C dynamic memory allocation facts for kids

C dynamic memory allocation is a way for computer programs written in the C language to ask for memory while they are running. Think of it like a program asking for extra space to store things only when it needs it, instead of having all the space ready from the start.

This is done using special functions from the C standard library, like malloc, realloc, calloc, aligned_alloc, and free. These functions help programs manage their memory more flexibly.

The C++ language also has these functions. However, C++ usually uses its own tools, new and delete, for similar tasks. Still, sometimes C programs need to use these C memory functions for specific reasons, like when dealing with very fast code.

There are many different ways these memory allocation tools work behind the scenes. How well they perform can change depending on how they are set up.

Why Programs Need Dynamic Memory

Computers manage memory in a few ways. Some memory is set aside when the program starts and stays there forever. This is like having a fixed-size box for certain items. Other memory is used temporarily when a function is called, and it disappears when the function finishes. This is like a temporary notepad.

But what if you don't know how much space you'll need until the program is running? For example, if you're reading a file from a user, you don't know its size beforehand. Fixed-size memory won't work here.

Also, sometimes you need data to last longer than a single function call, but not for the entire program. Temporary memory disappears too soon, and permanent memory stays too long.

This is where dynamic memory allocation comes in handy. It lets programs ask for memory exactly when they need it. They can also decide when to give that memory back. In C, the malloc function asks for a block of memory. The program then gets a special "address" (a pointer) to find this memory. When the memory is no longer needed, the program uses the free function to release it. This makes the memory available for other uses.

The idea of these memory functions has been around for a long time. They were fully described in the 7th Edition Unix manual.

Main Memory Functions

The C functions for dynamic memory are found in the `stdlib.h` file.

Differences Between malloc() and calloc()

• malloc() takes one input: the total number of bytes you want.
• calloc() takes two inputs: how many items you want and the size of each item.
• malloc() only gets the memory. It doesn't clear out any old data that might be there.
• calloc() gets the memory and then fills it with zeros.

How to Use These Functions

Let's say you want to create a list (an array) of ten whole numbers. If you know the size when you write the program, it's simple:

int array[10];

But if you don't know the size until the program runs, you can use malloc:

int *array = malloc(10 * sizeof(int));

This code figures out how much memory ten integers need. Then, it asks malloc for that much space. The result is stored in a pointer called `array`.

It's important to check if malloc actually found the memory. Sometimes it can't, and it returns a special "null pointer."

int *array = malloc(10 * sizeof(int));
if (array == NULL) {
  fprintf(stderr, "malloc failed\n");
  return -1;
}

If `array` is `NULL`, it means there wasn't enough memory.

When your program is finished using the memory, it must give it back using free:

free(array);

Memory given by malloc might contain old, random data. If you want the memory to be clean (all zeros), use calloc:

int *array = calloc(10, sizeof(int));

You can also change the size of an already allocated block of memory using realloc. For example, if you have an array and need it to be bigger:

int *arr = malloc(2 * sizeof(int)); // Get space for 2 integers
arr[0] = 1;
arr[1] = 2;
arr = realloc(arr, 3 * sizeof(int)); // Now change it to hold 3 integers
arr[2] = 3;

Be careful: realloc might move your memory block to a new location. If it does, any old pointers pointing inside the original block will no longer work.

Understanding Data Types

The malloc function returns a "void pointer" (`void *`). This means it's a pointer to memory of an unknown type. In C, you can use this pointer directly, but in C++ you often need to "cast" it to the correct type, like `(int *)`.

int *ptr, *ptr2;
ptr = malloc(10 * sizeof(*ptr)); // No cast needed in C
ptr2 = (int *)malloc(10 * sizeof(*ptr)); // With a cast

While casting is not always needed in C, some programmers use it. It can help if you're writing code that might also be used in C++.

Common Mistakes

Using dynamic memory incorrectly can cause problems. These can lead to programs crashing or having security issues.

Here are some common errors:

• Not checking for failures: Memory requests might not always succeed. If malloc returns `NULL` and you try to use that memory, your program might crash. Always check if the allocation worked!
• Memory leaks: If you ask for memory with malloc but forget to give it back with free, that memory stays "taken" even if your program doesn't need it anymore. This is called a memory leak. Over time, your program might use up all available memory.
• Using memory incorrectly:

* Using memory after freeing it: This is called a dangling pointer. Once you call free, that memory is no longer yours. Using it can cause crashes. * Calling free twice: Trying to free the same memory block more than once (a "double free") can also cause crashes. * These errors can be tricky to find because the program might not crash right away.

Sometimes, asking for zero bytes of memory can also cause issues. Good programming means being careful with how you ask for and release memory.

Other Ways to Allocate Memory

Besides the standard functions, some systems offer other ways to get memory:

• alloca: This function asks for memory on the "call stack." This memory is automatically freed when the function that asked for it finishes. It's like a very temporary notepad that disappears when you close the book. However, it's not part of the standard C language and might not work everywhere.
• posix_memalign: This function allows you to ask for memory that starts at a specific "alignment." This can be important for certain advanced computer tasks.

See also

• Buffer overflow
• Memory debugger
• Memory protection
• Page size
• Variable-length array