Transcript General

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
c
i
’y’
2
cp
0021
0022
0021
name memory address
c
i
’y’
2
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’;
3
Using Pointers


note that star at declaration is not a dereference opeartor – it just signifies
that the variable is a pointer.
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 pointer
int a[SIZE]; // this is an array
// int *const a; plus memory allocation
// is equivalent
p = 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 indexing
p = a;
// as pointer
a pointer can also be used similarly
p[4]=44; // as name
p = a;
// as pointer
since array name is a constant pointer – its modification is not legal
a=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 array
p -=2; // moves p two positions to the left
cout << 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