C Memory Management

by

There are two places where variables can be put in memory. When you create a variable like this:

int  a;
char c;
char d[16];

The variables are created in the “stack“. Stack variables are automatically freed when they go out of scope (that is, when the code can’t reach them anymore). You might hear them called “automatic” variables, but that has fallen out of fashion.

Many beginner examples will use only stack variables.

The stack is nice because it’s automatic, but it also has two drawbacks: (1) The compiler needs to know in advance how big the variables are, and (2) the stack space is somewhat limited. For example: in Windows, under default settings for the Microsoft linker, the stack is set to 1 MB, and not all of it is available for your variables.

If you don’t know at compile time how big your array is, or if you need a big array or struct, you need “plan B”.

Plan B is called the “heap“. You can usually create variables as big as the Operating System will let you, but you have to do it yourself. Earlier postings showed you one way you can do it, although there are other ways:

int size;
// ...
// Set size to some value, based on information available at run-time. Then:
// ...
char *p = (char *)malloc(size);

(Note that variables in the heap are not manipulated directly, but via pointers)

Once you create a heap variable, the problem is that the compiler can’t tell when you’re done with it, so you lose the automatic releasing. That’s where the “manual releasing” you were referring to comes in. Your code is now responsible to decide when the variable is not needed anymore, and release it so the memory can be taken for other purposes. For the case above, with:

free(p);

What makes this second option “nasty business” is that it’s not always easy to know when the variable is not needed anymore. Forgetting to release a variable when you don’t need it will cause your program to consume more memory that it needs to. This situation is called a “leak”. The “leaked” memory cannot be used for anything until your program ends and the OS recovers all of its resources. Even nastier problems are possible if you release a heap variable by mistake before you are actually done with it.

In C and C++, you are responsible to clean up your heap variables like shown above. However, there are languages and environments such as Java and .NET languages like C# that use a different approach, where the heap gets cleaned up on its own. This second method, called “garbage collection”, is much easier on the developer but you pay a penalty in overhead and performance. It’s a balance.

(I have glossed over many details to give a simpler, but hopefully more leveled answer)

More Related Contents:

  1. Making sense of memory gibberish (C)
  2. Understanding Memory Layout of C Programs [closed]
  3. How do I determine the size of my array in C?
  4. String literals: Where do they go?
  5. Getting a stack overflow exception when declaring a large array
  6. Determine size of dynamically allocated memory in C
  7. Difference between static memory allocation and dynamic memory allocation
  8. How do free and malloc work in C?
  9. Does stack grow upward or downward?
  10. “register” keyword in C?
  11. Returning local data from functions in C and C++ via pointer
  12. How much memory would be freed if pointer is changed in C?
  13. Pointer address in a C multidimensional array
  14. Obtaining peak bandwidth on Haswell in the L1 cache: only getting 62%
  15. Will a `char` always-always-always have 8 bits?
  16. Measuring Cache Latencies
  17. What is the difference between a segmentation fault and a stack overflow?
  18. how to print memory bits in c
  19. malloc(sizeof(int)) vs malloc(sizeof(int *)) vs (int *)malloc(sizeof(int))
  20. Why would you ever want to allocate memory on the heap rather than the stack? [duplicate]
  21. Memory usage of current process in C
  22. dynamic allocating array of arrays in C
  23. Malloc vs custom allocator: Malloc has a lot of overhead. Why?
  24. Determining Stack Space with Visual Studio
  25. When should I use malloc in C and when don’t I?
  26. Resizing an array with C
  27. dynamic allocation/deallocation of 2D & 3D arrays
  28. Why exactly should I not call free() on variables not allocated by malloc()?
  29. Struct varies in memory size?
  30. How to assign pointer address manually in C programming language?

Leave a Comment