Pointers, Dynamic Data, and

Reference Types
• Review on Pointers
• Reference Variables
• Dynamic Memory Allocation
– The new operator
– The delete operator
– Dynamic Memory Allocation for Arrays

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
 Recall that . . .
char str [ 8 ];

• str is the base address of the array.

• We say str is a pointer because its value is an address.
• It is a pointer constant because the value of str itself
cannot be changed by assignment. It “points” to the
memory location of a char.

6000

‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’

str [0] [1] [2] [3] [4] [5] [6] [7]

3
 Addresses in Memory
• When a variable is declared, enough memory to hold a value
of that type is allocated for it at an unused memory location.
This is the address of the variable

int x;
float number;
char ch;

2000 2002 2006

x number ch
4
 Obtaining Memory Addresses
• The address of a non-array variable can be obtained by using
the address-of operator &
2000 2002 2006
int x;
float number;
x number ch
char ch;

cout << “Address of x is “ << &x << endl;

cout << “Address of number is “ << &number << endl;

cout << “Address of ch is “ << &ch << endl;

5
 What is a pointer variable?

• A pointer variable is a variable whose value is the address of a

location in memory.

• To declare a pointer variable, you must specify the type of

value that the pointer will point to, for example,

int* ptr; // ptr will hold the address of an int

char* q; // q will hold the address of a char

6
 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
7
 *: 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

8
Using the Dereference Operator
2000
int x;
12 5
x = 12;
x

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

*ptr = 5;
// changes the value at the
address ptr points to 5
9
 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;
p = q; // the rhs has value 4000

// now p and q both point to 10ch

 Using a Pointer to Access the
Elements of a String
char msg[ ] =“Hello”;
msg
char* ptr;
3000
ptr = msg;
‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’
*ptr = ‘M’ ;
‘M’ ‘a’
ptr++;
*ptr = ‘a’;
3000
3001

ptr

11
 Reference Variables
Reference variable = alias for another variable
- Contains the address of a variable (like a pointer)
- No need to perform any dereferencing (unlike a pointer)
- Must be initialized when it is declared

int x = 5;
int &z = x; // z is another name for x
int &y ; //Error: reference must be initialized
cout << x << endl; -> prints 5
cout << z << endl; -> prints 5

z = 9; // same as x = 9;

cout << x << endl; -> prints 9

cout << z << endl; -> prints 9
12
 Why Reference Variables
• Are primarily used as function parameters

• Advantages of using references:

– you don’t have to pass the address of a variable
– you don’t have to dereference the variable inside the
called function

13
 Reference Variables Example
#include <iostream.h>
void p_swap(int *a, int *b)
{
// Function prototypes
(required in C++) int temp;
temp = *a; (2)
void p_swap(int *, int *); *a = *b; (3)
*b = temp;
void r_swap(int&, int&);
}
int main (void){
void r_swap(int &a, int &b)
int v = 5, x = 10;
{
cout << v << x << endl;
int temp;
p_swap(&v,&x);
temp = a; (2)
cout << v << x << endl;
a = b; (3)
r_swap(v,x); b = temp;
cout << v << x << endl; }
return 0;
14
}
 Dynamic Memory Allocation
In C and C++, three types of memory are used by programs:

• Static memory - where global

and static variables live

• Heap memory - dynamically

allocated at execution time
- "managed" memory accessed
using pointers

• Stack memory - used by

automatic variables

15
 3 Kinds of Program Data
• STATIC DATA: Allocated at compiler time

• DYNAMIC DATA: explicitly allocated and

deallocated during program execution by C++
instructions written by programmer using operators
new and delete
• AUTOMATIC DATA: automatically created at
function entry, resides in activation frame of the
function, and is destroyed when returning from
function
16
Dynamic Memory Allocation Diagram
High-end

Run-time allocated
Stack

memory
Heap

Compile-time
static data

allocated
memory
Program
code

Low-end

17
 Dynamic Memory Allocation
• In C, functions such as malloc() are used to
dynamically allocate memory from the Heap.
• In C++, this is accomplished using the new and
delete operators
• new is used to allocate memory during execution time
– returns a pointer to the address where the object is
to be stored
– always returns a pointer to the type that follows the
new
18
 Operator new Syntax

new DataType

new DataType [IntExpression]

• If memory is available, in an area called the heap (or free

store) new allocates the requested object or array, and
returns a pointer to (address of ) the memory allocated.
• Otherwise, program terminates with error message.
• The dynamically allocated object exists until the delete
operator destroys it.
19
 Operator new
2000
char* ptr; ???
5000

ptr
ptr = new char;
5000
*ptr = ‘B’; ‘B’

cout << *ptr;

NOTE: Dynamic data has no variable name

20
 The NULL Pointer
• There is a pointer constant called the “null pointer”
denoted by NULL
• But NULL is not memory address 0.
• NOTE: It is an error to dereference a pointer whose
value is NULL. Such an error may cause your
program to crash, or behave erratically. It is the
programmer’s job to check for this.

while (ptr != NULL) {

. . . // ok to use *ptr here
} 21
 Operator delete Syntax

delete Pointer

delete [ ] Pointer

• The object or array currently pointed to by Pointer is

deallocated, and the value of Pointer is undefined. The
memory is returned to the free store.
• Good idea to set the pointer to the released
memory to NULL
• Square brackets are used with delete to deallocate a
dynamically allocated array.
22
 Operator delete
2000
char* ptr; 5000
???

ptr
ptr = new char;
5000
*ptr = ‘B’; ‘B’
NOTE:
cout << *ptr; delete deallocates the
memory pointed to by ptr
delete ptr;
23
 Example
char *ptr ;
3000
ptr
ptr = new char[ 5 ]; ???
NULL
6000
???

strcpy( ptr, “Bye” );

ptr[ 0 ] = ‘u’; 6000

‘B’ ‘y’ ‘e’ ‘\0’
delete [] ptr; ‘u’
// deallocates the array pointed to by ptr
ptr = NULL; // ptr itself is not deallocated
// the value of ptr becomes undefined

24
 Pointers and Constants
char* p;
p = new char[20];

char c[] = “Hello”;

const char* pc = c; //pointer to a constant
pc[2] = ‘a’; // error
pc = p;

char *const cp = c; //constant pointer

cp[2] = ‘a’;
cp = p; // error

const char *const cpc = c; //constant pointer to a const

cpc[2] = ‘a’; //error
cpc = p; //error
25
 Take Home Message
• Be aware of where a pointer points to, and
what is the size of that space.

• Have the same information in mind when

you use reference variables.

• Always check if a pointer points to NULL

before accessing it.
26