MORE POINTERS

Plus: Memory AllocationHeap versus Stack

Where should we store stuff?• What’s wrong with this:

char* getString() {char result[80];…. Some code to put data into result …return result;

}

•Somehow, programs must modify or create data structures that persist in the program regardless of procedure calls…•So far the only variables we have seen (except for globals) are declared at the beginning of blocks and are “on the stack”•Variables “on the stack” disappear when the block they are declared in is exited or returned from.

The answer is the heap…

• What is it?– An area of memory distinct from the program

stack– Access to it is controlled, not by the compiler,

but by specific library procedures:• #include <stdlib.h>• malloc(), calloc() reserve blocks of memory for

program use• free() returns blocks of memory to the heap for

reuse

Dynamic Storage Allocation• The use of memory in the heap is referred to as “dynamic storage allocation”

• Arrays, strings, structures may all be stored in memory reserved in the heap area

•Pointers are used to maintain references to objects allocated in the heap.

•Objects in the heap may contain references to each other, forming what is known as a “data structure”

•All objects in the heap are unaffected by actions taking place on the program stack

The malloc Function• The most important storage allocation function is named malloc. When called, malloc allocates (reserves) a block of size bytes and returns a pointer to it:

void *malloc(size_t size);

• malloc returns a “generic” pointer that is capable of pointing at an object of any type. malloc’s return value can be stored in a variable of any pointer type:

int *pi;pi = malloc(sizeof(int));

… or better yet…pi = (int *) malloc(sizeof(int));

For portability, it is best to use sizeof when calling malloc , you don’t want to have to remember..

malloc• malloc reserves a portion of the heap,

and gives you a pointer to it to use as you see fit. It will not re-allocate that portion of heap memory until you “free” it.– The memory reserved is not initiallized– Be careful not to access the memory below or

above what is allocated… Stay in bounds!• calloc() is a closely related function

The Null Pointer

• Since NULL is equivalent to 0, it tests false in if, while, do, and for statements:int *p;…if (p) … /* true if p is not NULL */

• It is illegal to apply the indirection operator to a null pointer:p = NULL;i = *p; /* illegal */

Dynamically Allocated Strings• malloc is can be used to dynamically allocate space for strings.

char *result;result = malloc(strlen(s1) + strlen(s2) + 1);strcpy(result, s1);strcat(result, s2);return result;

• Now, the string returned is in the heap and not on the stack. A pointer to it can be passed around and stored without concern about its memory location.

•Warning: When using malloc to allocate space for a string, don’t forget to include room for the null character.

Dynamically Allocated Arrays• An array can be dynamically allocated by a call to the calloc function. calloc() is similar to malloc, but allocates space for an array with n elements, each of which is size bytes long:

void *calloc(int n, int size);

• calloc will allocate n*size bytes, passing back a pointer to the beginning of the memory block it reserved.

• calloc does one thing that malloc does not do: it will set every byte it allocates to zero, clearing the elements so you don’t have to.

Dynamically Allocated Arrays• Example:

int *a, size, i;printf("Enter array size: ");scanf("%d", &size);

a = (int *) calloc(size, sizeof(int));

printf("Enter array elements: ");for (i = 0; i < size; i++)

scanf("%d", &a[i]);

• Warning: A program that uses malloc or calloc must include the following header file:#include <stdlib.h>

The free Function• When a block of memory obtained by calling malloc or calloc is no longer referenced by a pointer, it is said to be garbage. In the following example, the memory pointed to by p becomes garbage when p is assigned a new value:

int *p, *q;p = malloc(sizeof(int));q = malloc(sizeof(int));p = q;

Garbage should be avoided; we need to “recycle” memory instead. Failure to do so causes “memory leaks” which will ultimately cause a program to fail when its heap is full (of garbage).

The free Function• When a block of memory is no longer needed, it can be released back to the heap by calling the free function:

int *p, *q;p = malloc(sizeof(int));q = malloc(sizeof(int));free(p);p = q;

• Warning: Watch for “dangling pointers” left behind after a call to free:

int *p, *q;p = malloc(sizeof(int));q = p;free(p);*q = 0; /* error, writing to freed heap area */

Linked Lists• Dynamic storage allocation is useful for building lists, trees, graphs, and other linked structures.• A linked structure consists of a collection of nodes. Each node contains one or more pointers to other nodes. In C, a node is represented by a struct.• The simplest linked structure is the linked list, which consists of a chain of nodes, with each node pointing to the next node in the chain. A node in a linked list might have the following definition:

struct node {int data;struct node *next;

};The use of a structure name is mandatory, since the node structure contains a reference to itself.

Linked Lists• An ordinary pointer variable points to the first node in the list. To indicate that the list is empty, the variable can be assigned NULL:

struct node *first = NULL;

• Nodes could be allocated from the heap and added as a linked list:

struct node* addNode(struct node* previous) {struct node* n = (struct node*)

malloc(sizeof(struct node));

n->data = … initialize data …n->next = NULL;previous->next = n;return n;

}

addNode(first);

The Right Arrow Operator

• Nodes can be created by calling malloc:struct node *temp;temp = (struct node*)

malloc(sizeof(struct node));

• The . operator could be used to select a data member in the node pointed to by temp:

(*temp).data = n;

• Because pointers often point to structures, C provides a special notation (the right arrow selection operator) for selecting members of these structures:

temp->data = n;

Example: Inserting into a Linked List

• The following statements will create a node containing n, then insert it at the beginning of the list pointed to by first:

struct node *temp;temp = malloc(sizeof(struct node));temp->data = n;temp->next = first;first = temp;

Example: Inserting into a Linked List

• The following example creates a linked list containing numbers entered by the user:

struct node *first = NULL, *temp;int n;printf("Enter a series of numbers: ");scanf("%d", &n);while (n != 0) {

temp = malloc(sizeof(struct node));temp->data = n;temp->next = first;first = temp;scanf("%d", &n);

}The numbers will appear in the list in the reverse of the order in which they were entered.

Example: Searching a Linked List

• The following statement searches a list for an integer n:

for (temp = first; temp != NULL; temp = temp->next){if (temp->data == n){

… /* found n */}

}

/* same thing written as a while loop */temp = first;while (temp != NULL) {

if (temp->data == n) {… /* found n */

}temp = temp->next;

}

Deleting from a Linked List• The following statements will delete the first node containing n from the list pointed to by first, assuming that n is present in the list:

struct node *p, *q;p = first;q = NULL;while (p != NULL) {

if (p->data == n) {if (q) q->next = p->next;else first = p->next;free(p);break;

}q = p;p = p->next;

}

Strings on the Heap

• When you do something like this…

char* getAString() {char s[80];scanf(“%s”,s);return s;

}

String “s” is on the stack, and disappears when the function returns, leaving the return value pointing at who-knows-what.

***** This is a BAD THING! *****

Strings on the Heap

• Instead, allocate strings from the heap…char* getAString() {char* s = (char*) malloc(sizeof(char)*80);

scanf(“%s”,s);return s;

}

But there is a better way… Using a library function

Strings on the Heap• Use the function “strdup”:

char* getAString() {char s[80];scanf(“%s”,s);

return strdup(s);}

strdup() takes a string as a parameter, allocates len(string)+1 bytes from the heap, copies the string into the allocated memory and returns a pointer to the copy (the copy is in the heap, regardless of where the original string was).