Pointers

What Is A Pointer every variable has a memory address

char c=’y’;

int i=2; address of variable i is 0022 address can used to refer to this variable address can be stored in a variable of special

type called a pointer (variable) C++ provides an abstraction of a pointer

a pointer is used only to reference the variable it points to - we usually don’t think of pointers as holding an integer (address) but just a reference to a variable

name memory address

i’y’c2

0021 0022

0021cp

name memory address

i’y’c2

0021 0022

cp

Pointer Syntax A pointer variable is declared as follows:

typeOfVariablePointedTo *pointerName; example:

double *p;int *ip;

pointer declarations can be freely intermixed with ordinary variable declarations:

char *cp, c1=’y’, c2=’n’;int i, *ip;

The star can move to the type without changing semantics:int *i, j; is the same as int* i, j;

A pointer to a pointer is legal and sometimes used:char **cpp;

A pointer can be assigned a value using & (address of or reference) operator:cp = &c1; // until reassigned cp “points at” c1

the value of a variable the pointer points to can be accessed using * (dereference) operator: cout << *cp << endl;*cp = ’G’;

Using Pointers note that the star in the declaration is not a dereference opeartor – it just

signifies that the variable is a pointer. A pointer can be initialized in the declaration just like any other variable:

char *cp2=&c2;

int *ip=&i;

Apointer variable can point to multiple variables (in sequence) and multiple pointers can point at the same variable

what does this code fragment do?

int *ip1, *ip2, one=1, two=2;

ip1=&one;

ip2=ip1;

*ip1 = *ip1 + 1;

ip1=&two;

*ip1 -= 1;

cout << *ip2 << ” ” << *ip1;

Constants and Pointers a constant pointer is a pointer construct where we cannot

change the location to which the pointer points

char c = 'c';

const char d = 'd';

char *const ptr1 = &c;

ptr1 = &d; // illegal a pointer to a constant value is a pointer object where the value

at the location to which the pointer points is considered constant

const char *ptr2 = &d;

*ptr2 = 'e'; // illegal: cannot change d

// through dereferencing ptr2 the following also declares a pointer to a constant

char const *ptr2 = &d;

Array Names and Constant Pointers An array indicator is in fact a constant pointer example

int *p; // this is a pointerint a[SIZE]; // this is an array// int *const a; plus memory allocation// is equivalentp = a; // now pointer p references the

// first element of an array an array name can be used as a name and as a pointer:

a[3]=22; // as array name: applying indexingp = a; // as pointer

a pointer can also be used similarlyp[4]=44; // as namep = a; // as pointer

since array name is a constant pointer – its modification is not legala=p; // ERROR!

Pointer Arithmetic array elements are guaranteed to be in continuous memory locations adding one to a pointer advances it one memory location of the specified type

int a[5], *p = a;p = p + 1; // p points to the second element of array

gives alternative way to manipulate arrays allowed pointer operations: add/subtract integer, compound assignment,

increment, decrement, subtract two pointers of the same type (what’s the purpose of that?)p++; // moves p one position to the right – points to

// third element of arrayp -=2; // moves p two positions to the leftcout << p – a; // prints how many elements between p and a

other arithmetic operations, like pointer division or multiplication, are not allowed regular and pointer arithmetic operations can be intermixed

*(p++) = 22; // what does this do? caution

use only on continuous memory locations terse but obscure

– indexing is clearer to understand– error prone

NULL Pointer/Loose Pointer Problem a pointer that is not initialized holds an arbitrary value assigning a value to the location an uninitialized pointer points to can

lead to unpredictable results: loose (dangling) pointer problem

int *ptr;

*ptr = 5; // ERROR - loose pointer! what do you think the result of this assignment can be? NULL is a constant that is assigned to a pointer that does not have a

value

int *ptr = NULL; assigning NULL to a pointer does not eliminate the loose pointer

problem but it is a convenient constant to compare to

int *ptr2 = NULL, i=5;

*ptr2 = 5; // ERROR - still loose

if (ptr2 == NULL)

ptr2=&i;

cout << *ptr2;

Pointers to Objects pointers can point to objects:

myclass{

public:

void setd(int i){d=i;};

int getd() const {return d;};

private:

int d;

};

myclass ob1, *obp=&ob1; members can be accessed using pointers:

(*obp).setd(5); parentheses around (*obp) are needed because dot-operator has higher

priority than dereferencing a shorthand -> is used for accessing members of the object the pointer

points to:

cout << obp->getd();