La tailleof (un pointeur) est-elle toujours égale à quatre?

Par exemple: sizeof(char*) renvoie 4. Comme le fait int* , long long* , tout ce que j’ai essayé. Y a-t-il des exceptions à cela?

La garantie que vous obtenez est celle de sizeof(char) == 1 . Il n’y a pas d’autres garanties, y compris aucune garantie que sizeof(int *) == sizeof(double *) .

Dans la pratique, les pointeurs seront de taille 2 sur un système 16 bits (si vous en trouvez un), 4 sur un système 32 bits et 8 sur un système 64 bits, mais rien ne permet de s’appuyer sur un système donné. Taille.

Même sur une plate-forme x86 32 bits simple, vous pouvez obtenir différentes tailles de pointeurs, essayez ceci par exemple:

 struct A {}; struct B : virtual public A {}; struct C {}; struct D : public A, public C {}; int main() { cout < < "A:" << sizeof(void (A::*)()) << endl; cout << "B:" << sizeof(void (B::*)()) << endl; cout << "D:" << sizeof(void (D::*)()) << endl; } 

Sous Visual C ++ 2008, j'obtiens 4, 12 et 8 pour les tailles de la fonction de pointeur à membre.

Raymond Chen en a parlé ici .

Juste une autre exception à la liste déjà affichée. Sur les plates-formes 32 bits, les pointeurs peuvent prendre 6 et non 4 octets:

 #include  #include  int main() { char far* ptr; // note that this is a far pointer printf( "%d\n", sizeof( ptr)); return EXIT_SUCCESS; } 

Si vous comstackz ce programme avec Open Watcom et l’exécutez, vous obtiendrez 6, car les pointeurs distants qu’il prend en charge se composent de valeurs de décalage de 32 bits et de segments de 16 bits.

si vous comstackz pour une machine 64 bits, il peut être 8.

Du sharepoint vue technique, le standard C ne garantit que la taille de (char) == 1, et le rest dépend de l’implémentation. Mais sur les architectures x86 modernes (par exemple les puces Intel / AMD), il est assez prévisible.

Vous avez probablement entendu des processeurs décrits comme étant 16 bits, 32 bits, 64 bits, etc. Cela signifie généralement que le processeur utilise des N bits pour les entiers. Comme les pointeurs stockent les adresses mémoire et que les adresses mémoire sont des nombres entiers, cela vous indique effectivement combien de bits seront utilisés pour les pointeurs. sizeof est généralement mesuré en octets, donc le code compilé pour les processeurs 32 bits indiquera la taille des pointeurs à 4 (32 bits / 8 bits par octet) et le code pour les processeurs 64 bits indiquera la taille des pointeurs à 8 (64 bits / 8 bits par octet). C’est là que vient la limitation de 4 Go de RAM pour les processeurs 32 bits – si chaque adresse mémoire correspond à un octet, pour traiter plus de mémoire, vous avez besoin d’entiers supérieurs à 32 bits.

En plus des différences de 16/32/64 bits, des choses plus étranges peuvent se produire.

Il y a eu des machines où sizeof (int *) sera une valeur, probablement 4, mais où sizeof (char *) est plus grand. Les machines qui adressent naturellement des mots au lieu d’octets doivent “augmenter” les pointeurs de caractères pour spécifier quelle partie du mot vous voulez vraiment pour implémenter correctement le standard C / C ++.

Ceci est maintenant très inhabituel car les concepteurs de matériel ont appris la valeur de l’adressabilité des octets.

Les pointeurs 8 bits et 16 bits sont utilisés dans la plupart des microcontrôleurs à profil bas. Cela signifie que chaque machine à laver, micro, réfrigérateur, téléviseurs anciens, et même des voitures.

Vous pourriez dire que ceux-ci n’ont rien à voir avec la programmation du monde réel. Mais voici un exemple concret: Arduino avec 1-2-4k ram (selon la puce) avec des pointeurs à 2 octets.

C’est récent, bon marché, accessible à tous et mérite d’être codé.

La taille du pointeur dépend essentiellement de l’architecture du système dans lequel il est implémenté. Par exemple, la taille d’un pointeur sur 32 bits est de 4 octets (32 bits) et de 8 octets (64 bits) sur une machine 64 bits. Les types de bits dans une machine ne sont rien d’autre qu’une adresse mémoire, qu’elle peut avoir. Les machines 32 bits peuvent avoir un espace d’adressage 2^32 et les machines 64 bits peuvent avoir jusqu’à 2^64 espaces d’adressage. Ainsi, un pointeur (variable qui pointe vers un emplacement de mémoire) doit pouvoir indiquer une adresse mémoire quelconque ( 2^32 for 32 bit and 2^64 for 64 bit ) qu’une machine contient.

Pour cette raison, nous voyons que la taille d’un pointeur est de 4 octets dans une machine 32 bits et de 8 octets dans une machine 64 bits.

En plus de ce que les gens ont dit à propos des systèmes 64 bits (ou autres), il existe d’autres types de pointeurs que les pointeurs sur objects.

Un pointeur sur un membre peut avoir presque n’importe quelle taille, selon la manière dont il est implémenté par votre compilateur: ils ne sont pas nécessairement tous de la même taille. Essayez un pointeur sur un membre d’une classe POD, puis un pointeur sur un membre hérité d’une des classes de base d’une classe avec plusieurs bases. Ce que c’est drôle.

De ce que je me souviens, il est basé sur la taille d’une adresse mémoire. Ainsi, sur un système avec un schéma d’adresse de 32 bits, sizeof renverra 4, car il s’agit de 4 octets.

En général, sizeof (à peu près tout) va changer lorsque vous comstackz sur différentes plates-formes. Sur une plate-forme 32 bits, les pointeurs ont toujours la même taille. Sur d’autres plates-formes (64 bits étant l’exemple évident), cela peut changer.

Non, la taille d’un pointeur peut varier selon l’architecture. Il existe de nombreuses exceptions.

La taille du pointeur et de l’int est de 2 octets dans le compilateur Turbo C sur la machine Windows 32 bits.

La taille du pointeur est donc spécifique au compilateur. Mais généralement, la plupart des compilateurs sont implémentés pour prendre en charge une variable de pointeur de 4 octets dans une variable de pointeur de 32 bits et de 8 octets dans une machine de 64 bits.

La taille du pointeur n’est donc pas la même dans toutes les machines.

La raison pour laquelle la taille de votre pointeur est de 4 octets est que vous comstackz pour une architecture 32 bits. Comme FryGuy l’a souligné, sur une architecture 64 bits, vous verriez 8.

Un pointeur est juste un conteneur pour une adresse. Sur une machine 32 bits, votre plage d’adresses est de 32 bits, donc un pointeur sera toujours 4 octets. Sur une machine 64 bits, si vous avez une plage d’adresses de 64 bits, un pointeur sera de 8 octets.

Dans Win64 (Cygwin GCC 5.4) , voyons l’exemple ci-dessous:

Tout d’abord, testez la structure suivante:

 struct list_node{ int a; list_node* prev; list_node* next; }; struct test_struc{ char a, b; }; 

Le code de test est le suivant:

 std::cout< <"sizeof(int): "< 

La sortie est ci-dessous:

 sizeof(int): 4 sizeof(int*): 8 sizeof(double): 8 sizeof(double*): 8 sizeof(list_node): 24 sizeof(list_node*): 8 sizeof(test_struc): 2 sizeof(test_struc*): 8 

Vous pouvez voir que dans 64-bit, sizeof(pointer) est 8 .

Pour des raisons d’exhaustivité et d’intérêt historique, dans le monde 64 bits, il existait différentes conventions de plate-forme sur les tailles des types long et long nommés LLP64 et LP64, principalement entre les systèmes de type Unix et Windows. Une ancienne norme nommée ILP64 faisait également un int = 64 bits.

Microsoft a maintenu LLP64 où longlong = 64 bits de large, mais est resté longtemps à 32, pour faciliter le portage.

 Type ILP64 LP64 LLP64 char 8 8 8 short 16 16 16 int 64 32 32 long 64 64 32 long long 64 64 64 pointer 64 64 64 

Source: https://stackoverflow.com/a/384672/48026