Problème avec malloc

Bonjour,

Je ne parviens pas à allouer un tableau de manière dynamique :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <stdio.h> #include <stdlib.h>   int main(int argc, char *argv[]) { char *tab = NULL;   tab = malloc(5 * sizeof(char)); printf("%d\n", sizeof(tab)); free(tab);   return 0; }

---

le sizeof me renvoie toujours une taille de 4 octets et je ne comprends pas pourquoi. Je compile sous gnu gcc.

Merci de votre aide.

Bonjour,

« sizeof » est un mot-clé réservé du C et pas une fonction dans le sens où on l'entend d'habitude. Ça veut dire aussi que sizeof est évalué à la compilation.

Ici, tu écris sizeof(tab), donc il va toujours te renvoyer la taille du pointeur, quoi que celui pointe, soit quatre octets sur une machine 32 bits.

Bonjour,

C'est parce que sizeof te retourne la taille de ton pointeur vers la zone mémoire allouée... Or un pointeur a une taille de 4 octets ;) (pour contenir une adresse de 32 bits).

Donc tu as bien un tableau de 5 caractères qui est créé, mais tu ne peux malheureusement pas connaître sa taille (à part faire confiance à malloc qui renvoie 0 si la zone n'a pas pu être allouée).

Dans ce cas pour quoi quand on fait :

Code:

---

1 2	char tab[6] = "salut"; printf("%d\n", sizeof(tab));

---

celui-ci nous renvoie bien 6 ? Car tab est bien un pointeur sur le 1er élèment donc je devrai avoir 4 octets pour le pointeur.

Citation:

---

Envoyé par Flynet

Dans ce cas pour quoi quand on fait :

Code:

---

1 2	char tab[6] = "salut"; printf("%d\n", sizeof(tab));

---

celui-ci nous renvoie bien 6 ? Car tab est bien un pointeur sur le 1er élèment donc je devrai avoir 4 octets pour le pointeur.

---

Eh non ! :-) tab est un tableau, mais invoquer tab seul renvoie l'adresse de ce tableau, donc une valeur de type « char * ». Par contre, si tu écris :

Code:

---

const char * tab = "Salut';

---

Là, tu te retrouves avec un sizeof(tab) égal à 4.

C'est facile à retenir car, dans le cas de tab[6], tu alloues 6 caractères, mais tu n'alloues pas de mémoire supplémentaire pour stocker l'adresse du tableau (connue). Donc, à aucun moment, sizeof() ne pourrait te renvoyer 4.

Donc si je comprends bien, le fait d'utiliser la déclaration sous forme de pointeur fait que sizeof renverra la taille du pointeur. Mais dans le cas du tableau, l'adresse de la mémoire étant connue, sizeof ne renverra que la taille du tableau ?

Citation:

---

Envoyé par Flynet

Donc si je comprends bien, le fait d'utiliser la déclaration sous forme de pointeur fait que sizeof renverra la taille du pointeur. Mais dans le cas du tableau, l'adresse de la mémoire étant connue, sizeof ne renverra que la taille du tableau ?

---

C'est surtout que sizeof() va naturellement te renvoyer la taille qu'occupe une entité en mémoire. Lorsque tu déclares un pointeur, tu réserves quatre octets dans la pile. Lorsque tu déclares un tableau de six caractères, tu réserves exactement six octets dans la pile et rien d'autre (en considérant que chaque caractère occupe un seul octet et en négligeant les histoires de padding).

Un tableau n'est pas accompagné d'un pointeur en mémoire qui contient l'adresse des données qu'il contient. Sinon, ça veut dire que tu pourrais changer cette valeur. Essaie par exemple de compiler ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10

int main (void) { char * pointer = "Hello"; char buffer [6] = "World";   pointer = (char *)0x12345678; buffer = (char[6])0x12345678;   return 0; }

---

Code:

---

1 2 3

$ gcc programme.c -o programme programme.c: In function ‘main’: programme.c:7: erreur: le transtypage spécifie un type de tableau

---

Tu peux réaffecter « pointer » mais pas « buffer » car il n'y a pas de pointeur en mémoire associé au tableau.

Citation:

---

Envoyé par Flynet

Dans ce cas pour quoi quand on fait :

Code:

---

1 2	char tab[6] = "salut"; printf("%d\n", sizeof(tab));

---

celui-ci nous renvoie bien 6 ? Car tab est bien un pointeur sur le 1er élèment donc je devrai avoir 4 octets pour le pointeur.

---

Bien que les pointeurs et les tableaux soient souvent très similaires dans leur manipulation, un pointeur n'est pas un tableau et un tableau n'est pas un pointeur. Donc sizeof(tab) te donnera 6.

La cause de la confusion vient dans le fait que bien souvent on utilise un pointeur pour manipuler le contenu d'un tableau. D'où l'idée que c'est la même chose.
Exemple

Code:

---

1 2 3 4

char tab[6] = "salut"; char *pt=tab; for (i=0; i < 6; i++) printf("i=%d => tab=(%p) %c et pt=(%p) %c\n", i, &tab[i], tab[i], &pt[i], pt[i])

---

Mais la différence se voit ici

Code:

---

1 2 3 4

char tab[6] = "salut"; char *pt=tab; printf("taille tab: %d\n", sizeof(tab)); printf("taille pt: %d\n", sizeof(pt));

---

Et cette différence devient un gouffre quand on commence à travailler avec des tableaux multi-dimensionnels...

Merci de vos réponses, je comprend mieux à présent. Le problème c'est que sur le site où j'ai suivi la programmation, on nous fait comprendre que tableau est un pointeur et qu'il pointe sur le premier élèment du tableau d'où la confusion.

Ma question maintenant porte plutôt sur ton code obsidian, j'ai bien compris qu'on essayait de réaffecter des adresses mémoires mais que signifient les :
(char *)
(char[6])

C'est la première fois que je vois ce genre de choses.

Citation:

---

Envoyé par Flynet

Ma question maintenant porte plutôt sur ton code obsidian, j'ai bien compris qu'on essayait de réaffecter des adresses mémoires mais que signifient les :
(char *)
(char[6])

---

Il est sage de choisir tout de suite un document complet et bien construit (par exemple, le K&R), ou les cours de C, sinon tu vas aller d'approximations en approximations, tu vas prendre de mauvaises habitudes, et ce sera difficile de les changer ensuite.

Un nom de type seul entre parenthèses précédant une expression, c'est un « cast » ou « transtypage » en français. Il s'agit de convertir la valeur concernée dans le type en question. C'est aussi répandu en C que les pointeurs et fait partie des fondamentaux du langage.

Par exemple, « (int)2.5 » vaut « 2 », puisque « 2.5 » est de type double par défaut, puis converti en int par le biais du cast. Ne subsiste donc que la partie entière.

Souvent, ces conversions sont implicites quand le compilateur sait les faire (conversions entre types numériques), la plupart du temps, elles sont explicites, et parfois, elles sont impossibles.

En particulier, les pointeurs sont des types à part entière et peuvent donc être transtypés. C'est très utile mais c'est aussi la porte ouverte à tous les bricolages, même les plus sales. Tu ne peux pas convertir un entier en structure, par exemple, parce que ça n'a pas de sens et, de toutes façons, le compilo ne saurait pas quel genre de résultat ce serait censé donner. Par contre, une adresse mémoire étant une adresse mémoire, tu peux très bien affirmer qu'un « int * », soit « l'adresse en mémoire d'un int » est en fait l'adresse en mémoire de n'importe quoi d'autre. À partir du moment où c'est faisable (l'adresse en elle-même reste inchangée) et que tu affirmes cela explicitement au compilo, il va te croire.

Dans le cas qui nous intéresse, donc, j'invente une adresse bidon (« 0x12345678 ») qui est, à ce stade, considérée par le compilateur comme un nombre entier et pas un pointeur. Ensuite, je transtype ce nombre vers le type de chacune de mes variables, pour avoir des arguments de même nature de chaque côté du « = ».

On voit alors qu'on peut affecter une nouvelle valeur à un pointeur, mais pas à un tableau.

Pour quoi ne pas avoir directement fait :

Code:

---

pointer = 0x12345678;

---

Car de toute manière l'adresse est elle aussi un nombre. De la même manière on ne fait pas :

Code:

---

1 2	int nombre = 0; nombre = (int)56;

---

A moins que dans le 1er cas, le compilateur ne sait pas faire cette conversion implicite ?

Citation:

---

Envoyé par Flynet

Pour quoi ne pas avoir directement fait :

Code:

---

pointer = 0x12345678;

---

Car de toute manière l'adresse est elle aussi un nombre.

---

Mais pas d'un point de vue sémantique. Pour le C, un nombre est un nombre, avec ses propriétés, et un pointeur est un pointeur, avec ses autres propriétés. Par exemple, il n'est pas possible d'additionner deux pointeurs. Additionner deux adresses en mémoire ne correspond pas à une troisième adresse en mémoire.

Exemple : 5 + 8 = 13. Ces deux expressions (de part et d'autre de « = ») représentent la même valeur du même type. Tu peux donc sans problème substituer l'une à l'autre. Par contre, ce n'est pas parce que dans ta rue, tu habites au № 5 et qu'un de tes amis habite au № 8 qu'à vous deux, vous habitez au № 13.

Donc, le C est capable de convertir directement les types numériques entre eux (int, long, float, etc) parce qu'ils font tous partie de ℝ ou de l'un de ses sous-ensembles.

De plus, le plan mémoire d'une machine n'est pas forcément continu, et certaines valeurs peuvent être interdites directement au niveau du micro-processeur :

http://www.developpez.net/forums/d61...r/#post3615287

Citation:

---

Code:

---

1 2	int nombre = 0; nombre = (int)56;

---

---

Oui, mais justement : si l'on enlève le cast, de quel type est « 56 » ? Cette question n'est pas anodine et la réponse est apportée dans la norme de façon explicite. Cela permet d'expliquer aussi certains petits mystères tels que celui qui se produit dans ce petit morceau de code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <stdio.h>   int main (void) { long long x;   x = 0x40000000; x = x << 2; printf ("x vaut %llx\n",x);   x = 0x40000000 << 2; printf ("x vaut %llx\n",x);   return 0; }

---

… qui donne :

Code:

---

1 2 3

$ ./programme x vaut 100000000 x vaut 0

---

Je te laisse deviner pourquoi.

Euh, étrangement j'ai pas le même résultat :?

Je l'ai compilé sous gcc mais voilà ce que j'obtiens :
x vaut 0
x vaut 0

ps: Quelles sont les balises à mettre pour le shell ?

C'est ma faute. Il fallait utiliser « long long » à la place de « long », et « %llx » plutôt que « %lx », et compiler en C99. L'exemple est censé fonctionner partout. S'il fonctionnait quand même chez moi, c'est justement parce que j'utilise une machine 64 bits.

En soi, c'est déjà un effet de bord intéressant à étudier.

Pour le premier cas je crois comprendre qu'il y a une conversion implicite, ce qui ne doit pas être le cas du 2e. Néanmoins certaines questions me viennent à l'esprit.

La première c'est qu'en modifiant un peu le code gcc m'a fait comprendre que l'argument x passé à printf est de type long long int or on l'a déclaré comme un long long ?

Ensuite j'ai essayé de faire :

Code:

---

printf ("x vaut %llx\n", (0x40000000 << 2));

---

et gcc me dit que l'argument est un int, donc je me demande pourquoi on a déclaré un long long pour le stocker ? Sinon, je retourne toujours sur le même résultat 0 en utilisant "%d".

Enfin pourquoi est-ce que le 2e cas ne marche pas ? Et pourquoi quand je fais :

Code:

---

printf ("x vaut %d\n", (0x30000000 << 2));

---

J'obtients bien un résultat : -1073741824
Est-ce lié au fait que (0x40000000 << 2) dépasse la capacité d'un int ?

Citation:

---

Envoyé par Flynet

et gcc me dit que l'argument est un int, donc je me demande pourquoi on a déclaré un long long pour le stocker ?

---

Tu chauffes ! :-)

Citation:

---

Est-ce lié au fait que (0x40000000 << 2) dépasse la capacité d'un int ?

---

Oui.

Citation:

---

Envoyé par Flynet

Et pourquoi quand je fais :

Code:

---

printf ("x vaut %d\n", (0x30000000 << 2));

---

J'obtients bien un résultat : -1073741824
Est-ce lié au fait que (0x40000000 << 2) dépasse la capacité d'un int ?

---

En fait, le processeur ne s'embête pas. Il fait le calcul et positionne le résultat là où tu l'as demandé. Et si le résultat est trop grand pour tenir, ben ce qui dépasse disparait.

Cette méthode permet d'ailleurs des raccourcis de calculs.
Exemple: regardons le codage binaire de +3 et de -3 sur 8 bits
+3 = 0000 0011
-3 = 1111 1101 (chaque bit de +3 est inversé puis on ajoute 1 au résultat)

Calculons maintenant (+3) + (-3) toujours sur 8 bits
0000 0011
+ 1111 1101
------------
1 0000 0000
Tu remarques que le premier "1" dépasse la capacité de stockage => il est supprimé et le résultat donne 0 ce qui est mathématiquement correct.
Ainsi, la méthode de codage des négatifs (inverser chaque bit du positif puis ajouter 1) permet au processeur de calculer plus rapidement.

Regardons maintenant 0x30000000. Cela donne
00110000 00000000 00000000 00000000

Décalé de 2, cela donne 11000000 00000000 00000000 00000000
Le premier "1" indiquant un négatif, pour calculer de quel nombre il s'agit je le convertis en positif selon la méthode inverse (enlever 1 puis tout inverser)
Enlever 1 donne alors 10111111 11111111 11111111 11111111
Tout inverser donne ensuite 01000000 00000000 00000000 00000000 soit 0x40000000 soit 1073741824

Conclusion: 0x30000000 << 2 donne bien -1073741824...

Bonjour,

Oui en fait j'avais trouvé la réponse mais je n'ai pas eu le temps de poster.
Merci quand même pour ton explication Sve@r.

En fait des deux cotés de "<<", 0x40000000 et 2 sont tous les deux des int. Du coup le compilateur ne fait rien et quand on déplace de 2 bits on arrive à 32 bits qui est supérieur a la capacité d'un int d'où le résultat 0. Comme tu l'as expliqué le '1' a été expulsé.

En faisant :

Code:

---

x = (long long) 0x40000000 << 2;

---

le 0x40000000 est transformé en long long de même que le 2 de manière implicite. Du coup le résultat est bien stocké.

Citation:

---

Envoyé par Flynet

On nous fait comprendre que tableau est un pointeur et qu'il pointe sur le premier élèment du tableau d'où la confusion.

---

oui c'est vrais que un tableau c'est un pointeur qui pointe sur le premier élément et pour les variables aussi et pour un pointeur normale en réalité c'est un pointeur de pointeur je vais t'exprimer ça pas a pas, un pointeur tous simplement une adresse sauvé en mémoire, je vais te donne une exemple imaginer que nous savons l'adresse de pointeur avant de le crée

Citation:

---

#define pointeur 0x956000

unsigned char data = 0xAA;
pointeur = data ; //ici on a affecté la donnée 0xAA a l'adresse 0x95600

---

c'est la meme chose avec la déclaration de pointeur mais ici on a une adresse de pointeur valide definé par le system

Citation:

---

unsigned char *pointeur = NULL;

unsigned char data = 0xAA;
pointeur = data ; //ici on a affecté la donnée 0xAA a une l'adresse valide

---

et pour les tableaux, un 'nom' de tableau lui meme est un variable imagine toi exemple on déclare un tableau de dix cases et on laisse les crochets"[9]" a coté voir ce qu'il reste

Citation:

---

unsigned char nomdetableau;//déclaration de tablau de dix cases

---

il nous reste qu'une variable / mais que fait cette variable ici?/pour sauvé une adresse /la qu'elle? /c'est le system qui va choisir cette adresse/ pour quoi?/pour mettre les dix cases de ton tableau en mémoire/c'est la meme chose avec un pointeur normale avec seulement un nom différant

Citation:

---

unsigned char pointeur[9]; //un pointeur de dix cases

---

meme chose avec les variables et bonne chanse :ccool:

Citation:

---

Envoyé par PIC16F877A

oui c'est vrais que un tableau c'est un pointeur

---

non

Citation:

---

Envoyé par PIC16F877A

qui pointe sur le premier élément

---

Le nom d'un tableau est équivalent à l'adresse de son premier élément

Citation:

---

Envoyé par PIC16F877A

et pour les variables aussi et pour un pointeur normale en réalité c'est un pointeur de pointeur

---

Hum, es-tu certain que les mots vont bien de ton cerveau au clavier sans altération intermédiaire due à un facteur externe indépendant de ta volonté ???

Citation:

---

Envoyé par PIC16F877A

je vais t'exprimer ça pas a pas, un pointeur tous simplement une adresse sauvé en mémoire, je vais te donne une exemple imaginer que nous savons l'adresse de pointeur avant de le crée

Code:

---

1 2 3 4

#define pointeur 0x956000   unsigned char data = 0xAA; pointeur = data ; //ici on a affecté la donnée 0xAA a l'adresse 0x95600

---

---

Superbe !!! Dans ton exemple, pointeur n'est pas une variable mais une macro. Tu ne peux pas lui mettre de valeur !!!

Citation:

---

Envoyé par PIC16F877A

c'est la meme chose avec la déclaration de pointeur mais ici on a une adresse de pointeur valide definé par le system

Code:

---

1 2 3 4

unsigned char *pointeur = NULL;   unsigned char data = 0xAA; pointeur = data ; //ici on a affecté la donnée 0xAA a une l'adresse valide

---

---

Magnifique. Tu stockes un caractère dans une zone prévue pour recevoir une adresse !!!

Citation:

---

Envoyé par PIC16F877A

et pour les tableaux, un 'nom' de tableau lui meme est un variable imagine toi exemple on déclare un tableau de dix cases et on laisse les crochets"[9]" a coté voir ce qu'il reste

il nous reste qu'une variable / mais que fait cette variable ici?/pour sauvé une adresse /la qu'elle? /c'est le system qui va choisir cette adresse/ pour quoi?/pour mettre les dix cases de ton tableau en mémoire/c'est la meme chose avec un pointeur normale avec seulement un nom différant

---

Et vice-versa

Citation:

---

Envoyé par PIC16F877A

meme chose avec les variables et bonne chanse :ccool:

---

Oui, avec tes explications nébuleuses, il en aura effectivement super besoin de "chance" !!!

Citation:

---

Envoyé par Flynet

En faisant :

Code:

---

x = (long long) 0x40000000 << 2;

---

le 0x40000000 est transformé en long long de même que le 2 de manière implicite. Du coup le résultat est bien stocké.

---

Oui. Tout calcul s'exécute dans le type le plus large des opérandes impliqués dans le calcul.

Attention toutefois, car le type le plus large ne s'applique qu'aux opérandes en cours de calculs et non ceux qui attendent leur tour.

Exemple: printf("%f", 3/2 + 1.0)

Voyant dans ce calcul deux int et un float, tu peux supposer que le calcul se fera en float et que tu obtiendras 2.5
Or la première opération "3/2" ne fait intervenir que des int et le "1.0" n'étant pas impliqué n'a aucune action. Le calcul se fera donc en int et donnera un int "1". Puis 1 + 1.0 se fera bien en float mais trop tard et donnera alors malheureusement 2.0