Pointers and Dynamic Memory

1
Pointers and Dynamic Memory
A pointer is the memory address of a variable. A
memory address is a physical location within a
systems memory space. A pointer variable is
variable used to hold a pointer. It is a special
data type.
2
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).
3
Pointers and Dynamic Memory
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.
4
Pointers and Dynamic Memory
We can refer to the value in the location pointer
to by myIntPtr with the dereferencing operator
as follows cout ltlt myIntPtr ltlt endl If we
had previously executed the statement int myInt
42 We would see 42 in the output.
5
Pointers and Dynamic Memory
Pointers can be set with the usual assign
operator.
int i 42 int p1, p2 p1 i
int i
42
int p2
int p1
Before
6
Pointers and Dynamic Memory
Pointers can be set with the usual assign
operator.
int i 42 int p1, p2 p1
i //-------------- p2 p1
int i
42
int p2
int p1
After
7
Pointers and Dynamic Memory
Contents of pointer variables can be set with the
assign operator.
int j
17
int i
42
int i 42 int j 17 int p1, p2 p1 i p2
j
int p2
int p1
Before
8
Pointers and Dynamic Memory
Contents of pointers variables can be set with
the assign operator.
int j
17
int i
p1 p2
17
int p2
Value of location pointed to by p2 copied to
location pointed to by p1
int p1
After
9
Pointers and Dynamic Memory
The real power of pointers is seen when they are
used to point to dynamically allocated variables.
Lets see why.
10
Pointers and Dynamic Memory

• 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.

11
Pointers and Dynamic Memory
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.
12
Pointers and Dynamic Memory
Here are the steps int myIntPtr // create
an integer pointer variable myIntPtr 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.
13
Pointers and Dynamic Memory
Free Store (heap)
int myIntPtr myIntPtr new int
myIntPtr
14
Pointers and Dynamic Memory
Use pointer variable as before
Free Store (heap)
1 2 3
int myIntPtr myIntPtr new int
myIntPtr
myIntPtr 123
15
Pointers and Dynamic Memory

• 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.

16
Pointers and Dynamic Memory
Free Store (heap)
int myIntPtr myIntPtr new int4
0
myIntPtr
3 2 5
1
2
myIntPtr1 325
3
Notice that the pointer symbol is understood, no
is used to reference the array element.
17
Pointers and Dynamic Memory

• 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

18
Pointers and Dynamic Memory
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)
19
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
20
Pointers and Arrays as Parameters

• int main_ptr
• main_ptr new int4
• set_value(main_ptr)
• -----------------------------------------
• void set_value(int tempPtr)
• tempPtr1 222

222
main_ptr
tempPtr
21
Pointers and Arrays as Const Parameters

• int main_ptr
• main_ptr new int4
• set_value(main_ptr)
• -----------------------------------------
• void set_value(const int tempPtr)
• tempPtr1 222

main_ptr
Not allowed
22
Pointers and Dynamic Memory
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)
23
Pointers and Dynamic Memory
We often use a typedef statement to simplify the
cumbersome syntax. typedef int inPtr inPtr
myIntPtr void functionEx(inPtr localPtr)
24
Pointers and Dynamic Memory
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.
25
Pointers and Dynamic Memory
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.
26
Pointers and Dynamic Memory
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.
Returned to free store
42
42
Delete p1
int p2
int p1
int p1
int p2
A dangling pointer
27
Pointers and Dynamic Memory
An inaccessable memory location, also called a
memory leak, results from the reassignment of a
pointer without first releasing the memory it
pointed to.
42
42
17
17
An inaccessable object
int p2
int p1
int p1
int p2
p2 p1
28
Pointers and Dynamic Memory
An inaccessable memory location can also be
caused by inappropriate use of new operator.
42
42
An inaccessable object
int p1
int p1
p1 new int
29
Pointers and Dynamic Memory
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.
30
Pointers and Dynamic Memory
What we wanted.
int myIntPtr myIntPtr new int4 int
myIntPtr2 myIntPtr2 myIntPtr
0
0
1
1
myIntPtr
2
2
3
3
myIntPtr2
Not the default behavior of
Free Store (heap)
31
Pointers and Dynamic Memory
What we got!
int myIntPtr myIntPtr new int4 int
myIntPtr2 myIntPtr2 myIntPtr
0
1
myIntPtr
2
3
myIntPtr2
Free Store (heap)
32
Pointers and Dynamic Memory
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.
33
Pointers and Dynamic Memory
Lets 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) Dyn
amicClass newClass oldClass
34
Pointers and Dynamic Memory
Class DynamicClass public DynamicClass (const
DynamicClass oldClass) void operator (const
DynamicClass oldClass) DynamicClass ()
35
Pointers and Dynamic Memory
DynamicClassDynamicClass (const DynamicClass
oldClass) data new ItemsomeSize for (int
i0 i lt oldClass.currentSize i) datai
oldClassi
36
Pointers and Dynamic Memory
A
A
0
0
oldClass
B
1
B
1
data
C
2
C
2
D
3
D
3
Free Store (heap)
37
Pointers and Dynamic Memory
Now lets apply what weve 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.
38
Pointers and Dynamic Memory
A
0
A
0
oldClass
B
1
B
1
data
C
2
C
2
D
3
D
3
4
5
6
39
Pointers and Dynamic Memory
delete oldClass
A
0
A
0
oldClass
B
1
B
1
data
C
2
C
2
D
3
D
3
4
5
Return memory
6
40
Pointers and Dynamic Memory
Class DynamicClass public DynamicClass (const
DynamicClass oldClass) void operator (const
DynamicClass oldClass) DynamicClass ()
41
Pointers and Dynamic Memory
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()
42
Pointers and Dynamic Memory
The use of pointers and dynamic variables is an
important problem solving tool. It gives the
class builder flexibility in managing memory.
Its 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.