allocation de mémoire double point

Question

char ** r; r = (char **) malloc (10);

l'allocation ci-dessus est suffisant? Je n'ai pas besoin d'allouer pour char * r à travers pour la boucle? Tout peut expliquer lequel est juste?

Answer 1

En supposant que vous souhaitiez allouer 10 pointeurs char, cela ne fonctionnera pas. Vous allouez plutôt de la mémoire pour 10 octets.

Un pointeur char est susceptible d'être de plus d'un octet. Heureusement, votre compilateur connaît la taille réelle de celui-ci.

char** r = (char**)malloc(sizeof (char*) * 10); 

Ceci alloue suffisamment de place pour 10 pointeurs char. Cependant, actuellement, ils ne pointent nulle part utile. Vous devez allouer de la mémoire pour eux aussi:

int sizeOfMyStrings = 20; 
for (int i = 0; i < 10; i++) 
    r[i] = (char*)malloc(sizeoOfMyStrings); 

Cela vous donne 10 pointeurs char, chacun pointant vers 20 octets de mémoire allouée.

(Il n'y a pas sizeof impliqué ici parce que ce serait sizeof(char) et sizeof(char) est défini comme 1.)

Answer 2

Cela est certainement faux. Un char* est d'une taille qui ne divise pas 10 sur la plupart des architectures.

Voici quelques exemples de code:

char** r; 
// Allocate an array of 10 char* in r 
r = (char**)malloc(10 * sizeof(*r)); 

Maintenant, chaque élément de r est un char* affecté et peut être utilisé pour pointer quelque part.

Notez également que dans le code ci-dessus je lance (comme vous l'avez fait) le résultat de malloc. Cela n'est nécessaire que si ce code est compilé avec un compilateur C++ et non un compilateur C qui n'a pas besoin de la conversion. OTOH, en C++ vous auriez besoin de new, pas de malloc.

Answer 3

Un char ** r est un pointeur vers un pointeur char. Il peut être vu comme un tableau de chaînes. Si vous vouliez initialiser toute la mémoire pour le tableau, vous auriez besoin de faire

r = (char **)malloc(sizeof(char *) * NUMBER_OF_ELEMENTS_OF_ARRAY); 
for (i = 0; i < NUMBER_OF_ELEMENTS_OF_ARRAY; i++) { 
    r[i] = (char *)malloc(sizeof(char) * LENGTH_YOU_WANT_STRING); 
} 

ou quelque chose comme ça.

Answer 4

Une façon simple d'allouer de la mémoire pour la structure « 2 dimensions » d'une manière que vous voulez est:

#include <stdlib.h> /* for malloc() */ 

char **r; 
/* we will allocate 'size' values, each of 'data_size' length */ 
size_t size = 10; 
size_t data_size = 42; 
size_t i; 

/* allocate 'size' objects of the right type. 
* 
* Notes: 
* 
* 1. no casting the return value of malloc(), 
* 2. r = malloc(size * sizeof *r) is type-agnostic, so 
     if you change the type of r, you don't need to remember 
     to change the malloc() call */ 

r = malloc(size * sizeof *r); 

/* Error check omitted for clarity. In real code, always check for return 
    value of malloc() */ 

for (i=0; i < size; ++i) { 
    /* once again, no cast, and we use x = malloc(size * sizeof *x) idiom */ 
    r[i] = malloc(data_size * sizeof *r[i]); 
} 

L'avantage du schéma ci-dessus est que cela fonctionne avec un minimum d'effort pour 3, 4 -, ou des dimensions plus élevées, et est plus facile à lire aussi.

Dans le code ci-dessus, dans la boucle, je aurait pu écrire malloc(data_size) au lieu de malloc(data_size * sizeof *r[i]), car sizeof(char) est garanti à 1, mais encore une fois, je préfère la forme ci-dessus parce que c'est de type agnostique.