La taille d'un pointeur est-elle constante ?

Le problème exposé dans ce sujet a été résolu.

Bonjour,

Pour une architecture donnée, la taille d’un pointeur est-elle toujours la même comme semble le montrer l’exemple ci-dessous ?

#include <stdio.h>

int main(void)
{
    int a = (int) sizeof(void*);
    int b = (int) sizeof(char*);
    int c = (int) sizeof(long unsigned int*);
    int d = (int) sizeof(FILE*);
    
    // Tailles : 8, 8, 8, 8
    printf("Tailles : %d, %d, %d, %d", a, b, c, d);
    return 0;
}

Si oui, peut-on en déduire qu’il est toujours possible de convertir un pointeur vers void* ?

+0 -0

Salut,

Pour une architecture donnée, la taille d’un pointeur est-elle toujours la même comme semble le montrer l’exemple ci-dessous ?

info-matique

Sur un processeur x86_64, cette affirmation est exacte, y compris pour les pointeurs de fonctions. Toutefois, comme te l’a précisé @Ksass`Peuk, du point de vue de la norme, c’est une autre histoire.

Pour les pointeurs sur des objets (autrement dit, tous sauf les pointeurs de fonctions), seule la conversion vers et depuis un pointeur sur void ou un pointeur sur char est garantie.

A pointer to void may be converted to or from a pointer to any object type. A pointer to any object type may be converted to a pointer to void and back again; the result shall compare equal to the original pointer.

[…]

A pointer to an object type may be converted to a pointer to a different object type. If the resulting pointer is not correctly aligned for the referenced 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.

ISO/IEC 9899:2017, doc. N2176, 6.3.2.3 Pointers, al. 1 et 7, p. 41

Pour les pointeurs de fonctions, comme expliqué dans le lien que t’a fourni @Ksass`Peuk, seule la conversion vers un autre pointeur de fonction est garantie (note bien seulement la conversion, pas son utilisation).

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 referenced type, the behavior is undefined.

ISO/IEC 9899:2017, doc. N2176, 6.3.2.3 Pointers, al. 8, p. 41
+0 -0

C’est la norme POSIX qui garantie ça en particulier. ;)

unidan

Mmm… La norme POSIX ne définit-elle pas plutôt des interfaces et des commandes ? Je ne pense pas qu’elle étende le standard C, en tous les cas pas concernant le langage en lui-même (la bilbiothèque standard est en revanche enrichie).

+0 -0

=> man dlopen

           /* According to the ISO C standard, casting between function
              pointers and 'void *', as done above, produces undefined results.
              POSIX.1-2003 and POSIX.1-2008 accepted this state of affairs and
              proposed the following workaround:

                  *(void **) (&cosine) = dlsym(handle, "cos");

              This (clumsy) cast conforms with the ISO C standard and will
              avoid any compiler warnings.

              The 2013 Technical Corrigendum to POSIX.1-2008 (a.k.a.
              POSIX.1-2013) improved matters by requiring that conforming
              implementations support casting 'void *' to a function pointer.
              Nevertheless, some compilers (e.g., gcc with the '-pedantic'
              option) may complain about the cast used in this program. */
+1 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte