malloc() Funktion i C-bibliotek med EXEMPEL

By: Benjamin walker Benjamin walker
Hours Uppdaterad

⚡ Smart sammanfattning

malloc() in C reserves a block of memory on the heap at runtime and returns a void pointer to its first byte, letting programs request storage whose size is unknown until the code actually executes.

  • 🧠 Runtime allocation: malloc() reserves memory during execution when the required size is not known at compile time.
  • 📦 Syntax: A cast_type pointer receives malloc(byte_size), commonly sized with sizeof for portability.
  • ⚠️ NULL check: A failed request returns a NULL pointer, so validate the result before dereferencing it.
  • ➕ Pointer arithmetic: The block is contiguous, so use + rather than ++ to reach array elements.
  • 🧹 Free the memory: Release every block with free() to prevent memory leaks and dangling pointers.
  • 🤖 AI-hjälp: AI assistants and GitHub Copilot draft malloc() calls and flag missing free() statements.
Läs mer

malloc() Function in C

Vad är malloc i C?

Funktionen malloc() står för minnesallokering. Det är en funktion som används för att tilldela ett minnesblock dynamiskt. Den reserverar minnesutrymme av specificerad storlek och returnerar nollpekaren som pekar till minnesplatsen. Pekaren som returneras är vanligtvis av typen void. Det betyder att vi kan tilldela malloc-funktion till vilken pekare som helst.

Vad är malloc i C

syntax

ptr = (cast_type *) malloc (byte_size);

Här,

  • ptr är en pekare av cast_type.
  • Malloc-funktionen returnerar en pekare till det tilldelade minnet av byte_size.
Example: ptr = (int *) malloc (50)

När denna sats exekveras framgångsrikt, reserveras ett minnesutrymme på 50 byte. Adressen för den första byten av reserverat utrymme tilldelas pekaren ptr av typen int.

Tänk på ett annat exempel på malloc-implementering:

#include <stdlib.h>
int main(){
int *ptr;
ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */
    if (ptr != NULL) {
      *(ptr + 5) = 480; /* assign 480 to sixth integer */
      printf("Value of the 6th integer is %d",*(ptr + 5));
    }
}

Produktion:

Value of the 6th integer is 480

Notice that sizeof(*ptr) was used instead of sizeof(int) in order to make the code more robust when *ptr declaration is typecasted to a different data type later.

Tilldelningen kan misslyckas om minnet inte räcker till. I det här fallet returnerar den en NULL-pekare. Så du bör inkludera kod för att leta efter en NULL-pekare.

Keep in mind that the allocated memory is contiguous and it can be treated as an array. We can use pekare arithmetic to access the array elements rather than using brackets [ ]. We advise to use + to refer to array elements because using incrementation ++ or += changes the address stored by the pointer.

Malloc-funktionen kan också användas med teckendatatypen såväl som komplexa datatyper som strukturer.

Why Use malloc() in C?

Static arrays and ordinary variables fix their size when the program is compiled, which wastes space when the requirement turns out smaller and fails outright when it turns out larger. malloc() solves this by requesting memory at runtime, so a program can size a buffer to the exact amount of data it receives. This runtime flexibility is the heart of dynamisk minnesallokering in C.

Dynamic allocation with malloc() is the right choice in several common situations:

  • The amount of input is unknown until the program runs, such as reading a file or a user-supplied list.
  • Large blocks are needed that would overflow the limited stack, since malloc() draws from the much larger heap.
  • Data must outlive the function that created it, because heap memory persists until it is explicitly released.
  • Structures and arrays need to grow or shrink while the program is executing.

Because the reserved block is handed back as a pointer, it can be passed between functions cheaply without copying the underlying data.

RELATERADE ARTIKLAR

How to Free Memory Allocated by malloc()

Memory reserved by malloc() lives on the heap and is never released automatically. When a program keeps allocating without freeing, it slowly consumes all available memory, a defect known as a memory leak. The free() function returns a finished block to the system so the space can be reused.

The free() function takes a single argument, the pointer that malloc() returned, and releases the whole block at once:

int *ptr;
ptr = malloc(10 * sizeof(int));
if (ptr != NULL) {
    /* use the allocated memory here */
    free(ptr);   /* release the block */
    ptr = NULL;  /* avoid a dangling pointer */
}

Follow these rules to manage dynamic memory safely:

  • Call free() exactly once for every successful malloc(); freeing the same block twice causes undefined behavior.
  • Set the pointer to NULL after freeing so it cannot be reused as a dangling pointer.
  • Never free() a pointer that malloc() did not return, including one shifted by pointer arithmetic.
  • Match every allocation with a matching release before the pointer goes out of scope.

keeping allocation and release in balance is the core discipline of manual memory management in C, and it prevents both leaks and crashes caused by reusing freed memory.

malloc() vs calloc(): Key Differences

malloc() and calloc() both reserve heap memory, but they differ in their arguments and in how they treat the new block. malloc() takes one argument, the total number of bytes, and leaves the contents uninitialized, so the block holds unpredictable garbage values until the program writes to it. calloc() takes two arguments, the number of elements and the size of each, and clears every byte to zero before returning the pointer.

The practical differences come down to three points:

  • Initialization: calloc() zeroes the memory, while malloc() does not, which makes malloc() slightly faster when the values will be overwritten anyway.
  • Arguments: you write malloc(n * size) but calloc(n, size) to reserve the same array.
  • Use case: choose calloc() when a clean, zeroed block matters, and malloc() when speed is preferred and initialization is handled manually.

Both functions are declared in stdlib.h, both return a void pointer or NULL on failure, and both hand their memory back with the same free() function.

Vanliga frågor

In C the cast is optional and often discouraged, because void* converts to any object pointer automatically and an explicit cast can mask a missing stdlib.h include. In C++, however, the cast is required.

A NULL return means the request failed, usually from insufficient memory. Always check the pointer before using it, because dereferencing NULL leads to undefined behavior and typically crashes the program.

realloc() resizes a block previously reserved by malloc(), keeping existing data up to the smaller size. If it fails it returns NULL and leaves the original block intact, so assign its result to a temporary pointer first.

A memory leak happens when heap memory from malloc() is never released with free(). The program keeps reserving space it no longer uses, which can gradually exhaust the memory available to it.

malloc() reserves memory on the heap, not the stack. Heap blocks stay valid until you call free(), so they can outlive the function that created them, unlike automatic stack variables that vanish on return.

malloc() is a library function that returns void* and needs sizeof to compute bytes. C++ new is an operator that returns a typed pointer and calls constructors. Pair malloc() with free(), and new with delete.

Yes. AI coding assistants draft malloc() calls, insert NULL checks, and flag missing free() calls or leaks, and they can explain pointer arithmetic. Always compile and test the generated code before trusting it.

GitHub Copilot suggests malloc(), sizeof(), and matching free() lines from a comment describing your intent. Review each suggestion for missing NULL checks and leaks before you compile.

Sammanfatta detta inlägg med: