En supposant qu'une adresse de mémoire occupe 4 octets et un produit de carbonisation occupe 1 octet:Combien d'octets sont alloués dynamiquement dans le segment de code suivant?
char** t;
t = malloc(5 * sizeof(char*));
int i;
for (i = 0; i < 5; i++)
t[i] = malloc(sizeof(char) * (i+1));
35 octets (Voir ci-dessous pour la rupture)
char** t;
t = malloc(5 * sizeof(char*)); // 5 * 4 = 20 bytes
int i;
for (i = 0; i < 5; i++)
t[i] = malloc(sizeof(char) * (i+1)); //1 + 2 + 3 + 4 + 5 = 15 bytes
Mieux que la dernière réponse, vous avez vu le 'i + 1'. –
Donc, cela correspond en effet à (0 + 1) = 1, (0 + 2) = 2 .... (0 + 4) = 5. Réfléchir avant d'agir. –
35 sur une machine de 32 bits.
20 pour que
t = malloc(5 * sizeof(char*));
15 pour que: 5 + 4 + 3 + 2 + 1
int i;
for (i = 0; i < 5; i++)
t[i] = malloc(sizeof(char) * (i+1));
un minimum d'environ 35 octets - mais une mise en oeuvre typique de malloc auront une certaine taille d'allocation minimale qu'il prend en charge, donc en réalité, vous pouvez vous attendre à ce qu'il utilise plus de mémoire que cela (bien que le nombre exact de variables varie). Dans un cas typique, l'allocation minimum sera de 16 ou même 32 octets, auquel cas la plupart des tailles que vous avez spécifiées ci-dessus ne font pas vraiment de différence - les 5 dernières allocations seront toutes de le minimum arrive à être. Dans un cas typique, les tailles plus grandes seront arrondies à la puissance suivante de 2. Cela donnerait 32 octets pour votre première allocation, et 16 ou 32 (c'est-à-dire, la taille minimum supportée) pour chacun de vos cinq autres, pour un total de 112 ou 192 octets.
La façon dont je pourrais le mettre est qu'il alloue 35 octets qui sont utilisables pour le programme, mais le coût/overhead des allocations est plus élevé. –
Obtenez le nombre d'octets sont alloués SUR VOTRE SYSTÈME avec, par exemple
#define malloc(s) mm(s)
void *mm(size_t s) {
printf("allocating %d ...\n", (int)s);
return (malloc)(s);
}
/* your code */
Bien sûr, vous pouvez additionner les tailles au lieu de les imprimer.
Laissez le calcul de l'ordinateur pour vous:
char** t;
t = (char**) malloc(5 * sizeof(char*));
int i;
for (i = 0; i < 5; i++)
t[i] = (char*) malloc(sizeof(char) * (i+1));
unsigned int sz = 5 * sizeof(char*);
for (i = 0; i < 5; i++)
sz += sizeof(char) * (i+1);
printf("%d\n", sz);
Le malloc() alloue de l'espace arrondi à 16 octets (au moins en win32), de sorte que vous allez utiliser 32 octets dans la première alloc et 16 * 5 en la boucle.
Il y a aussi les frais généraux de malloc (à la fois, le temps et la mémoire), parce que malloc() met un en-tête spécial, _CrtMemBlockHeader avant la zone de mémoire, il retourne (c'est pourquoi vous devez donner exactement le même pointeur sur le free() et sont en mesure de .. utiliser des fonctions comme _msize()
Ainsi, la quantité de mémoire réellement utilisée serait de 32 + 80 = 112 octets Considérant également les frais généraux pour en-tête: + 5 * sizeof (__ CrtMemBlockHeader)
le montant final peut être aussi élevé de 300 octets, soit environ 8 fois plus que le nombre attendu de 35.
Ma réponse est 39. Mais, je ne suis pas certain. –
Un caractère occupe toujours 1 octet - selon la norme. – sje397
'malloc' ne garantit pas d'allouer exactement le nombre d'octets demandés. 'malloc' alloue * au moins * le montant demandé. Ce qui signifie que la réponse correcte à la question indiquera toujours que "N octets au moins est attribué", quel que soit ce N. – AnT