C dynamic memory allocation facts for kids

C dynamic memory allocation is a way for computer programs written in the C programming language to ask for and manage computer memory while they are running. This is different from memory that is set aside when the program is first created. It's like a program asking for more space on a whiteboard as it needs it, instead of having a fixed-size whiteboard from the start.

This process uses special functions from the C standard library. The main functions are malloc, realloc, calloc, aligned_alloc, and free. These tools help programmers control memory very precisely.

The C++ programming language also uses these functions. However, C++ usually prefers its own tools, new and delete, for similar tasks. Still, there are times when C functions like malloc are very useful, especially for advanced programming or when speed is super important.

Many different ways exist for how malloc actually finds and gives out memory. These methods can affect how fast a program runs and how much memory it uses.

Why Programs Need Dynamic Memory

Computers manage memory in a few ways. Some memory is set aside when a program starts and stays there the whole time. This is like having a fixed number of lockers for a school year. Other memory is used for short tasks, like when a function runs, and then it's cleared away. This is like borrowing a book from the library for a short time.

The problem is that for these types of memory, the program needs to know exactly how much space it will need ahead of time. But what if a program needs to store information that changes in size? For example, if it's reading a file from the internet, it doesn't know how big the file will be until it starts reading. Fixed-size memory won't work here.

Also, how long the memory is needed matters. Short-term memory disappears when a function finishes, which isn't good if you need the data later. Long-term memory stays forever, even if you don't need it anymore, which wastes space.

Dynamic memory allocation solves these problems. It lets a program ask for memory when it needs it and release it when it's done. This memory comes from a special area called the "heap." In C, the malloc function asks for a block of memory on the heap. It then gives the program a special address (a pointer) to find that memory. When the program no longer needs the memory, it uses the free function to give it back. This way, the memory can be used by other parts of the program or other programs.

The malloc and free functions we use today became standard in the late 1970s with the 7th Edition Unix manual.

Key Functions for Memory Management

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

How `malloc()` and `calloc()` Are Different

• malloc() takes one number: the total amount of memory in bytes you want.
• calloc() takes two numbers: how many items you want and the size of each item.
• malloc() just gives you memory; it doesn't clear it. The memory might contain old, random data.
• calloc() gives you memory and automatically fills it with zeros, making it clean.

How to Use Dynamic Memory: An Example

Let's say you want to create a list (an array) of ten whole numbers in C. If you know the size ahead of time, it's simple:

int array[10];

But what if you don't know how many numbers you'll need until the program is running? You can use malloc to ask for memory dynamically:

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 always check if malloc was successful. Sometimes, it can't find enough memory and will return a special "null pointer." If this happens, your program might crash if you try to use that memory.

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

When your program is finished using the dynamic memory, you must call free to give it back. If you don't, the memory stays reserved and can't be used by other parts of your program or other programs. This is called a "memory leak."

free(array);

Remember, memory from malloc isn't cleared. It might have old data in it. If you want clean memory, use calloc:

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

This will give you space for 10 integers, all set to zero.

You can also change the size of memory you've already asked for using realloc. For example, if you have an array of 2 integers and want to make it 3:

int *arr = malloc(2 * sizeof(int));
arr[0] = 1;
arr[1] = 2;
arr = realloc(arr, 3 * sizeof(int));
arr[2] = 3;

Be careful: realloc might move your memory block to a new location. If you had other pointers pointing inside the old block, they won't work anymore.

Understanding Memory Types

The malloc function gives back a "void pointer" (written as `void *`). This means it's a pointer to memory of an unknown type. In C, you don't always have to tell the program what type of data will be stored there, but in C++ you usually do. You can "cast" this pointer to a specific type, like `(int *)` for integers:

int *ptr, *ptr2;
ptr = malloc(10 * sizeof(*ptr)); /* without a cast */
ptr2 = (int *)malloc(10 * sizeof(*ptr)); /* with a cast */

Casting can sometimes help catch mistakes, especially if you're writing code that needs to work in both C and C++. However, in modern C, it's often not needed and can sometimes hide other problems, like forgetting to include the right header file.

Common Mistakes with Dynamic Memory

Using dynamic memory incorrectly can lead to serious problems, like programs crashing or having security holes. Here are some common errors:

• Not checking for failures: Memory requests might not always work. If malloc can't find enough memory, it returns a "null pointer." If you try to use this null pointer, your program will likely crash. Always check if the memory was given successfully!
• Memory leaks: This happens when you ask for memory but forget to free it when you're done. The program keeps holding onto that memory, even though it's not using it. Over time, this can use up all available memory, making your computer slow or causing other programs to fail.
• Logical errors: You must follow a pattern: ask for memory, use it, then free it.
  • Using memory after freeing it: This is called a "dangling pointer." Once you free memory, you shouldn't use it again. The memory might have been given to another part of the program, and using it could cause a crash.
  • Freeing memory twice: Trying to free the same memory block more than once is also a big problem and usually crashes the program.

These errors can be tricky to find because they might not cause a crash right away.

How Memory Allocators Work (Behind the Scenes)

The way malloc actually finds and gives out memory depends a lot on the computer's operating system and how it's built. Some operating systems have their own built-in memory managers.

Heap-based Allocators

Many older memory managers used a part of memory called the "heap segment." They would make this heap bigger or smaller as programs asked for memory.

However, this method had some challenges:

• It could get "stuck" at a large size if a small piece of memory was needed for a long time at the very end of the heap.
• It could suffer from "fragmentation." This is like having many small, empty spaces scattered around, but no single large space when you need one.
• It was not good for programs that use many different parts (threads) at the same time, as they all had to wait their turn to get memory.

Popular Memory Allocators

• dlmalloc and ptmalloc: Doug Lea created dlmalloc, a popular general-purpose memory allocator, starting in 1987. The GNU C library (glibc), which is used on many Linux systems, uses ptmalloc. Ptmalloc is a version of dlmalloc that works better with multiple threads. These allocators organize memory into "chunks" and group unused memory into "bins" based on size to find space efficiently.
• jemalloc: Used by FreeBSD and NetBSD operating systems since around 2007-2008. Jemalloc is designed to be very good at handling many different parts of a program (threads) asking for memory at the same time. It uses separate "arenas" for each computer processor to avoid slowdowns.
• OpenBSD's malloc: The OpenBSD operating system uses a malloc that relies heavily on a system call called mmap. For large memory requests, it uses mmap directly. For smaller requests, it manages memory in "bucket pages." When memory is freed, it's quickly released. This system is designed to improve security and help find bugs where programs try to use memory after it's been freed.
• Hoard malloc: Hoard is another allocator focused on speed, especially for programs with many threads. It also uses mmap and manages memory in larger chunks called "superblocks." Hoard tries to keep memory organized and available for different parts of a program.
• mimalloc: This is an open-source memory allocator from Microsoft Research. It's designed to be very fast and efficient, even though it's quite compact in its code.
• Thread-caching malloc (tcmalloc): Developed by Google, TCMalloc gives each program thread its own small storage area for quick memory requests. For larger requests, it uses mmap. TCMalloc is known for being very fast for programs that use many threads.

In-kernel Allocators

Even the core part of an operating system (the kernel) needs to ask for memory. The way malloc works inside a kernel can be very different from how it works for regular programs. This is because kernel memory might have special rules, for example, for direct access by hardware.

Changing How Malloc Works

Because malloc and its related functions can greatly affect how fast a program runs, programmers sometimes replace them with their own custom versions. These custom versions are optimized for how their specific program uses memory. While the C standard doesn't have a direct way to do this, operating systems often allow it by letting you "override" the standard functions. For example, on Linux, you can set a special environment variable called `LD_PRELOAD` to tell the system to use a different malloc library.

How Much Memory Can Be Allocated?

The largest amount of memory malloc can give you depends on your computer system. This includes how much physical memory you have and how the operating system is set up.

Theoretically, the biggest number should be the maximum value that can be stored in a `size_t` type. This is a special number type in C that represents sizes of memory.

Other Ways to Allocate Memory

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

• alloca: This function asks for memory on the "call stack" instead of the heap. The memory is automatically freed when the function that called alloca finishes. It's fast, but it's not part of the standard C language, so it might not work everywhere. Also, asking for too much memory with alloca can cause a "stack overflow," which crashes the program.
• posix_memalign: This function, defined by POSIX standards, lets you ask for memory that is "aligned" in a specific way. This can be important for certain types of high-performance computing. The memory allocated with `posix_memalign` is still freed using the regular free function.

See also

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