Dynamic Memory PDF

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.
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; 42 int i
p1 = &i;
int *p2
int *p1
Before
Pointers can be set with the usual assign operator.
int i = 42;
int * p1, *p2; 42 int i
p1 = &i;
//--------------
p2 = p1;
int *p2
int *p1
After
Contents of pointer variables can be set with the
assign operator.
42 int i 17 int j
int i = 42;
int j = 17
int * p1, *p2;
p1 = &i;
int *p2
p2 = &j; int *p1
Before
Contents of pointers variables can be set with the assign
operator.
17 int i 17 int j
*p1 = *p2;
Value of location pointed int *p2

int *p1
to by p2 copied to
location pointed to by p1 After
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 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.
Free Store (heap)
int * myIntPtr
myIntPtr = new int;
myIntPtr
Use pointer variable as before
Free Store (heap)
12 3
int * myIntPtr
myIntPtr myIntPtr = new int;
*myIntPtr = 123;
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.
Free Store (heap)
0 int * myIntPtr;
myIntPtr myIntPtr = new int[4];
1 3 2 5
2
3 myIntPtr[1] = 325;
Notice that the pointer symbol is

understood, no * is used to reference
the array element.
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;
222
set_value(main_ptr);
main_ptr
----------------------------------------
-
void set_value(int * tempPtr)
{
*tempPtr = 222; tempPtr
}
Pointers and Arrays as Parameters
int *main_ptr;
main_ptr = new int[4];
main_ptr 222
----------------------------------------
-
void set_value(int tempPtr[])
{
tempPtr[1] = 222; tempPtr
}
Pointers and Arrays as Const
Parameters
int *main_ptr;
main_ptr = new int[4];
main_ptr
-----------------------------------------
void set_value(const int
tempPtr[])
{
tempPtr[1] = 222;
} 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 42 Returned to
Delete p1;
free store
int *p2 int *p1

int *p1
int *p2
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.
42 17 42 17
An inaccessable
int *p1 int *p2 int *p1 int *p2 object
p2 = p1;
An inaccessable memory location can also be
caused by inappropriate use of new operator.
42 42
An inaccessable
int *p1 object int *p1
p1 = new int;
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.
What we wanted.
int * myIntPtr;
0 0 myIntPtr = new int[4];
myIntPtr 1 1
2 2 int * myIntPtr2;
3 3
myIntPtr2 = myIntPtr;
myIntPtr2
Not the default
Free Store (heap) behavior of ‘=‘
What we got!
int * myIntPtr;
0 myIntPtr = new int[4];
myIntPtr 1
2 int * myIntPtr2;
3
myIntPtr2 = myIntPtr;
myIntPtr2
Free Store (heap)

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];
}
}
0 A 0 A
1 B
oldClass
data 1 B
2 C 2 C
3 D 3 D
Free Store (heap)

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.
0 A A
0
1 B oldClass
data 1 B
2 C 2 C
3 D 3 D
4
5
6
delete [ ] oldClass;
0 A A
0
1 B oldClass
data 1 B
2 C 2 C
3 D 3 D
4
5 Return
6
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.

Dynamic Memory PDF

Uploaded by

Copyright:

Available Formats

Dynamic Memory PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Dynamic Memory PDF

Uploaded by

Copyright:

Available Formats

Pointers and Dynamic Memory

A pointer is the memory address of a variable.

A memory address is a physical location within a

A pointer variable is variable used to hold a pointer.

We can declare a pointer variable:

Type of data pointed to (int), pointer symbol (*),

Where: int myInt was declared earlier in the

cout << *myIntPtr << endl;

If we had previously executed the statement

We would see ‘42’ in the output.

Value of location pointed int *p2

The real power of pointers is seen when

Let’s see why.

•They are not declared, so they have no identifiers

•They are created during run time, not when the

Storage for these variables comes from an area of

The creation of new dynamic variables is called

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

Here are the steps:

int * myIntPtr; // create an integer pointer variable

new returns a pointer (or memory address) to the

This allows a program to ask for just the amount of

Notice that the pointer symbol is

When you are done using a memory location, it is

delete myIntPtr; // Deletes the memory pointed

The memory pool for dynamic memory allocation is

Dynamic memory can be returned to the free store

This is accomplished by using a reference

void change_location(int* & refPtr)

typedef int* inPtr;

void functionEx(inPtr & localPtr);

Pointers should always point to something. When a

delete myIntPtr; // return memory to free store

An unassigned pointer variable must not be

A “null” pointer value should not be dereferenced.

A pointer left pointing is called a dangling pointer.

int *p2 int *p1

The automatic behavior produces what is called a

Free Store (heap)

We must overload the assignment operator.

We must provide a copy constructor.

We also need to add a destructor member function.

A copy constructor is a special constructor called

DynamicClass newClass = oldClass;

Free Store (heap)

When the capacity of the original array is used up,

After the data has been copied, we can delete the

Like the constructor, the destructor does not return any

It’s use does require more care on the part of the

However, the benefits generally outweigh the disadvantages

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

int p2 int p1