Why, or when, do you need to dynamically allocate memory in C?

by

You need to use dynamic memory when:

  • You cannot determine the maximum amount of memory to use at compile time;
  • You want to allocate a very large object;
  • You want to build data structures (containers) without a fixed upper size;

You don’t always know how much memory you will need to set aside at compile time. Imagine processing a data file (a time series of temperatures, say), where the number of records in the file isn’t fixed. You could have as few as 10 records or as many as 100000. If you want to read all that data into memory to process it, you won’t know how much memory to allocate until you read the file. If the file is structured so that the very first value is the number of records, you could do something like this:

size_t recs = 0;
double *temps = NULL;

FILE *fp = fopen ( filename, "r" );
if ( fp )
{
  if ( fscanf( fp, "%zu", &recs ) == 1 )
  {
    temps = malloc( sizeof *temps * recs );
    if ( temps )
    {
      // read contents of file into temps
    }
  }
}

Sometimes you need to allocate a very large object, something like

int ginormous[1000][1000][1000];

Assuming a 4-byte integer, this array will require 4GB. Unfortunately, stack frames (where local variables are kept on most architectures) tend to be much smaller than that, so trying to allocate that much memory may lead to a run-time error (and typically does). The dynamic memory pool (a.k.a. the heap) is typically much larger than the stack, much less any one stack frame. so for something that obnoxious you’d need to write something like

int (*ginormous)[1000][1000] = malloc( sizeof *ginormous * 1000 );

It’s still possible for a request like that to fail; if your heap is fragemented enough, you may not have a single contiguous block large enough to hande the request. If necessary, you could do a piecemeal allocation; rows won’t necessarily be adjacent in memory, but it’s more likely you’ll be able to grab all the memory you need:

int ***ginormous = malloc( sizeof *ginormous * 1000 );
if ( ginormous )
{
  for ( size_t i = 0; i < 1000; i++ )
  {
    ginormous[i] = malloc( sizeof *ginormous[i] * 1000 );
    if ( ginormous[i] )
    {
      ginormous[i][j] = malloc ( sizeof *ginormous[i][j] * 1000 );
      if ( ginormous[i][j] )
      {
        // initialize ginormous[i][j][k]
      }
    }
  }
}

And finally, dynamic memory allows you to build containers that can grow and shrink as you add or remove data, such as lists, trees, queues, etc. You could even build your own real “string” data type that can grow as you append characters to it (similar to the string type in C++).

More Related Contents:

  1. Dynamic memory access only works inside function
  2. When and why to use malloc?
  3. Malloc function (dynamic memory allocation) resulting in an error when it is used globally
  4. whats the difference between dynamic memory allocation and normal memory allocation?
  5. Segmentation fault, I don’t know why
  6. Do I cast the result of malloc?
  7. How can I allocate memory and return it (via a pointer-parameter) to the calling function?
  8. sprintf() with automatic memory allocation?
  9. What’s the difference between a VLA and dynamic memory allocation via malloc?
  10. How to dynamically allocate memory space for a string and get that string from user?
  11. Proper usage of realloc()
  12. How is malloc() implemented internally? [duplicate]
  13. Should I free memory before exit?
  14. Freaky way of allocating two-dimensional array?
  15. Function to dynamically allocate matrix
  16. Include source code of malloc.c in gdb?
  17. Can I rely on malloc returning NULL?
  18. C – Accessing data AFTER memory has been free()ed?
  19. allocate matrix in C
  20. How to initialize const in a struct in C (with malloc)
  21. Using Dynamic Memory allocation for arrays
  22. If free() knows the length of my array, why can’t I ask for it in my own code?
  23. How big can a malloc be in C?
  24. How do I free memory in C?
  25. Why do you specify the size when using malloc in C?
  26. difference between and
  27. What happens if I try to access memory beyond a malloc()’d region?
  28. Problem usage memory in C
  29. How are we able to access the pointer after deallocating the memory?
  30. checking that `malloc` succeeded in C

Leave a Comment