Dynamic Memory in C/Article (SoCoder)

Articles + Tutorials > Advanced Techniques (

Created 10 July 2008 | Last Edited 30 October 2008)

Dynamic Memory in C by Phoenix | No Votes
Explanation of the cryptic malloc()

Introduction

Last night I was in the MudChat, and Spinal was wondering how the malloc() function in C works. I tried to explain, but I probably wasn't elaborate enough. So I figured that he probably isn't the only one who wonders how to work with memory allocation, and therefore I wrote this article.

Prerequisites

This isn't a C tutorial. I assume that you have a basic understanding of C and some knowledge of pointers.

The Stack and the Heap

There are two ways to work with memory in C; on the stack and on the heap. An example of memory allocated on the stack can be seen here:

int main()
{
  int foo; /* stack allocation */
  foo = 5;
}

-->

"foo" needs to be stored in memory, and when variables are defined the way pictured above they are stored on the stack. The stack can be seen as a temporary storage place for memory, because the variable is removed when it goes out of scope.

Those curly braces - {} - define the beginning and the end of a scope. When a variable is allocated on the stack inside a scope, it "expires" when the } is reached. This shows a potential limitation of the stack:

/* This function creates an integer and returns a pointer to its address */
int* returnFive()
{ /* Scope begins */
  int bar = 5;
  return &bar;
} /* Scope ends */

int main()
{
  int* foo = returnFive();
}

-->

"foo" may or may not be a 5, because when returnFive's scope ends, its stack memory is freed. When memory is freed, its content isn't necessarily removed, but it is no longer reserved space in memory. The operating system will think that the memory can be reused for other purposes. So the five will remain in memory for a while, but can change at any time because other things might start using that particular block of memory.

So how do we overcome this problem? We work on the heap.

Dynamic Memory Allocation

This is where we get to the good stuff. Dynamic memory allocation (heap memory) is what we use to solve the issue of the previous example. I'll show some code first:

#include <stdlib.h>

int* returnFive()
{
  /* allocate on the heap */
  int* bar = (int*)malloc(sizeof(int));
  *bar = 5;

  return bar;
}

int main()
{
  int* foo = returnFive();

  free(foo);
}

-->

This way works around the limitations of the stack. We tell the program that we want enough memory for an integer (usually four bytes), so it searches all the blocks of memory it has until it finds a place where there are four bytes available, and returns a pointer to that space. That is, unless it is impossible to find such a place. When that happens, it just returns zero. The pointer is actually created on the stack, and it is therefore removed when it reaches the end of the scope. But it is only a pointer, and not the data it points to. Since we return a copy of the pointer with "return bar", there is no loss of data. The block of memory still exists and its address is returned into foo in main().

The memory remains until we call free(), which tells the program that the memory is no longer in use and can be utilized by other operations -- perhaps another allocation on the heap.

The Syntax of malloc()

At first, the syntax of malloc() can look a bit confusing so I'll walk you through it.

malloc() returns a pointer, and therefore you need to have a pointer where you store the address to the memory block. Let's take a char as an example:

char* heapMemory;

-->

Since it returns a void pointer (pointer to anything), the return value needs to be casted to your data type:

char* heapMemory = (char*)malloc();

-->

Then you need to define the size of your memory block. This is usually accomplished using the sizeof() function, which returns how many bytes large the data type passed to it is. For example, sizeof(char) commonly returns 1, since it is one byte large.

char* heapMemory = (char*)malloc(sizeof(char));

-->

Often though, you want to store more than just a couple of bytes. This can be accomplished by multiplying sizeof(data_type) by the amount of elements you want. For example, let's say we wanted to store the word "Hi" (containing two letters) inside our heap memory.

/* We multiply sizeof(char) by three to fit three characters */
char* heapMemory = (char*)malloc(sizeof(char)*3);
heapMemory[0] = 'H';
heapMemory[1] = 'i';
heapMemory[2] = '\0'; /* The extra character is used to indicate that the string ends there */

-->

As seen above, you can access each char individually by using square braces. This is because heapMemory only points to the address of the first element of the memory block (&heapMemory[0]), as oposed to the whole block. Pointers don't contain any information about the size of the memoory block it points to. The same principle can be applied to pretty much any data type:

#include <stdio.h>
#include <stdlib.h>

/* A car! */
typedef struct
{
	 /* Useless data */
	 int foo;
	 float bar;
} car;

int main()
{
	 int i;
	 car* iterator;
	 car* carStore;
	 
	 /* Allocate space for twenty cars */
	 carStore = (car*)malloc(sizeof(car)*20);
	 
	 /* Add some pointless data to the cars */
	 for(i = 0; i < 20; ++i)
	 {
		  carStore[i].foo = i;
		  carStore[i].bar = 2.5f * i;
	 }
	 
	 /* Set "iterator" to point to the first element of carStore */
	 iterator = carStore;
	 for(i = 0; i < 20; ++i)
	 {
		  /* Print the pointless data */
		  printf("%d %f\n", iterator->foo, iterator->bar);
		  
		  /* Move to the next car in the car store */
		  ++iterator;
	 }
	 
	 system("pause");
	 
	 /* Remove all the cars: DO NOT FORGET TO CALL free() */
	 free(carStore);
}

-->

Conclusion

I hope that that was understandable -- if not, feel free to ask and I'll try to explain even more.

(I'm eagerly awaiting a thousand corrections from Agent Smith)

Latest Comments

Posted : Thursday, 10 July 2008, 10:38

mike_g

I havent really read this article through yet, but malloc.h is included as part of stdlib

Posted : Thursday, 10 July 2008, 10:55

Phoenix

Thanks, I didn't know that. I'll correct it.

Posted : Friday, 11 July 2008, 19:41

JL235

There are also libraries and tools such as dmalloc that can be used to help debug all those memory leaks you'll be making with malloc.