C++ Pointers

1
 C++ Data Types

simple structured

integral enum floating array struct union class

char short int long bool

float double long double address

pointer reference
2
 Pointers

• A pointer is the memory address of a

variable
– When a variable is used as a call-by-reference
argument, its address is passed

– An address used to tell where a variable is stored

in memory is a pointer

3
Slide 3
 Few important pointer Concepts:
1. Null Pointers: which is a constant with a value of zero defined in
several standard libraries. NULL is a special value that indicates an
empty pointer
2. Dangle Pointer: A pointer pointing to a memory location that has
been deleted (or freed).
3. Pointer Arithmetic
4. There are four arithmetic operators that can be used on pointers:
++, --, +, -
4. Pointers vs Arrays:
There is a close relationship between pointers and arrays.
5. Passing Pointers to Functions
• Passing an argument by reference or by address both enable the
passed argument to be changed in the calling function by the
called function.
• Return Pointer from Functions
6. C++ allows a function to return a pointer to local variable, static4
 Declaring Pointers
• Pointer variables must be declared to have a
pointer type
– Example: To declare a pointer variable p that can
"point" to a variable of type double:
double *p;
All are the same:
int* p = 0;
int *p = 0;
int * p = 0;
int*p = 0;
– The asterisk identifies p as a pointer variable

All pointers, when they are created, should be initialized to

some value, even if it is only zero. A pointer whose value is zero is
called a null pointer.
5
Slide 5
 The * appears before the pointer variable
in only TWO places:

1. when you declare a pointer variable, and

2. when you de-reference a pointer variable (point to (access)
the data whose address is stored in the pointer)

6
 Assigning a value to a
dereferenced pointer
A pointer must have a value before you can
dereference it (follow the pointer).
int *x;
*x=3;
i ng! !!
R! ! ! o anyth
ERRO n’t point t
does
x

7
 Pointers
A pointer is a variable MEMORY
Address
that holds the address 0
of something else. 1
2
int foo; foo 3 123
int *x; 4
5

...

...
foo = 123;
x = &foo; x 81345 3
81346
81347
8
 &foo
In C++ you can get the address of a variable
with the “&” operator.
MEMORY
int foo; Address
0
1
foo = 123; 2
x = &foo; foo 3 123
4
5

...

...
&foo means “the address of foo”

9
 Using a Pointer Variable
2000
int x;
12
x = 12;
x

3000
int* ptr;
2000
ptr = &x;
ptr

NOTE: Because ptr holds the address of x,

we say that ptr “points to” x
10
 *: dereference operator
2000
int x;
12
x = 12;
x

3000
int* ptr;
2000
ptr = &x; ptr

cout << *ptr;

NOTE: The value pointed to by ptr is denoted by *ptr

11
Using the Dereference Operator
2000

12 5
int x;
x
x = 12;
3000

2000
int* ptr;
ptr
ptr = &x;
// changes the value at the
*ptr = 5;
address ptr points to 5

12
 Self –Test on Pointers
4000
char ch;
A Z
ch = ‘A’;
ch

char* q; 5000 6000

q = &ch; 4000 4000

q p
*q = ‘Z’;
char* p;
// now p and q both point to ch
p = q;
Pointer Assignments
13
 Pointer Assignment

• The assignment operator = is used to assign

the value of one pointer to another
– Example: If p1 still points to v1 (previous
slide)
then
p2 = p1;

causes *p2, *p1, and v1 all to name

the same variable
14
Slide 14
 Caution! Pointer Assignments

• Some care is required making assignments to

pointer variables
– p1= p2; // changes the location that p1 "points" to

– *p1 = *p2; // changes the value at the location

that
// p1 "points" to

15
Slide 15
 16
Slide 16
Example:
int Count = 10; // declare and initialize a regular int
variable
int *pCount = 0; // declare and initialize an integer pointer
cout << *pCount ; // Takes you nowhere ??????????

• If the pointer is initialized to zero, you must

specifically assign the address to the pointer.

17
//Example - variable of type pointer
#include <iostream.h>
int main(void)
{
char first = 'A';
char second = 'B';
char *p = &first;
cout<< *p << endl; // dereference - output A
p = &second;
cout<< *p <<endl; //dereference - output B
p = &first;
*p = 'Z'; // set first to 'Z'
p = &second;
*p = 'Y';
cout << first << second <<endl; // output ZY
return 0;
} 18
 Arrays & Pointers
0 2 4

52 76 87

A[0] A[1] A[2]

Let's look at an array
with three elements:
int A[3];
*A *(A+1) *(A+2) by pointer
&A[0] &A[1] &A[2] by reference
Address examples 1000 1004 1008
// De-reference operator *
#include <iostream.h>
int main(void)
{
int A[3] = {52, 76, 87};
cout<< (*A) // 52
<< (*(A+1)) // 76
<< (*(A+2)) // 87
<< (*A + 1); // 76? Watch OUT -- Be Careful Precedence!!!
return 0;
} 19
 1000 a[0] = 2
1004 a[1] = 3
1008 a[2] = 4

The name of an array variable in C++, without the use of [ ],

represents the starting address of the array.
Array values are guaranteed to be in contiguous memory
these values can be accessed using a pointer:
20
21
 Pointers into Arrays
char msg[ ] =“Hello”;
msg
char* ptr; 3000

ptr = msg; ‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’

‘M’ ‘a’
*ptr = ‘M’ ;
ptr++;
*ptr = ‘a’; 3000
3001

ptr = &msg[4]; ptr

// *ptr = o
22
 Example: 1
#include <iostream>
using namespace std;

int main()
{
// Declare an array with 10 elements
int Marks [10]= {1,2,3,4,5,6,7,8,9,0};
// Print out the memory address of an array name
cout << Marks << endl;
// Print out the memory address of a first element of an array
cout << &Marks[0] << endl;
// Print out value of the first element by dereferencing a array
name
cout << *Marks << endl;
return 0;
}
0xbf83d3fc
0xbf83d3fc
23
1
Passing pointers as parameters/By Value:

void swap( int *x, int *y) {

int tmp;

tmp = *x;
*x = *y;
*y = tmp;
}

24
Passing pointers as parameters
/By Reference:

void swap( int *&x, int *&y)

{
int tmp;
int *tmp = x;
x = y;
y = tmp;
}

25
 Pointers to Structure
struct temp { class temp {
int i; public:
float f; int i;
}; float f;
};
int main() {
temp abc = {10,20}; //Static int main() {
temp *ptr = &abc; temp abc = {10,20}; //Static
temp *ptr1 = new temp; temp *ptr = &abc;
//Dynamic temp *ptr1 = new temp; //Dynamic
(*ptr).i = 20; (*ptr).i = 20;
ptr->f = 30; ptr->f = 30;
return 0; return 0;
} }

(.) Dot and -> (Arrow) Operators

26