Wann sollte ich malloc in C verwenden und wann nicht?

Ich verstehe, wie malloc() funktioniert. Meine Frage ist, ich werde Dinge wie diese sehen:

#define A_MEGABYTE (1024 * 1024)

char *some_memory;
size_t size_to_allocate = A_MEGABYTE;
some_memory = (char *)malloc(size_to_allocate);
sprintf(some_memory, "Hello World");
printf("%s\n", some_memory);
free(some_memory);

Ich habe die Fehlerprüfung der Kürze halber weggelassen. Meine Frage ist, können Sie nicht einfach das Obige tun, indem Sie einen Zeiger auf einen statischen Speicher im Speicher initialisieren? vielleicht:

char *some_memory = "Hello World";

An welchem ​​Punkt müssen Sie den Speicher tatsächlich selbst zuweisen, anstatt die Werte zu deklarieren/initialisieren, die Sie beibehalten müssen?

char *some_memory = "Hello World";

erstellt einen Zeiger auf eine String-Konstante. Das bedeutet, dass die Zeichenfolge “Hello World” irgendwo im schreibgeschützten Teil des Speichers sein wird und Sie nur einen Zeiger darauf haben. Sie können die Zeichenfolge schreibgeschützt verwenden. Du kann nicht Änderungen daran vornehmen. Beispiel:

some_memory[0] = 'h';

Bittet um Ärger.

Auf der anderen Seite

some_memory = (char *)malloc(size_to_allocate);

weist ein char-Array (eine Variable) zu und some_memory zeigt auf diesen zugewiesenen Speicher. Jetzt kann dieses Array sowohl gelesen als auch geschrieben werden. Sie können jetzt Folgendes tun:

some_memory[0] = 'h';

und der Inhalt des Arrays ändert sich zu “hello World”

Für genau dieses Beispiel ist malloc von geringem Nutzen.

Der Hauptgrund, warum malloc benötigt wird, ist, wenn Sie Daten haben, deren Lebensdauer sich vom Codebereich unterscheiden muss. Ihr Code ruft malloc in einer Routine auf, speichert den Zeiger irgendwo und ruft schließlich free in einer anderen Routine auf.

Ein zweiter Grund ist, dass C nicht wissen kann, ob auf dem Stack noch genügend Speicherplatz für eine Zuordnung vorhanden ist. Wenn Ihr Code 100 % robust sein muss, ist es sicherer, malloc zu verwenden, da Ihr Code dann erkennen kann, dass die Zuordnung fehlgeschlagen ist, und damit umgehen kann.

malloc ist ein wunderbares Werkzeug zum Zuweisen, Neuzuordnen und Freigeben von Speicher zur Laufzeit, im Vergleich zu statischen Deklarationen wie Ihrem Hallo-Welt-Beispiel, die zur Kompilierzeit verarbeitet werden und daher nicht in der Größe geändert werden können.

Malloc ist daher immer dann nützlich, wenn Sie mit Daten beliebiger Größe zu tun haben, z. B. beim Lesen von Dateiinhalten oder beim Umgang mit Sockets, und Sie sich der Länge der zu verarbeitenden Daten nicht bewusst sind.

In einem trivialen Beispiel wie dem von Ihnen gegebenen ist malloc natürlich nicht das magische “richtige Werkzeug für den richtigen Job”, aber für komplexere Fälle (z. B. das Erstellen eines Arrays beliebiger Größe zur Laufzeit) ist es die einzige Möglichkeit gehen.

Wenn Sie die genaue Größe des zu verwendenden Speichers nicht kennen, benötigen Sie eine dynamische Zuweisung (malloc). Ein Beispiel könnte sein, wenn ein Benutzer eine Datei in Ihrer Anwendung öffnet. Sie müssen den Inhalt der Datei in den Speicher einlesen, kennen aber natürlich die Größe der Datei nicht im Voraus, da der Benutzer die Datei zur Laufzeit an Ort und Stelle auswählt. Also im Grunde braucht man malloc wenn Sie die Größe der Daten, mit denen Sie arbeiten, nicht im Voraus kennen. Zumindest ist das einer der Hauptgründe für die Verwendung malloc. In Ihrem Beispiel mit einer einfachen Zeichenfolge, deren Größe Sie bereits zur Kompilierzeit kennen (und Sie sie nicht ändern möchten), ist es nicht sinnvoll, diese dynamisch zuzuweisen.

Etwas off-topic, aber … Sie müssen sehr vorsichtig sein, um bei der Verwendung keine Speicherlecks zu erzeugen malloc. Betrachten Sie diesen Code:

int do_something() {
    uint8_t* someMemory = (uint8_t*)malloc(1024);

    // Do some stuff

    if ( /* some error occured */ ) return -1;

    // Do some other stuff

    free(someMemory);
    return result;
}

Sehen Sie, was an diesem Code falsch ist? Dazwischen gibt es eine bedingte return-Anweisung malloc und free. Es mag auf den ersten Blick in Ordnung erscheinen, aber denken Sie darüber nach. Wenn ein Fehler auftritt, werden Sie zurückkehren, ohne den zugewiesenen Speicher freizugeben. Dies ist eine häufige Ursache für Speicherlecks.

Natürlich ist dies ein sehr einfaches Beispiel, und es ist sehr einfach, den Fehler hier zu sehen, aber stellen Sie sich Hunderte von Codezeilen vor, die mit Zeigern übersät sind, mallocs, frees und alle Arten der Fehlerbehandlung. Die Dinge können sehr schnell sehr chaotisch werden. Das ist einer der Gründe, warum ich modernes C++ in bestimmten Fällen C++ vorziehe, aber das ist ein ganz anderes Thema.

Also wann immer Sie es verwenden mallocStellen Sie immer sicher, dass Ihr Gedächtnis so gut wie möglich ist freed wie möglich.

char *some_memory = "Hello World";
sprintf(some_memory, "Goodbye...");

ist illegal, String-Literale sind es const.

Dadurch wird ein 12-Byte-Char-Array auf dem Stapel oder global zugewiesen (je nachdem, wo es deklariert ist).

char some_memory[] = "Hello World";

Wenn Sie Raum für weitere Manipulationen lassen möchten, können Sie angeben, dass das Array größer dimensioniert werden soll. (Bitte legen Sie jedoch nicht 1 MB auf den Stapel.)

#define LINE_LEN 80

char some_memory[LINE_LEN] = "Hello World";
strcpy(some_memory, "Goodbye, sad world...");
printf("%s\n", some_memory);

Ein Grund, warum es notwendig ist, den Speicher zuzuweisen, ist, wenn Sie ihn zur Laufzeit ändern möchten. In diesem Fall kann ein Malloc oder ein Puffer auf dem Stack verwendet werden. Das einfache Beispiel der Zuweisung von „Hello World“ an einen Zeiger definiert Speicher, der „normalerweise“ zur Laufzeit nicht geändert werden kann.