Dynamic Data Structures
Refer to dynamic memory allocation sections
in your text book.
E.g. Chapter 13 and Chapter 15 of Bronson.
Dynamic Memory Allocation
Static Allocation
Each variable is assigned storage for a pool of
memory
The location is fixed for life of variable
Arrays created statically
Size is fixed once
E.g. an array of 500 integers
int A[500];
May only use first few spaces. Rest is wasted
OR
E.g. an array of 5 integers
int B[5]
What if we need space for 6 integers?
2
Can we allocate space from our
pool of memory as required?
If we need more memory can we ask for
more?
If we need less can we free up
memory?
Can we do this while the program is
running?
3
Dynamic memory
Allows you to decide at run time how much
space is needed.
Very useful with lists, stacks and queues.
We do not have to worry about specifying an
upper limit to the size needed.
We can customise our lists to fit the amount of
information that will be stored.
We can expand and shrink the lists to respond to
additions and deletions
4
What do you need to do to reserve
memory dynamically?
You need a special sort of variable that holds an address
A pointer is a variable that holds an address.
You must use a special type of declaration to create a pointer
variable.
You need to know what sort of object will be created
You need to use a special notation
E.g to create a pointer that contains an address of an integer
int * x;
The asterisk informs the compiler that x holds an address. And that
this will be an address of an integer.
You also need two C++ operators for dynamic memory allocation
new and delete
5
Memory Pool
Every program is provided with a pool of
memory it can use during execution.
This is called the free store or heap
The size of this heap depends on your
system.
Local variables and function parameters
are stored in another pool called the
stack
6
To create an integer dynamically
1. #include <iostream.h>
2.
3. int main() {
4. int * x;
5. Create an integer
6. x = new int; dynamically
7.
8. *x = 8;
9. cout << “Address of x is “ << &x << endl;
10. cout << “Address stored in x is “ << x << endl;
11. cout << “Value stored at address “ << x << “ is “ << *x << endl;
12.
13. delete x;
14. return 0; delete from memory
15. }
7
Typical output: you will have different addresses!
Address of x is 0x0012FF7C
Address stored in x is 0x00300030
Value stored at address 0x00300030 is 8
Press any key to continue
8
Note
line 6: Allocation of memory
x = new int;
means grab enough memory for one integer from the heap and return its
address and store the address in x
line 13:
delete x;
free up the memory allocated for x for use by this and other programs.
9
Use of &.
Note
line 9: means address of
cout << “Address of x is “ << &x << endl;
means display the address of x
line 10:
cout << “Address stored in x is “ << x << endl;
displays what is stored in x. Since x is a pointer it too will be an address
Use of *.
Line 4: means x is a pointer
int * x;
Line 11: (*x) Dereferences pointer.
“at the address stored in” operator
cout << “Value stored at address “ << x << “ is “ << *x << endl;
Display the value “at the address stored in” x
10
What use is this?
We can grab any amount of memory from the heap
To grab enough memory for 100 integers all we need
is a pointer to hold one address (of an integer).
A request for memory for 100 ints using the new
operator.
new will grab contiguous space for 100 ints and
return the base address to the pointer
int *theData;
theData = new int[100];
This could be an expression. E.g. a variable. Suppose we had a data file
with an unknown number of records. A varaible nItems could be used to
count the number of records in the file. a block of memory could then
be allocated that can contain exaclty the records in the data files.
theData = new int[nItems]; 11
Another example
int *data;
cout << “Enter the number of items to be processed : ”;
cin >> nItems;
data = new int[nItems];
Note the use of square brackets. This looks like an array. Remember an array is a
contiguous block of memory. The array name holds the base address of that block
of memory.
An array name is a special kind of pointer!
The point is that once we allocate a block of memory dynamically we can treat the
pointer like an array.
See Demo 2
12
Dynamic structure Allocation
Suppose we have a declaration for a structure
struct myDataType {
char name[20];
char phoneNo[15];
float balance;
};
We can create a pointer to a structure.
myDataType * myPtr;
we can create a single object dynamically by
myPtr = new myDataType;
or a dynamically created array by
myPtr = new myDataType[100];
13
Accessing parts of a dynamically allocated structure
Normally to access fields of a structure we use the dot notation.
myDataType obj1;
cin >> obj1.name;
cin >> obj1.phoneNo
cin >> obj1.balance;
However if the structure was created dynamically we may be tempted to
access fields of the structure using the following syntax
myDataType *obj2;
obj2 = new myDataType;
cin >> *obj2.balance; // WRONG WILL NOT COMPILE!
to get it to work we would need to do
cin >> (*obj2).balance; //OK BUT YUCKY
14
SPECIAL SYNTAX FOR
Dynamic Structs and Classes
Because of the yucky syntax previously the C/C++ language
provide a more “natural” syntax to dereference dynamic structs and
classes.
cin >> obj2->name;
cin >> obj2->phoneNo;
cin >> obj2->balance;
15
Accessing parts of a dynamically allocated array of
structures
Warning: this is confusing!
However if we have an array of structures created dynamically we have to use
the normal syntax.
myDataType *obj2;
obj2 = new myDataType[5]; //reserve enough space for 5 myDataType objects
//initialise the first two structures
cin >> obj2[0].name;
cin >> obj2[0].phoneNo;
cin >> obj2[0].balance;
cin >> obj2[1].name;
cin >> obj2[1].phoneNo;
cin >> obj2[1].balance;
16
Passing a dynamically allocated atomic variable to a function
#include <iostream.h>
void ReadData(int *data);
int main() {
int *number;
number = new int; //created dynamically
ReadData(number); //pass by reference - pointer method
return 0;
} number contains an address
ReadData needs a parameter that
void ReadData(int *data) {
cin >> *data;
can store an address. data is a pointer
} so it can receive an address.
note to read a value in to the pointed
at address we use the dereference
operator. 17
Passing a dynamically allocated array to a function
This is exactly the same a passing a statically allocated array to a function
Example.
#include <iostream.h>
void ReadData(int data[], int n);
int main() {
int *number;
int nItems;
cout << "How many numbers are there to process? : ";
cin >> nItems;
number = new int[nItems]; //created dynamically
ReadData(number, nItems); //pass and use like a static array
return 0;
}
void ReadData(int data[], int n) {
int i;
for (i=0;i<n;i++)
cin >> data[i];
} 18
Passing a single structure to a function
//Supose we want a function that process a single structure.
#include <iostream.h>
struct myDataType {
char name[20];
int grade;
};
void ReadData(myDataType * rec);
int main() {
myDataType *newrecord;
DEMO5
newrecord = new myDataType; //created dynamically
ReadData(newrecord);
cout << newrecord->name << " " << newrecord->grade << endl;
delete record;
return 0;
}
void ReadData(myDataType *rec) {
cout <<" Enter a name : "; //NOTICE referencing of fields using ->
cin >> rec->name;
cout <<" Enter a grade : ";
cin >> rec->grade;
}
19
Passing an Array of structs to a function
#include <iostream.h>
#include <stdlib.h>
struct myDataType {
char name[20];
int grade;
};
void ReadData(myDataType data[], int n); DEMO 4
int main() {
myDataType *record;
int nItems;
int i;
cout << "How many numbers are there to process? : ";
cin >> nItems;
record = new myDataType[nItems]; //created dynamically
ReadData(record, nItems); //effectively record used like an array
for (i=0;i<nItems;i++)
cout <<record[i].name << " " << record[i].grade << endl;
return 0;
}
void ReadData(myDataType data[], int n) {
int i;
for (i=0;i<n;i++) {
cout << "Enter a name : ";
cin >> data[i].name;
cout << "Enter a grade : ";
cin >> data[i].grade;
}
} 20
Summary: How to use dynamic Arrays
Define a pointer variable of the chosen type: The
pointer variable will point to the dynamic array in
memory and will serve as the name of the dynamic
array
Call new: Creates the dynamic array. The size of the
array is given in the square brackets.
Use like an ordinary array
Call delete: when you have finished your program
before the final return call delete [] to free memory for
future use.
21
A Couple of Ideas to think about
NULL pointers
typedef
22
NULL
You often see NULL used in programs.
It is a special constant pointer value (a zero address) that can be
assigned to any sort of pointer.
int *x = NULL;
Why would you want to assign NULL to a pointer?
Pointers are dangerous, they allow direct access to memory, any memory.
It is common practice when creating a pointer to initialise it to NULL. This
can be changed e.g. via a new statement. But whenever you delete
memory it is good practice to reset a pointer back to NULL again.
Also analogous to strings we can make use of the knowledge that a pointer
is set to NULL. This is especially true for linked lists.
23
typedef
You can define alternative names for existing types
can aide readability of code
is important for some dynamic data structures (linked lists)
E.g.
typedef int banana;
banana x; //variable x is a banana
//banana is an int
//same as int x;
OR More commonly to “clean up pointer declarations
typedef float * floatPtr;
floatPtr f1ptr,f2ptr; //f1prt and f2ptr are pointers to floats
24
Practical Application-Linked Lists
A dynamic list data structure created
using pointers
They grow and shrink according to
need.
Adding items to the list is sometimes
called insertion.
We have to specify all the operations
that we have for array based lists.
25
Nodes
We have seen that often useful data items
are structured using structs or arrays.
We can create special structures that contain
pointers to other structures. If the other
structure is the same type as itself.
We have a self referential data structure.
A self referential data structure is often called
a NODE
Yes this is a bit like explaining cricket to an
American! 26
A Node
struct Node { Note reference to a
node within node
int data;
Node *next; Note use of typedef to create an
alias data type pointer to node type.
}; Necessary for function prototypes that use
this sort of self referential structure
typedef struct Node * NodePtr;
NodePtr front = NULL;
NodePtr newNode = NULL;
27
After declaration of pointers
front NULL
newNode NULL
28
Insertion to list
newNode = new Node;
newNode->data = 10;
newNode->next = NULL
front NULL
data 10
newNode
next NULL NULL
29
Insertion to list
front = newNode;
front
data 0
newNode
next NULL NULL
30
Insertion to list
newNode = new Node;
newNode->data = 20;
newNode->next = NULL
data 10
front
next NULL NULL
data 20
newNode
next NULL NULL
31
front->next = newNode; Insertion to list
newNode = NULL
data 10
front
next NULL
data 20
next NULL NULL
newNode NULL
32
NodePtr cursor; Deletion from list (note
cursor = front; requires another pointer)
data 10
front
next NULL
cursor
data 20
next NULL NULL
newNode NULL
33
front = front->next; //deleting first node
data 10
cursor
next NULL
data 20
front
next NULL NULL
newNode NULL
34
delete cursor;
cursor = NULL;
temp
NULL
data 20
front
next NULL NULL
newNode NULL
35
Demo 6 and 7
36
Linked lists
They require very precise programming
and a high level of understanding of
manipulation of data by addresses.
Writing functions that manipulate linked
lists also requires a very clear
understanding of pointers.
More next week.
37
