C++ Pointers and Functions

const references allow you to specify that the data referred to won't be changed. A const reference is actually a reference to const. A reference is inherently const, so when we say const reference, it is not a reference that can not be changed, rather it’s a reference to const. Once a reference is bound to refer to an object, it can not be bound to refer to another object. For example:

int &ri = i;

binds ri to refer to i. Then assignment such as:

ri = j;

doesn’t bind ri to j. It assigns the value in j to the object referenced by ri, ie i;

This means, if we pass arguments to a function by const references; the function can not change the value stored in those references. This allows us to use const references as a simple and immediate way of improving performance for any function that currently takes objects by value without having to worry that your function might modify the data. The compiler will throw an error if the function tries to modify the value of a const reference.

An object’s state is returned without modifying the object’s abstract state by using a function called inspector. Invoking an inspector does not cause any noticeable change in the object’s behavior of any of the functions of that object.

A mutator, on the other hand, changes the state of an object which is noticeable by outsiders. It means, it changes the abstract state of the object.

The following code snippet depicts the usage of these two functions:

class ShoppingCart {

public:

int addItem(); //Mutator

int numItems() const; //Inspector

};

The function addItems() is a mutator. The reason is that it changes the ‘ShoppingCart’ by adding an item.

The function numItems() is an inspector. The reason is that it just updates the count of number of items in the ‘ShoppingCart’. The const declaration followed by int numItems() specifies that numItems() never change the ‘ShoppingCart’ object..

When a member function is called, it is automatically passed an implicit argument that is a pointer to the invoking object (ie the object on which the function is invoked). This pointer is known as this pointer. It is internally created at the time of function call.

The this pointer is very important when operators are overloaded.

Example: Consider a class with int and float data members and overloaded Pre-increment operator ++:

class MyClass

{

int i;

float f;

public:

MyClass ()

{

i = 0;

f = 0.0;

}

MyClass (int x, float y)

{

i = x; f = y;

}

MyClass operator ++()

{

i = i + 1;

f = f + 1.0;

return *this; //this pointer which points to the caller object

}

MyClass show()

{

cout<<”The elements are:n” cout<i<<”n<f; //accessing

data members using this

}

};

int main()

{

MyClass a;

++a; //The overloaded operator function ++()will return a’s this

pointer

a.show();

retun 0;

}

The o/p would be:

The elements are:

1

1.0

not to a specific instance of that member in an object. This type of pointer is called a pointer to a class member or a pointer-to-member. It is not same as normal C++ pointer. Instead it provides only an offset into an object of the member’s class at which that member can be found. Since member pointers are not true pointers, the . and -> can not be applied to them. Instead we must use the special operators .* and ->* . They allow access to a member of a class.

Example:

#include <iostream>

using namespace std;

class MyClass

{

public:

int val;

MyClass(int i)

{

val = i;

}

int double_val()

{

return val + val;

}

};

int main()

{

int MyClass::*data; //data member pointer

int(MyClass::*func)(); //function member pointer

MyClass obj1(1), obj2(2); //create objects

data =&MyClass::val; //get offset of data val

func=&MyClass::double_val; //get offset of function double_val()

cout << “The values are:”;

cout << ob1.*data << “ “ <<ob2.*data << “n”;

cout<< “Here they are doubled:”;

cout << (ob1.*func)() << “ “ <<(ob2.*func)()<< “n”;

return 0;

}

Here data and func are member pointers. As shown in the program, when declaring pointers to members, you must specify the class and use the scope resolution operator.

Smart pointers are objects which store pointers to dynamically allocated (heap) objects. They are like built-in C++ pointers. However, they automatically delete the object pointed to at the appropriate time. They are useful as they ensure proper destruction of dynamically allocated objects (Exceptions). They can also be used to keep track of dynamically allocated objects shared by multiple owners.

They appear as owning the object pointed to and are responsible for deletion of the object when it is no longer needed.

The smart pointer library provides five smart pointer class templates:

scoped_ptr : Simple sole ownership of single objects. Noncopyable.

scoped_array: Simple sole ownership of arrays. Noncopyable.

shared_ptr: Object ownership shared among multiple pointers

shared_array: Array ownership shared among multiple pointers.

weak_ptr: Non-owning observers of an object owned by shared_ptr.

intrusive_ptr: Shared ownership of objects with an embedded reference count.

These templates are designed to complement the std::auto_ptr template.

A function has a physical location in the memory which is the entry point of the function. And this is the address used when a function is called. This address can be assigned to a pointer. Once a pointer points to a function, the function can be called through that pointer. Function pointers also allow functions to be passed as arguments to other functions. The address of a function is obtained by using the function’s name without any parenthesis or arguments.

Consider following example:

#include <iostream>

using namespace std;

void check(char *a, char *b, int (*cmp) (const char*, const*));

int numcmp(const char *a, const char *b);

int main()

{

char s1[80], s2[80];

gets (s1);

gets (s2);

if (isalpha(*s1))

check(s1, s2, strcmp);

else

check(s1, s2, numcmp);

return 0;

}

void check(char *a, char *b, int (*cmp) (const char*, const*))

{

cout <<”Testing for equality n”;

if(!(*cmp)(a,b))

cout <<“Equal”;

else

cout <<“ Not Equal”;

}

int numcmp(const char *a, const char *b)

{

if(atoi(a) == atoi(b))

return 0;

else

return 1;

}

In this function, if you enter a letter, strcmp() is passed to check() otherwise numcmp() is used.

const pointer is a pointer which you don’t want to be pointed to a different value. That is, the location stored in the pointer can not change. We can not change where the pointer points. It is declared as:

type * const name

type is data type

name is name of the pointer

eg: char * const p

Since the location to which a const pointer points to can not be changed, the following code:

char ch1 = ‘A’;

char ch2 = ‘B’;

char * const p = &ch1;

p = &ch2;

will throw an error since address stored in p can not be changed.

const reference:

const references allow you to specify that the data referred to won't be changed. A const reference is actually a reference to const. A reference is inherently const, so when we say const reference, it is not a reference that can not be changed, rather it’s a reference to const. Once a reference is bound to refer to an object, it can not be bound to refer to another object. For example:

int &ri = i;

binds ri to refer to i. Then assignment such as:

ri = j;

doesn’t bind ri to j. It assigns the value in j to the object referenced by ri, ie i;

This means, if we pass arguments to a function by const references; the function can not change the value stored in those references. This allows us to use const references as a simple and immediate way of improving performance for any function that currently takes objects by value without having to worry that your function might modify the data. The compiler will throw an error if the function tries to modify the value of a const reference.

Pointer to constant points to a value that does not change and is declared as:

const type * name

type is data type

name is name of the pointer

e.g: const char *p;

pointer to constant can not be used to change the value being pointed to. Therefore:

char ch = ‘A’;

const char *p = &ch;

*p = ‘B’;

is not allowed. The program will throw an error.

Pointer Constant (or constant pointer) is a pointer which you don’t want to be pointed to a different value. That is, the location stored in the pointer can not change. We can not change where the pointer points. It is declared as:

type * const name

type is data type

name is name of the pointer

eg: char * const p

Since the location to which a const pointer points to can not be changed, the following code:

char ch1 = ‘A’;

char ch2 = ‘B’;

char * const p = &ch1;

p = &ch2;

will throw an error since address stored in p can not be changed.