Pointers

What Is Pointer every variable has 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 pointer (variable) C++ provides an abstraction of pointer

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

name memory address

i’y’c2

0021 0022

0021cp

name memory address

i’y’c2

0021 0022

cp

2

Pointer Syntax 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;

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

pointer to a pointer is legal and sometimes used: char **cpp; pointer can be assigned 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’;

note that star at declaration is not a dereference operator – it just signifies that the variable is a pointer.

3

Using Pointers pointer can be assigned a value at declaration

char *cp2=&c2;

int *ip;

pointer 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;

4

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;

5

Array Names and Constant Pointers array name 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 references first

// element of an array an array name can be used as name and as 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!

6

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

int a[5], *p = a;p = p + 1; // p points to 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 may be clearer to understand– error prone

7

Null Pointer/Loose Pointer Problem a pointer that is not initialized holds arbitrary value assigning a value to the location 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 is? nullptr is a constant that is assigned to a pointer that does not have a

value

int *ptr = nullptr; assigning nullptr to pointer does not eliminate loose pointer problem

but it is a convenient constant to compare to

int *ptr2 = nullptr, i=5;

*ptr2 = 5; // ERROR - still loose

if (ptr2 == nullptr)

ptr2=&i;

cout << *ptr2;

8

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

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

points to:

cout << obp->getd();

9