Discussion :

[j0o0]

Bonjour,

J'ai une petite question simple : est-ce qu'il est assuré par la norme que les pointeurs ont toujours la même taille, quelque soient les types des objets pointés ?

sizeof(char *) == sizeof(int *) == sizeof(double *) == ... ?

[Franck.H]

Du point de vue de la norme il faudrait le vérifier mais en tous cas peu importe leur type, ils occupent tous la même taille... en tous cas chez moi.

[Jean-Marc.Bourguet]

Bonjour,

J'ai une petite question simple : est-ce qu'il est assuré par la norme que les pointeurs ont toujours la même taille, quelque soient les types des objets pointés ?

sizeof(char *) == sizeof(int *) == sizeof(double *) == ... ?

Non. Ce qui est assure c'est que caster n'importe que pointeur vers un void* (ou un char*, mais il vaut mieux utiliser un void* pour ca) puis revenir au pointeur initial est valide.

[j0o0]

Ok merci beaucoup !

[Skyounet]

Pourtant un pointeur c'est simplement une adresse. Peu importe le type pointé non ? Donc une adresse reste une adresse et sa taille ne change pas. Me trompe-je ?

[Franck.H]

Pourtant un pointeur c'est simplement une adresse. Peu importe le type pointé non ? Donc une adresse reste une adresse et sa taille ne change pas. Me trompe-je ?

Bin non tu te trompes pas, chez moi ca fait bien 4 octets partout

[Skyounet]

Bin non tu te trompes pas, chez moi ca fait bien 4 octets partout

Oui mais peut-on pas l'assurer ?

[Franck.H]

Oui mais peut-on pas l'assurer ?

Ca je ne jure de rien, ca peut changer suivant l'architecture matérielle voir même système je pense.

[Skyounet]

Ca je ne jure de rien, ca peut changer suivant l'architecture matérielle voir même système je pense.

Nan pas le fait qu'une adresse vaille 4 octets, ça oui ça peut changer mais le fait ben qu'un pointeur peu importe sur quoi il pointe soit egal à la taille d'un autre pointeur.

En gros j'en reviens à la question originale parce que la réponse de Jean-Marc ne m'a pas éclairé du tout.

Parce qu'un pointeur c'est une adresse on est d'accord. Donc peu importe si on a un pointeur sur int sur char ou sur double, un pointeur reste une adresse. Donc logiquement un pointeur sur un type x fait la même taille qu'un pointeur sur un type y non ? Et si oui peut-on l'assurer ?

J'enlève le tag Résolu

[Jean-Marc.Bourguet]

Il y a des architectures qui sont adressables par mot (c'est a dire qu'une adresse désigne une zone de 16, 18, 24, 32, 36 ou 48 bits pour celles que je suis capable de citer si on me le demande, il y en a peut-être d'autres). Dans ce genre d'architecture, une implémentation pour le C a le choix, soit elle prend pour taille de char un mot complet, ce qui est quand même un peu du gaspillage surtout que certaines sont limitées en mémoire (p.e. 18 bits d'adresse), soit on prend une partie d'un mot. Et alors un char* doit outre contenir l'adresse, mais aussi une désignation du char dans le mot. Donc il faut plus de place qu'une simple adresse pour un char*.

Les architectures a usage général adressable par mot sont anecdotiques de nos jours, mais ne l'étaient pas durant les années 80. A noter que la seule que je connais ayant un compilateur C avec un bon support de C90 utilise un mot par pointeur de toute manière, les pointeurs vers autre chose que des char ayant 18 bits d'inutilisés.

De nos jours, les seules architectures adressable par mot répandues sont celles de DSP et autres processeurs spécialises. Les implémentations de C font souvent (toujours?) le choix d'un char par mot parce que ça simplifie le travail d'écriture du compilateur et que la manipulation de chaines de caractères n'est pas ceux a quoi ils servent.

[Skyounet]

Hum, merci pour l'explication assez approfondie.

[Gruik]

L'autre jour j'ai commencé à lire le (dernier) "standard internationnal" sur le C (C99)
Jcopie colle les passages concernés

A pointer to void shall have the same representation and alignment requirements as a
pointer to a character type. Similarly, pointers to qualified or unqualified versions of compatible types shall have the same representation and alignment requirements. All pointers to structure types shall have the same representation and alignment requirements as each other. All pointers to union types shall have the same representation and alignment requirements as each other. Pointers to other types need not have the same representation or alignment requirements.

Ca dit qu'un "void *" a la meme representation qu'un "char *", qu'un "T *" a la meme representation qu'un "const/volatile T *", que les pointeurs sur structures ont tous la meme representation, pareil pour les union. Le reste des pointeurs n'a pas forcement la meme representation.


Et pour cet aspect

Non. Ce qui est assure c'est que caster n'importe que pointeur vers un void* (ou un char*, mais il vaut mieux utiliser un void* pour ca) puis revenir au pointeur initial est valide.

A pointer to an object or incomplete type may be converted to a pointer to a different object or incomplete type. If the resulting pointer is not correctly aligned for the
pointed-to type, the behavior is undefined. Otherwise, when converted back again, the result shall compare equal to the original pointer. When a pointer to an object is converted to a pointer to a character type, the result points to the lowest addressed byte of the object. Successive increments of the result, up to the size of the object, yield pointers to the remaining bytes of the object.

A pointer to a function of one type may be converted to a pointer to a function of another type and back again; the result shall compare equal to the original pointer. If a converted pointer is used to call a function whose type is not compatible with the pointed-to type, the behavior is undefined.

Donc c'est bien ce qu'avait dit JeanMarc, mais il faut que les pointeurs soient correctement "alignés" (j'avoue que c'est encore flou pour moi cette histoire d'alignement).

[Jean-Marc.Bourguet]

Donc c'est bien ce qu'avait dit JeanMarc, mais il faut que les pointeurs soient correctement "alignés" (j'avoue que c'est encore flou pour moi cette histoire d'alignement).

Il est courant qu'avoir des contraintes du genre "les entiers doivent avoir une adresse multiple de 4" qu'on appelle contrainte d'alignement.

Si tu forces un pointeur dans un autre qui a une contrainte d'alignement plus forte (par exemple un double* dans un float*), la norme permet que la copie inverse ne donne pas le pointeur initial.

Un exemple serait un char* dans un int* pour une architecture adressable par mot ayant fait le choix d'avoir sizeof(char) != sizeof(int); il est naturel de perdre l'indication "char dans le mot" en faisant cette assignation.