c: la taille de void*

Je suis un peu confus avec un pointeur void* en C. Surtout après la lecture de cette question: Est la sizeof(certains pointeur) toujours égal à quatre?, lorsqu'une personne affirme qu'il n'existe aucune garantie que sizeof(int *) == sizeof(double *)

Ma question est: est-il une garantie de sizeof(void*) >= sizeof(tout autre type de pointeur)?
En d'autres termes, puis-je toujours attribuer une some_type* pointeur vers un pointeur void* et le récupérer comme some_type*?

InformationsquelleAutor facha | 2011-08-02
  1. 27

    Seulement les pointeurs de données. void * peut contenir des données de pointeur, mais pas des pointeurs de fonction.

    Ici est un C FAQ.

    void *'s ne sont garantis qu'à tenir des objets (c'est à dire des données) pointeurs; il
    n'est pas portable pour convertir un pointeur de fonction de type void *. (Sur certains
    des machines, des adresses de fonction peut être très grande, plus grande que toutes les données
    les pointeurs.)

    Comme pour la première partie, oui, de différents types peuvent avoir les pointeurs de tailles différentes:

    • Cependant, la taille des pointeurs est rare, voire inexistante dans les systèmes modernes.
    • Et note "peut contenir", pas "est au moins aussi grande". Il n'y a rien dans la norme qui dit que, par exemple, double* pointeurs peuvent pas être inutilement grand et juste de ne pas utiliser certains de leurs morceaux. Vous pourriez avoir sizeof(double*) > sizeof(void*) même si un void* peut contenir toutes les valeurs de double*.
    • sans arguments m'ont convaincu pour l'instant (bien sûr std est la bible, mais il peut être mal conçu): il doit exister un "registre", capable de tenir le "plus" de "pointeur"; et j'attends "void *" à une "union" de tous les pointeurs possibles, de sorte qu'il peut signifier pour de vrai "pointeur à rien". Avant que je puisse l'utiliser, j'ai besoin de la lancer, et puis il doit acquérir une "forme particulière". Mais sizeof(void *) devrait donner la taille de la "plus grand" dans un, de pouvoir garder les pointeurs de fonction trop (quels qu'ils soient)
    • Un contre-exemple serait un système dans lequel les pointeurs ne sont pas très compact, par exemple classique x86: Vous avez besoin d'un 16+16 bits pointeur lorsque vous êtes à la déférence, mais ils ne contiennent que 20 bits d'information. Puisque vous n'avez jamais déréférencement de void*, qui n'a pas besoin d'être en 32 bits, mais pourrait être de 24 bits.
    • Dans ce contexte, il est intéressant de noter que POSIX viole de façon flagrante ce point de la norme C, en exigeant que void* peut en fait détenir une méthode de pointeur.
    • viole" dans le sens que non pas tous conformes C mise en œuvre est conforme Posix mise en œuvre. Ce qui n'est guère surprenant, étant donné que (pour commencer) Posix introduit de nouveaux en-têtes de bibliothèque.
    • viole” dans le sens qu'ils ont choisi d'exiger UB dans un cas (dlsym) où elles auraient pu s'en sortent bien défini C code. Et en fait, cette décision peut être réexaminée à l'avenir, selon la page de man.

    InformationsquelleAutor cnicutar
  2. 10

    La valeur stockée dans le pointeur est une adresse de mémoire. Si vous êtes sur un système 32 bits, ce pointeur dans la mémoire va être 32 bits (ou quatre octets) de long. Si vous êtes sur un système 64 bits, le pointeur dans la mémoire va être 64 bits (huit octets) de long.

    La taille des données que détient l'emplacement de la mémoire n'a rien à voir avec la taille des données représentées à l'emplacement de la mémoire.

    Quant à la façon d'un char * diffère d'un double *, le char * peut pointer vers n'importe quel endroit, mais le double * a à un point à quelque chose le long d'un huit-frontière d'octet. Plus de données doit être alignée selon les règles du processeur que vous êtes sur. Ainsi, les pointeurs de données de petite taille ne sont pas, en général, compatible avec les pointeurs de données de grande taille (par exemple, vous ne devriez pas point une double * pointeur vers un char * adresse); mais vous êtes enregistrer dans l'autre sens (par exemple, vous pouvez pointer une char * pointeur vers un double * adresse).

    • C'est une bonne pratique, mais il semble que la COOP est à la recherche pour l'une des normes pédant réponse.
    • Comme l'a dit Chris. Ce que vous exprimez ici, est ce que la pratique nous dit, mais aussi loin que la langue standard, tous les paris sont éteints. 😉
    • Les règles de la langue sont ce qu'ils sont pour autoriser implémentations sur des systèmes où la lutte n'est pas régulière. La langue concepteurs n'sur ce but.
    • +1 . Mais l'alignement n'est pas nécessaire sur toutes les machines possibles; cependant, il est très commun (c'est à dire c'est); par exemple, si je me souviens bien, 68020 pouvez accéder bizarre adresses lors de la lecture de mots (16)ou à long mot (32) de données, mais l'accès est plus lent (et donc, l'alignement des données feront de votre programme courir plus vite)
    • J'ai besoin d'exemple de systèmes où la lutte "n'est pas régulier" et la langue ne peut pas le cacher (la seule raison pour laquelle je ne peux accepter la norme rédacteurs ont écrit que, de cette façon, c'est que les cachant et en permettant à l' "intuitive" le fait que l'un pointeur est un pointeur n'importe quelle aurait été impossible ...)
    • Le cas le plus fréquent, c'est quand le "naturel", la taille du pointeur est un mot pointeur, et de l'octet les pointeurs doivent représenter un décalage supplémentaire au sein de ce mot. Quant à savoir pourquoi il ne s'en cache pas, ce n'est pas qu'il "ne peut pas", c'est parce que le C n'est pas dans les affaires de cacher des trucs comme ça.

    InformationsquelleAutor unpythonic