See this page as a slide show

Dynamic Memory Allocation

• Alternative to fixed memory allocation
• Memory space grows or diminishes during program execution
• Unnecessary to reserve a fixed amount of memory for a scalar, array, or structure variable in advance
• Also known as run-time allocation
• Requests are made for allocation and release of memory space while the program is running

Dynamic Memory Allocation

• malloc: Reserves bytes of memory; returns the address or NULL.
• calloc: Reserves space for an array; returns the address or NULL.
• realloc: Re-sizes previously allocated memory; returns the address or NULL.
• free: Releases memory previously reserved.

malloc(…)

• malloc - memory allocate
• Requires #include <stdlib.h>
• Memory is not cleared.
• Takes one parameter — the size (in bytes)
  

  void *malloc(size_t size)
  

• Returns a pointer to a piece of memory of given size. If unsuccessful, returns NULL
• malloc(12) : returns a pointer to 12 bytes of memory.
• malloc(sizeof(int) * 100) : returns a pointer to memory that has enough space for 100 ints, no matter how big an int is.

size_t

size_t is a typedef for an unsigned numeric type, often unsigned long int. It’s used as an argument to functions like malloc, when a number of bytes is required.

strlen and sizeof return a size_t.

Print a size_t with %zd, thus:

char god[] = "Thor of Asgard";
printf("%d\n", sizeof(god));        // not quite right
printf("%zd\n", sizeof(god));       // correct

c.c: In function 'main':
c.c:2: warning: format '%d' expects argument of type 'int', but argument 2 has type 'long unsigned int'
15
15

sizeof(…)

• returns the number of bytes used in memory for a specific datatype or variable.
• sizeof(int) == 4 (assume this, for the moment)
• int i, a[10], *p;
  • sizeof(i) == 4
  • sizeof(a) == 40
  • sizeof(p) == 4 (assume, also, that pointers are 4 bytes)
• sizeof can be used with user-defined types as well.

free(…)

• Free your memory when you’re done!
  

  void free(void *p)
  

• Returns the block pointed at by p to pool of available memory
• p must come from a previous call to malloc or realloc or calloc (can’t free from the stack)

A poem about memory deallocation

calloc(…)

• Allocate memory and clear it:
  

  void *calloc(size_t how_many, size_t size_of_each);
  

• Allocates how_many × size_of_each bytes.
• Sets the memory to zero:

int *p = calloc(10, sizeof(int));
for (int i=0; i<10; i++)
    printf(" %d", p[i]);

 0 0 0 0 0 0 0 0 0 0

realloc(…)

• Resizing a previous memory allocation:

void *realloc(void *p, size_t size)

• Returns a (new) pointer to the resized memory.
• If it can, it will give you the same pointer. If not, it will copy your old data into the new memory.
• Contents of new block unchanged up to min of old and new size—new memory is uninitialized
• Can be used to grow or shrink a memory area.
• Make sure to save the new pointer:

    int *p = malloc(100*sizeof(int));
    …
    p = realloc(p, 200*sizeof(int));

Example allocations

    int *grades;
    int numgrades = 15;
    grades = malloc(numgrades * sizeof(int));

    int size = 10;
    char *base = calloc(size, sizeof(char));

    free(base);
    free(grades);

Example

Dynamically create an array of grades, asking the user how many, then prompting the user for each grade.

int numgrades;
int *grades;           // ptr to array of grades
printf("How many students? ");
scanf("%d", &numgrades);

// get memory for the entire array
grades = malloc(numgrades * sizeof(int));
if (grades == NULL) {     // snafu?
    printf("Failed to allocate grades array\n");
    return 1;
}
for (int i=0; i<numgrades; i++) {
    printf("Enter a grade: ");
    scanf("%d", &grades[i]);
}
for (int i=0; i<numgrades; i++)
    printf("Value %d: %d\n", i, grades[i]);
free(grades);

How Can This Work?

• Hey, wait—malloc returns a void *, so how can we assign that to an int *?
• It’s because void * is special.
• void * magically transforms to any other pointer type, as needed.

Example

% c11 -o dym2 dynMem2.c
% ./dym2
Array size: 4
a, b, c, d

Dynamically create a repeating array of the alphabet.

    int size;
    printf("Array size: ");
    scanf("%d", &size);
    char *base = calloc(size, sizeof(char)); // calloc: handy for arrays
    /* Should check for failure here */
    for (int i=0;i<size;i++)
        base[i] = 'a' + i%26;
    for (int i=0;i<size;i++) {
        if (i != 0)
            printf(", ");
        printf("%c", base[i]);
    }
    printf("\n");
    free(base);

Leaking

The dreaded Memory Leak

Memory

Memory is divided into two parts: the stack & the heap.

A stack is a common structure used in computers and in programming. The basics are the same, but here we are talking about memory management as opposed to programming it in our code.

Until now, we’ve mostly used the stack:

• Local Variables
• Parameters

The Stack

• Everything on the stack has a name
• The only way to get something on the stack is to declare it before you compile.
• Things on the stack have preset datatypes.
• You need to know how many items you want and when you want them before you compile.
• Things on the stack disappear automatically when they are finished.

The Heap

• Nothing on the heap has a name
• The only way to get something in the heap is to ask for it while the program is running.
• Heap items have no preset datatype.
• You can ask for as much, or as little as you want, whenever you want it.
• Things allocated on the heap remain in memory until you get rid of them explicitly.

Memory Leaks

• When a heap item is allocated, it must be explicitly released by the programmer.
• It’s easy to write code that causes a memory leak because it doesn’t free some memory that it allocated, but no longer needs.
• The free function allows us to give memory back to the heap.

free

• free takes a pointer (which you got from a previous call to malloc/calloc/realloc) and returns nothing.
• All it does is give the memory back to the OS (operating system), which puts it back on the memory heap.
• After you free something don’t try to use it again. This is a good way to get segfaults.

A Few Details

• malloc does not initialize the memory it gives you. Its contents are undefined. If you want it initialized, that’s your job (or use calloc).
• Over-/Under-running a piece of malloced memory has VERY unpredictable consequences!
• The maximum size of a piece of memory you can malloc is determined by the machine and operating system.

Finding Problems

• The best method is to avoid them in the first place. Never call malloc without eventually calling free.
• The program valgrind can be used to find problems with dynamic memory usage.
• valgrind detects the use of uninitialized memory, read/write outside allocated memory, and memory leaks (unfreed memory).

Example

char str[8] = "spam\n"
char *ptr;

        ┌───┐         ┌────┬────┬────┬────┬────┬────┬────┬────┐
    ptr:│ ? │     str:│ s  │ p  │ a  │ m  │ \n │ \0 │ ?? │ ?? │
        └───┘         └────┴────┴────┴────┴────┴────┴────┴────┘

Example

char str[8] = "spam\n";
char *ptr;
ptr = malloc(sizeof(char)*(strlen(str)+1));

        ┌───┐         ┌────┬────┬────┬────┬────┬────┬────┬────┐
    ptr:│   │     str:│ s  │ p  │ a  │ m  │ \n │ \0 │ ?? │ ?? │
        └─┼─┘         └────┴────┴────┴────┴────┴────┴────┴────┘
          │
          ∨  
        ┌────┬────┬────┬────┬────┬────┐
        │ ?? │ ?? │ ?? │ ?? │ ?? │ ?? │
        └────┴────┴────┴────┴────┴────┘

Example

char str[8] = "spam\n";
char *ptr;
ptr = malloc(sizeof(char)*(strlen(str)+1));
strcpy(ptr, str);

        ┌───┐         ┌────┬────┬────┬────┬────┬────┬────┬────┐
    ptr:│   │     str:│ s  │ p  │ a  │ m  │ \n │ \0 │ ?? │ ?? │
        └─┼─┘         └────┴────┴────┴────┴────┴────┴────┴────┘
          │
          ∨  
        ┌────┬────┬────┬────┬────┬────┐
        │ s  │ p  │ a  │ m  │ \n │ \0 │
        └────┴────┴────┴────┴────┴────┘

Example

char str[8] = "spam\n";
char *ptr;
ptr = malloc(sizeof(char)*(strlen(str)+1));
strcpy(ptr, str);
free(ptr);             // Assume that we’re done with it

        ┌───┐         ┌────┬────┬────┬────┬────┬────┬────┬────┐
    ptr:│   │     str:│ s  │ p  │ a  │ m  │ \n │ \0 │ ?? │ ?? │
        └─┼─┘         └────┴────┴────┴────┴────┴────┴────┴────┘
          │
          ∨  
        ┌────┬────┬────┬────┬────┬────┐
        │ ?? │ ?? │ ?? │ ?? │ ?? │ ?? │
        └────┴────┴────┴────┴────┴────┘

• Where does ptr point to, now?
• What’s there?

strdup

• strdup (non-standard, but available everywhere) does exactly what we just did on the previous slides.
• It will malloc exactly enough space for a string, and copy it into the new memory for you. It’s still your job to free it.

char foo[] = "Hello";
char *bar = strdup(foo);
bar[0] = 'J';
printf("%s %s\n", foo, bar);         // Displays Hello Jello

While we are talking about memory …

memcpy(dst, src, len)

• Copies len bytes from src to dst; dst and src cannot overlap

memmove(dst, src, len)

• Copies len bytes from src to dst; dst and src CAN overlap

memset(dst,val,len)

• initializes len bytes of dst to val
• memset(ptr,0,sizeof(int) * 100);