pointers and dynamic memory

A pointer is the memory address of a variable.

A memory address is a physical location within a system’s memory space.

A pointer variable is variable used to hold a pointer. It is a special data type.

Pointers and Dynamic Memory

A pointer variable can be assigned a pointer (memory address).

We can declare a pointer variable:

int * myIntPtr;

Type of data pointed to (int), pointer symbol (*), variable name (myIntPtr).


We can assign a memory address (pointer) to the variable: (& is called the address-of operator)

myIntPtr = &myInt;

Where: int myInt was declared earlier in the program.


We can refer to the value in the location pointer to by myIntPtr with the dereferencing operator * as follows:

cout << *myIntPtr << endl;

If we had previously executed the statement int myInt =42;

We would see ‘42’ in the output.



Pointers can be set with the usual assign operator.

int i = 42;int * p1, *p2;p1 = &i;

42

int *p1int *p2

int i

Before


Pointers can be set with the usual assign operator.

int i = 42;int * p1, *p2;p1 = &i;//--------------p2 = p1;

42

int *p1int *p2

int i

After


Contents of pointer variables can be set with the assign operator.

int i = 42;int j = 17int * p1, *p2;p1 = &i;p2 = &j;

42

int *p1int *p2

int i

Before

17 int j


Contents of pointers variables can be set with the assign operator.

*p1 = *p2; 17

int *p1int *p2

int i

After

17 int j

Value of location pointed to by p2 copied to

location pointed to by p1


The real power of pointers is seen when they are used to point to dynamically allocated variables.

Let’s see why.


Dynamic variables are used just like ordinary static variables except:

•They are not declared, so they have no identifiers like static variables do.

•They are created during run time, not when the program is compiled.


Storage for these variables comes from an area of memory called the free store or the heap.

The creation of new dynamic variables is called memory allocation and the memory is called dynamic memory.

C++ uses the new operator create a dynamic variable.


Here are the steps:

int * myIntPtr; // create an integer pointer variablemyIntPtr = new int; // create a dynamic variable

// of the size integer

new returns a pointer (or memory address) to the location where the data is to be stored.


Free Store (heap)

myIntPtr

int * myIntPtrmyIntPtr = new int;


Free Store (heap)

myIntPtr

int * myIntPtrmyIntPtr = new int;

*myIntPtr = 123;

1 2 3

Use pointer variable as before


We can also allocate entire arrays with the new operator. These are called dynamic arrays.

This allows a program to ask for just the amount of memory space it needs at run time.

Pointers and Dynamic MemoryFree Store (heap)

myIntPtrint * myIntPtr;myIntPtr = new int[4];

Notice that the pointer symbol isunderstood, no * is used to referencethe array element.

3 2 5

myIntPtr[1] = 325;

0

2

1

3


The new operator gets memory from the free store (heap).

When you are done using a memory location, it is your responsibility to return the space to the free store. This is done with the delete operator.

delete myIntPtr; // Deletes the memory pointed

delete [ ] arrayPtr; // to but not the pointer variable


Dynamic memory allocation provides a more flexible solution when memory requirements vary greatly.

The memory pool for dynamic memory allocation is larger than that set aside for static memory allocation.

Dynamic memory can be returned to the free store and allocated for storing other data at later points in a program. (reused)

Pointers and Arrays as Parameters

int *main_ptr;main_ptr = new int;

set_value(main_ptr);-----------------------------------------

void set_value(int * tempPtr){

*tempPtr = 222;}

222

main_ptr

tempPtr

Pointers and Arrays as Parameters

int *main_ptr;main_ptr = new int[4];

set_value(main_ptr);-----------------------------------------

void set_value(int tempPtr[]){

tempPtr[1] = 222;}

222main_ptr

tempPtr

Pointers and Arrays as Const Parameters

int *main_ptr;

main_ptr = new int[4];

set_value(main_ptr);

-----------------------------------------

void set_value(const int tempPtr[])

{

tempPtr[1] = 222;

}

main_ptr

Not allowed


Sometimes we may want a function to change a pointer so that it points to a different location

This is accomplished by using a reference parameter that is a pointer type

void change_location(int* & refPtr)


We often use a typedef statement to simplify the cumbersome syntax.

typedef int* inPtr;

inPtr myIntPtr;

void functionEx(inPtr & localPtr);


Some things to be careful with when using pointers.

Pointers should always point to something. When a object pointed to is no longer needed, the memory should be freed with delete and the pointer should be assigned the special value null, defined in the stddef.h header file.

delete myIntPtr; // return memory to free store

myIntPtr = null; // point to special “nothing” value.


A pointer not pointing to an object is considered “unassigned”.

An unassigned pointer variable must not be dereferenced.

A “null” pointer value should not be dereferenced.

A pointer left pointing is called a dangling pointer.


Dangling pointers can occur when two or more pointers point to the same object and one of the pointers is used with the delete operator.

42

int *p1int *p2

42

int *p1int *p2

Delete p1;Returned to

free store

A dangling pointer


An inaccessable memory location, also called a memory leak, results from the reassignment of a pointer without first releasing the memory it pointed to.

An inaccessable

object

42

int *p1 int *p2

17

p2 = p1;

42

int *p1 int *p2

17


An inaccessable memory location can also be caused by inappropriate use of new operator.

An inaccessable

object

42

int *p1

p1 = new int;

42

int *p1


Pointers also introduce potential problems with the behavior of the automatic assignment operator, the copy operation, and the comparison operation.

The automatic behavior produces what is called a shallow copy. Both pointers point to the same object. What we want is a deep copy. We want a copy of the data not just the pointer.


Free Store (heap)

myIntPtr

int * myIntPtr;myIntPtr = new int[4];

int * myIntPtr2;

myIntPtr2 = myIntPtr;

0

2

1

3

myIntPtr2

0

2

1

3

Not the default

behavior of ‘=‘

What we wanted.


Free Store (heap)

myIntPtr

int * myIntPtr;myIntPtr = new int[4];

int * myIntPtr2;

myIntPtr2 = myIntPtr;

0

2

1

3

myIntPtr2

What we got!


To handle this and other dynamic data situations, we must add additional member functions to any class that uses dynamic data. Some additional functions would want:

We must overload the assignment operator.

We must provide a copy constructor.

We also need to add a destructor member function.


Let’s look at the copy constructor. The principles are the same for the assignment operator overload.

A copy constructor is a special constructor called when a new instance of a class is created from an existing object of that class.

DynamicClass newClass(oldClass);

DynamicClass newClass = oldClass;


Class DynamicClass

{

public:

DynamicClass (const DynamicClass & oldClass);

void operator =(const DynamicClass & oldClass);

~DynamicClass ();

…};


DynamicClass::DynamicClass

(const DynamicClass& oldClass)

{

data = new Item[someSize];

for (int i=0; i < oldClass.currentSize; i++)

{

data[i] = oldClass[i];

}

}


Free Store (heap)

data

A

B

C

D

0

2

1

3

A

B

C

D

0

2

1

3

oldClass


Now let’s apply what we’ve learned to resizing a dynamically allocated array.

When the capacity of the original array is used up, we want to allocate a new larger array and copy the data from the original array to the new larger array.

After the data has been copied, we can delete the original array and return the memory to free store.


data

A

B

C

D

0

2

1

3

A

B

C

D

0

2

1

3

oldClass

45

6


data

A

B

C

D

0

2

1

3

A

B

C

D

0

2

1

3

oldClass

45

6

delete [ ] oldClass;

Return

memory


Class DynamicClass

{

public:

DynamicClass (const DynamicClass & oldClass);

void operator =(const DynamicClass & oldClass);

~DynamicClass ();

…};


When we are finished using a class instance, we must free any memory pointed to by variables in the class. This is done automatically by invoking the code contained in the class destructor. Failure to do so creates memory leaks.

Like the constructor, the destructor does not return any data type. It has the same name as the class name but is preceded by the ‘~’ symbol.

DynamicClass::~DynamicClass() { }


The use of pointers and dynamic variables is an important

problem solving tool. It gives the class builder flexibility in managing memory.

It’s use does require more care on the part of the programmer, since control is now in the hands of the programmer and not the system.

However, the benefits generally outweigh the disadvantages and C++ programs make heavy use of dynamic memory.

pointers and dynamic memory

Documents

dynamic memorywe

dynamic memorypointers

dynamic arrays

dynamic memoryhere

dynamic memorystorage

pointer memory address

memory address pointer

location pointer