malloc vs. calloc: Wichtige Unterschiede mit praktischen Beispielen erklärt

Was ist dynamische Speicherallokation?

Dynamische Speicherallokation ermöglicht es einem Programm, zur Laufzeit Speicher anzufordern und freizugeben. In C stellt die Standardbibliothek vier Hauptfunktionen dafür bereit: malloc(), calloc(), realloc() und free() – alle deklariert in stdlib.h.

malloc(): Einzelnen Speicherblock allokieren

malloc() (kurz für „memory allocation“) reserviert einen zusammenhängenden Block von Bytes und gibt einen Zeiger auf das erste Byte zurück. Der Inhalt des neu allokierten Blocks ist undefiniert (enthält zufällige Bitmuster).

Typische Verwendung:

int *p = (int *)malloc(n * sizeof(int));

Schlägt die Anfrage fehl, gibt malloc() NULL zurück.

calloc(): Mehrere null-initialisierte Blöcke allokieren

calloc() (kurz für „contiguous allocation“) nimmt zwei Argumente entgegen: die Anzahl der Elemente und die Größe jedes Elements. Es allokiert Speicher für alle Elemente und setzt jedes Byte automatisch auf null – ideal für Arrays oder Strukturen, die einen sauberen Startzustand benötigen.

Typische Verwendung:

int *p = (int *)calloc(n, sizeof(int));

Wie malloc() gibt es NULL zurück, falls die Allokation fehlschlägt.

Wann welche Funktion verwenden?

• malloc() – Verwenden, wenn Sie einen einzelnen Block benötigen und den Speicher selbst initialisieren. Etwas schneller, da der Null-Schritt entfällt.
• calloc() – Verwenden, wenn Sie ein Array oder eine Struktur benötigen, die mit Nullen initialisiert starten soll. Die automatische Initialisierung schützt vor versehentlicher Nutzung von Müllwerten.

Syntax-Übersicht

malloc()

void *malloc(size_t size);

calloc()

void *calloc(size_t num, size_t size);

Praktische Code-Beispiele

Beispiel 1: malloc() für 15 Integer

#include <stdlib.h>
#include <stdio.h>
int main(void) {
    int *ptr = malloc(15 * sizeof(*ptr));
    if (!ptr) {
        perror("malloc fehlgeschlagen");
        return EXIT_FAILURE;
    }
    ptr[5] = 480; // 6. Element (0-basierter Index)
    printf("Wert des 6. Integer ist %d\n", ptr[5]);
    free(ptr);
    return EXIT_SUCCESS;
}

Ausgabe: Wert des 6. Integer ist 480

Beispiel 2: calloc() für Summenberechnung

#include <stdlib.h>
#include <stdio.h>
int main(void) {
    int *ptr = calloc(10, sizeof(int));
    if (!ptr) {
        perror("calloc fehlgeschlagen");
        return EXIT_FAILURE;
    }
    int sum = 0;
    for (int i = 0; i < 10; ++i) {
        ptr[i] = i; // Initialisierung redundant, aber zur Verdeutlichung
        sum += ptr[i];
    }
    printf("Summe = %d\n", sum);
    free(ptr);
    return EXIT_SUCCESS;
}

Ausgabe: Summe = 45

Direkter Vergleich

Merkmal	malloc()	calloc()
Anzahl Parameter	1 (Größe)	2 (Anzahl, Größe)
Speicherzustand nach Allokation	Uninitialisiert (Müllwerte)	Null-initialisiert
Typischer Anwendungsfall	Einzelblock, manuelle Initialisierung	Arrays/Strukturen mit sauberem Start
Performance	Schneller (kein Nullen)	Langsamer (Null-Overhead)
Sicherheit	Höheres Risiko durch Müllwerte	Geringeres Risiko durch Auto-Nullung
Rückgabewert bei Fehlschlag	NULL	NULL
Standard-Header	stdlib.h	stdlib.h

Fazit

• Nutzen Sie malloc() für einzelne Blöcke, die Sie selbst initialisieren – für leichten Performance-Gewinn.
• Nutzen Sie calloc() für null-initialisierten Speicher, besonders bei Arrays/Structs, um subtile Bugs zu vermeiden.
• Beide Funktionen geben NULL bei Fehlschlag zurück – immer prüfen vor Dereferenzierung.
• Allokierten Speicher mit free() freigeben, um Memory Leaks zu verhindern.