Quand devrais-je utiliser malloc en C et quand pas?

Je comprends comment fonctionne malloc (). Ma question est, je vais voir des choses comme ceci:

#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);

J'ai omis la vérification des erreurs par souci de concision. Ma question est la suivante: ne pouvez-vous pas simplement faire ce qui précède en initialisant un pointeur vers un stockage statique en mémoire? peut-être:

char *some_memory = "Hello World";

À quel moment avez-vous réellement besoin d'allouer vous-même la mémoire au lieu de déclarer / initialiser les valeurs que vous devez conserver?

char *some_memory = "Hello World";

crée un pointeur vers une constante de chaîne. Cela signifie que la chaîne "Hello World" sera quelque part dans la partie en lecture seule de la mémoire et que vous avez juste un pointeur vers elle. Vous pouvez utiliser la chaîne en lecture seule. Vous ne pouvez pas y apporter de modifications. Exemple:

some_memory[0] = 'h';

Demande des ennuis.

D'autre part

some_memory = (char *)malloc(size_to_allocate);

alloue un tableau de caractères (une variable) et some_memory pointe vers cette mémoire allouée. Maintenant, ce tableau est à la fois en lecture et en écriture. Vous pouvez maintenant faire:

some_memory[0] = 'h';

et le contenu du tableau devient "bonjour le monde"

Pour cet exemple exact, malloc est de peu d'utilité.

La principale raison pour laquelle malloc est nécessaire est lorsque vous avez des données qui doivent avoir une durée de vie différente de la portée du code. Votre code appelle malloc dans une routine, stocke le pointeur quelque part et finit par appeler gratuitement dans une routine différente.

Une raison secondaire est que C n'a aucun moyen de savoir s'il reste suffisamment d'espace sur la pile pour une allocation. Si votre code doit être 100% robuste, il est plus sûr d'utiliser malloc car votre code peut alors savoir que l'allocation a échoué et la gérer.

malloc est un outil formidable pour allouer, réallouer et libérer de la mémoire au moment de l'exécution, par rapport aux déclarations statiques comme votre exemple hello world, qui sont traitées au moment de la compilation et ne peuvent donc pas être modifiées en taille.

Malloc est donc toujours utile lorsque vous traitez des données de taille arbitraire, comme la lecture du contenu de fichiers ou le traitement des sockets et que vous ne connaissez pas la longueur des données à traiter.

Bien sûr, dans un exemple trivial comme celui que vous avez donné, malloc n'est pas le "bon outil magique pour le bon travail", mais pour les cas plus complexes (créer un tableau de taille arbitraire à l'exécution par exemple), c'est le seul moyen de aller.

Si vous ne connaissez pas la taille exacte de la mémoire que vous devez utiliser, vous avez besoin d'une allocation dynamique ( malloc). Un exemple peut être lorsqu'un utilisateur ouvre un fichier dans votre application. Vous devrez lire le contenu du fichier en mémoire, mais bien sûr vous ne connaissez pas la taille du fichier à l'avance, car l'utilisateur sélectionne le fichier sur place, au moment de l'exécution. Donc, fondamentalement, vous avez besoin malloclorsque vous ne connaissez pas à l'avance la taille des données avec lesquelles vous travaillez. Au moins c'est l'une des principales raisons d'utiliser malloc. Dans votre exemple avec une chaîne simple dont vous connaissez déjà la taille au moment de la compilation (plus vous ne voulez pas la modifier), cela n'a pas beaucoup de sens de l'allouer dynamiquement.

Légèrement hors sujet, mais ... vous devez faire très attention à ne pas créer de fuites de mémoire lors de l'utilisation malloc. Considérez ce 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;
}

Voyez-vous ce qui ne va pas avec ce code? Il existe une instruction de retour conditionnelle entre mallocet free. Cela peut sembler correct au début, mais réfléchissez-y. S'il y a une erreur, vous reviendrez sans libérer la mémoire que vous avez allouée. C'est une source courante de fuites de mémoire.

Bien sûr, c'est un exemple très simple, et il est très facile de voir l'erreur ici, mais imaginez des centaines de lignes de code parsemées de pointeurs, de mallocs, de frees et de toutes sortes de gestion des erreurs. Les choses peuvent devenir très compliquées très vite. C'est l'une des raisons pour lesquelles je préfère de loin le C ++ moderne au C dans les cas applicables, mais c'est un tout autre sujet.

Donc, chaque fois que vous utilisez malloc, assurez-vous toujours que votre mémoire est aussi susceptible d'être freed que possible.

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

est illégal, les littéraux de chaîne le sont const.

Cela allouera un tableau de caractères de 12 octets sur la pile ou globalement (selon l'endroit où il est déclaré).

char some_memory[] = "Hello World";

Si vous souhaitez laisser de la place pour d'autres manipulations, vous pouvez spécifier que le tableau doit être plus grand. (Cependant, ne mettez pas 1 Mo sur la pile.)

#define LINE_LEN 80

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

Une des raisons pour lesquelles il est nécessaire d'allouer la mémoire est si vous souhaitez la modifier au moment de l'exécution. Dans ce cas, un malloc ou un tampon sur la pile peut être utilisé. L'exemple simple d'affectation de "Hello World" à un pointeur définit la mémoire qui "généralement" ne peut pas être modifiée au moment de l'exécution.