char x [256] par rapport à char * = malloc (256 * sizeof (char));

Dans le premier code, la mémoire est allouée dynamiquement sur le tas. Que la mémoire a besoin d'être libérée avec free(). Sa durée de vie est arbitraire: il peut traverser la fonction de limites, etc.

Dans le deuxième code, les 256 octets sont allouées sur la pile, et sont automatiquement récupéré lorsque la fonction renvoie (ou à la fin du programme, si elle est en dehors de toutes les fonctions). Si vous n'avez pas à (et ne peut) pas d'appeler free (). Il ne peut pas fuir, mais aussi de ne pas vivre au-delà de la fin de la fonction.

Choisir entre les deux, sur la base des exigences pour la mémoire.

Additif (Pax):

Si je peux ajouter à cela, Ned, la plupart des implémentations fournissent généralement plus de segment de pile (au moins par défaut). Ce ne sera pas généralement de la matière pour un total de 256 octets, sauf si vous êtes déjà en cours d'exécution hors de la pile ou de faire fortement récursive des trucs.

Aussi, sizeof(char) est toujours de 1 selon la norme de sorte que vous n'avez pas besoin de superflu de se multiplier. Même si le compilateur va probablement optimiser loin, il rend le code laid IMNSHO.

Fin additif (Pax).

Il existe une troisième possibilité, qui est que le tableau peut être déclarée à l'extérieur de la fonction, mais de manière statique, par exemple,

//file foo.c
char name[256];

int foo() {
    //do something here.
}

J'ai été plutôt surpris dans les réponses à une autre question sur de SORTE que quelqu'un a estimé que c'était inapproprié dans C; ici il n'est même pas mentionné, et je suis un peu confus et surpris (comme "quels sont-ils enseigner à des enfants à l'école ces jours-ci?") à propos de cette.

Si vous utilisez cette définition, la mémoire est allouée de manière statique, ni sur le tas, ni la pile, mais dans l'espace de données dans l'image. Ainsi est ni, doit être géré avec malloc/free, ni ne vous avoir à vous soucier de l'adresse réutilisés comme vous le feriez avec une option d'auto-définition.

Il est utile de rappeler l'ensemble ", a déclaré" vs "défini" chose ici. Voici un exemple

/* example.c */

char buf1[256] ;           /* declared extern, defined in data space */
static char buf2[256] ;    /* declared static, defined in data space */
char * buf3 ;              /* declared extern, defined one ptr in data space */
int example(int c) {       /* c declared here, defined on stack */
    char buf4[256] ;       /* declared here, defined on stack   */
    char * buf5 = malloc(256)]   /* pointer declared here, defined on stack */
                           /* and buf4 is address of 256 bytes alloc'd on heap */
    buf3 = malloc(256);    /* now buf3 contains address of 256 more bytes on heap */

    return 0;              /* stack unwound; buf4 and buf5 lost.      */
                           /* NOTICE buf4 memory on heap still allocated */
                           /* so this leaks 256 bytes of memory */
}

Maintenant dans un tout autre fichier

/* example2.c */

extern char buf1[];             /* gets the SAME chunk of memory as from example.c */
static char buf2[256];          /* DIFFERENT 256 char buffer than example.c */
extern char * buf3 ;            /* Same pointer as from example.c */
void undoes() {
     free(buf3);                /* this will work as long as example() called first */
     return ;
}

Briser votre déclaration

char* name = malloc(256*sizeof(char)); //one statement
char *name; //Step 1 declare pointer to character
name = malloc(256*sizeof(char)); //assign address to pointer of memory from heap
name[2]; //access 3rd item in array
*(name+2); //access 3rd item in array
name++; //move name to item 1

Traduction: le nom est désormais un pointeur de caractère qui est assignée à l'adresse de la mémoire sur le tas

char name[256]; //declare an array on the stack
name++; //error name is a constant pointer
*(name+2); //access 3rd item in array
name[2]; //access 3rd item in array
char *p = name;
p[2]; //access 3rd item in array
*(p+2); //access 3rd item in array
p++; //move p to item 1
p[0]; //item 1 in array

Traduction: le Nom est un pointeur constant vers un personnage que les points de la mémoire sur la pile

En C les tableaux et les pointeurs sont la même chose plus ou moins. Les tableaux sont constants des pointeurs de la mémoire. La principale différence est que lorsque vous appelez la fonction malloc vous prenez votre mémoire dans le tas et de la mémoire pris dans le tas doit être libéré dans le tas. Lorsque vous déclarez le tableau avec une taille de mémoire attribué à partir de la pile. Vous ne pouvez pas libérer cette mémoire car gratuit est fait pour libérer de la mémoire dans le tas. La mémoire sur la pile sera automatiquement libéré lorsque le programme actuel de l'unité retourne. Dans le deuxième exemple de free(p) serait une erreur aussi. p est un pointeur le nom de tableau sur la pile. Donc, en libérant de la p que vous essayez de libérer de la mémoire sur la pile.

Ce n'est pas différent de:

int n = 10;
int *p = &n;

libérant p dans ce cas serait une erreur parce que les points p de n, qui est une variable sur la pile. Donc p est titulaire d'un emplacement de mémoire dans la pile et ne peut pas être libéré.

int *p = (int *) malloc(sizeof(int));
*p = 10;
free(p);

dans ce cas, le libre est la bonne parce que p pointe vers un emplacement de la mémoire sur le tas qui a été allouée par malloc.