Est la sizeof(certains pointeur) toujours égal à quatre?

Par exemple:
sizeof(char*) renvoie 4. Comme int*, long long*, tout ce que j'ai essayé. Existe-il des exceptions?

  • Pourquoi cette marque vers le bas? Bonne question pour les débutants.
  • Je soupçonne qu'une autre question se cache dans celui-ci: "qu'est-Ce que sizeof?" ou peut être "Pourquoi est-sizeof <un pointeur> == 4? Quel est si spécial à propos de 4?". Suis-je le droit?
  • Eh bien, cela dépend de votre plate-forme. La plupart des implémentations de partager une même taille pour chaque type de pointeur sur une plate-forme spécifique.
InformationsquelleAutor Joel | 2008-12-29
  1. 180

    La garantie que vous obtenez est que 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 16 bits (si vous pouvez en trouver un), 4 sur un système 32 bits, et 8 sur un système 64 bits, mais il n'y a rien à gagner en s'appuyant sur une taille donnée.

    • Et 3 octets sur 24 bits. Oui, j'ai travaillé sur un. Bienvenue dans le monde des périphériques intégrés.
    • J'ai travaillé sur les systèmes 16 bits 20 bits pointeurs ainsi. Je devrais aller voir ce que sizeof renvoie dans ce cas...
    • IIRC, le 8086 était comme ça. Il y avait une 16 bits de l'adresse et de 4 bits registre de segment. Je crois normale "PRÈS de" pointeur était de 16 bits et un pointeur déclaré en tant que "MESURE" était plus, probablement 24, même si je ne suis pas sûr.
    • J'ai travaillé sur une (32 bits) système où le 'char *' pour quelque chose était différent de bits de la représentation de la " anthing_else *' pour le même emplacement de mémoire. Vous avez appris à faire en sorte que "malloc ()" a été déclaré (parce que dans ces jours d'antan, malloc() a retourné 'char *' et pas de 'void *'). Méfiez-vous!
    • (suite): La taille des pointeurs est la même dans tous les cas, c'était juste le modèle de bits qui diffèrent. Je n'ai pas vu les systèmes où les pointeurs à différents types de données ont des tailles différentes. J'ai vu des systèmes où le code (fonction) les pointeurs sont de tailles différentes à partir de pointeurs de données.
    • Dans certains modèles de mémoire, un pointeur sur un 8086 était de 32 bits. Un segment de 16 bits et un décalage de 16 bits. Le processeur serait de combiner ces en déplaçant le segment de 4 bits vers la gauche et en ajoutant le décalage, résultant en une adresse de 20 bits. Deux pointeurs différents peuvent pointer vers la même adresse physique! amusant!
    • 16 bits des systèmes sont faciles à trouver. Tout code qui s'exécute dans la barre de mode sur un BRAS de la puce.
    • Désolé, @ApplePieIsGood: BRAS de POUCE de code est toujours le code 32 bits. C'est juste une technique pour compresser la taille de l'instruction de 32 bits à 16 bits, mais l'espace d'adressage est toujours le même.
    • une autre garantie est que sizeof(char*) == sizeof(void*) , car ils ont le même representationss (object [taille] et la valeur [set de bits pertinents pour leur valeur] de la représentation)
    • Ferruccio: Il est pas vieux. Mon Core 2 Quad, processeur supporte également le mode réel ;-P
    • Bien sûr, si vous avez un pointeur vers une fonction membre d'une classe qui utilise plusieurs ou de l'héritage virtuel, alors vous aurez probablement complètement différent pointeur de tailles.
    • itanium utilise parfois 2word (2 pointeurs) pour représenter 1 pointeur de fonction.
    • Il existe d'autres garanties telles que sizeof(int) <= sizeof(long). Ils peuvent être les mêmes ou long pourrait être considérablement plus grande que int, mais ce ne sera jamais plus petit.
    • sonne comme la 16-bits de Monde Réel
    • Depuis que la question demande exceptions, il convient de noter que la non-membre statique des pointeurs de fonction sont souvent d'une taille différente de la normale pointeurs et varient aussi selon la plate-forme, type, etc. Autres que que +1.
    • 8 et 16 bits est partout. Lave-mashines, des réfrigérateurs, des micros, des contrôleurs à distance, les clés de la voiture.
    • Arduino est de 16 bits. Et oui, il utilise 2 octets pointeurs.
    • Il y a aussi la garantie que tous les pointeurs vers les structures ont la même taille et la mise en page, et tous les pointeurs vers les syndicats ont la même taille et de la représentation. Et des pointeurs vers signé/non signé quantités. Et des pointeurs vers la plaine/const/volatils objets.
    • Je sais il y a des garanties sur casting pointeurs, mais où est-il une garantie sur la taille et la représentation?
    • d'où vient le standard dit que sizeof(char*) == sizeof(void*) ?
    • Confiant C ne précise pas sizeof(char*) == sizeof(void*). Hâte de savoir vos pensées sur cela.
    • Je pense que c'est bon à savoir ce qui décide de la taille du pointeur.
    • Ça veut dire que, quel que soit le type de données, l'adresse est l'adresse et c'est ce que le pointeur de magasins, pour cette raison, il doit être de la même taille?
    • Donc, ce qu'il a dit?

    InformationsquelleAutor David Thornley
  2. 36

    Même sur une plaine x86 32 bits plate-forme, vous pouvez obtenir une variété de pointeur de tailles, essayez ceci pour un 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, je reçois 4, 12 et 8 pour la taille des pointeurs-à-membres de la fonction.

    Raymond Chen a parlé de ce ici.

    • Des pointeurs vers des fonctions de membre sont une vraie douleur. Il est regrettable que pas tous les compilateurs aime-t-il le Numérique Mars compilateur C++, qui de retour de 4 dans tous les cas.
    • gcc 4.72 imprimer toutes les 8 ... Est-ce pas défini dans la norme c++?
    • La seule chose qui est défini est que le char est 1. D'autres types peuvent être n'importe quelle taille est important pour le compilateur. Il n'y a aucune exigence de cohérence entre ces types de pointeur.
    • ok merci. Alors pas étonnant que gcc & VC ont différentes de mise en œuvre .
    • oui, il y a: char <= court <= int <= long <= long
    • assez vrai.

    InformationsquelleAutor Eclipse
  3. 29

    Juste une autre exception à la déjà posté la liste. Sur les plates-formes 32 bits, les pointeurs peut prendre 6, pas 4, octets:

    #include <stdio.h>
#include <stdlib.h>

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

    Si vous compilez ce programme avec l'Open Watcom et l'exécuter, vous aurez 6, parce que loin des pointeurs qu'il prend en charge se composent de 32 bits décalage de 16 bits et le segment de valeurs

    • Bon exemple! +1
    • Pas de segment, mais sélecteur plutôt elle n'est pas une partie de l'adresse de la mémoire, mais une entrée d'index dans la LDT ou GDT et a accès drapeaux
    • Bien sûr far est non-standard.
    • Pourquoi il y a des segments et des décalages en x86, tandis que l'adresse de l'espace est plat?
    • Car il permet d'économiser de l'espace pour le cas très commun de près de pointeurs, qui peuvent être encodés plus courte.
    • cela signifie que les segments sont utilisés pour l'extension de l'espace d'adresse comme PAE?
    • Cela fait un bout de temps que j'ai fait de l'assemblée sur quoi que ce soit 32 bits. La partie il me semble me rappeler, c'est que vous pouvez économiser de l'espace pour les pointeurs pointant à proximité de le code que vous avez. Aussi, pas tous les architectures 32 bit – certainement pas, tous basés sur x86 – l'utilisation d'un modèle de mémoire fixe. Voir, par exemple, tenouk.com/Bufferoverflowc/Bufferoverflow1a.html pour un peu plus de discussion autour de ce point, bien que, comme je l'ai dit, ça fait un moment et je ne peut pas garantir quoi que ce soit.
    • Vĩnh Phúc L'architecture segmentée introduite avec le 8088 et 8086 a été fondée sur l'hypothèse que la mémoire que les prix étaient élevés, de sorte que les coûts pourraient être sauvés en gardant tout dans des segments de 64 ko. Il a été l'un des principaux maux de tête à ceux d'entre nous de programmation de bas niveau de code dans cet environnement. Il est rarement utilisé, mais il est encore présent dans de CPU intel pour les masochistes d'entre nous.

    InformationsquelleAutor dmityugov
  4. 24

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

    • Tout cela est généralement le cas, il n'est pas nécessairement vrai. Par exemple, si vous êtes à la compilation sur une machine 64 bits, où la taille de mot est en 64 bits, sizeof(char*) sera probablement 1. Pour ne pas mentionner le plus exotique de type pointeur dans la même commune, des machines, comme Eclipse et dmityugov écrire.
    • Êtes-vous sûr? Ne pas vous dire size(char)==1?
    • Je n'ai en effet sizeof(char*). sizeof(char) est toujours de 1. Mais si votre machine le mot est en 64 bits, et de votre environnement de développement est mis en œuvre de telle manière que CHAR_BITS=64, il est possible qu'un pointeur s'inscrit dans le même espace comme un char et sera donc également être 1.
    • ce n'est pas vrai dans x32-abi sites.google.com/site/x32abi
    • Juste curieux, @KazDragon pouvez-vous donner un exemple d'une machine où CHAR_BITS=64?
    • Non, mais je pourrais construire un si j'ai choisi.

    InformationsquelleAutor FryGuy
  5. 17

    Techniquement parlant, la norme ne garantit que sizeof(char) == 1, et le reste est à la mise en œuvre. Mais sur le moderne, les architectures x86 (par exemple Intel/AMD, puces), il est assez prévisible.

    Vous avez probablement entendu parler des processeurs décrit comme étant de 16 bits, 32 bits, 64 bits, etc. Généralement, cela signifie que le processeur utilise N-bits pour les entiers. Puisque les pointeurs de stocker en mémoire les adresses et les adresses mémoire sont des nombres entiers, effectivement cela vous indique combien de bits sont utilisés pour les pointeurs. sizeof est généralement mesurée en octets, de sorte que le code compilé pour les processeurs 32 bits rendra compte de la taille des pointeurs à 4 (32 bits /8 bits par octet), et le code pour les processeurs 64 bits, fera rapport à la taille des pointeurs à 8 (64 bits /8 bits par octet). C'est là que la limitation de 4 GO de RAM pour les processeurs 32 bits proviennent -- si chaque adresse mémoire correspond à un octet, d'adresser plus de mémoire vous avez besoin des entiers de plus de 32-bits.

    • "Vous avez probablement entendu parler des processeurs décrit comme étant de 16 bits, 32 bits, 64 bits, etc. Généralement, cela signifie que le processeur utilise N-bits pour les entiers." -> je vais avoir une machine 64 bits, mais la sizeof(int) est de 4 octets. Si votre affirmation est vraie, comment cela pourrait-il être possible?!
    • Pour la compatibilité ascendante avec les versions 32 bits de code, ils ont décidé de s'int continuer à être de 4 octets et vous demandent de vous inscrire à l'aide du 8 octets type spécifiant "long". long est en fait le natif de la taille de mot sur x86-64. Une façon de voir c'est que généralement les compilateurs pad de vos structures pour les rendre mot aligné (même si il peut y avoir des architectures où la taille de mot et un alignement non relié), donc si vous faites une structure avec un int (32 bits), et appel sizeof() sur celui-ci, si vous obtenez de retour 8 vous savez que c'est de rembourrage pour 64-bit taille de mot.
    • Notez que, théoriquement, le natif de word taille de l'UC et de ce que le compilateur décide de 'int' est peut être arbitrairement différents, c'est juste qu'il a été la convention de 'int' être le natif de la taille de mot avant de x86-64 est venu autour, où il est long à la facilité en arrière compat.
    • Merci pour l'explication! 🙂
    InformationsquelleAutor Joseph Garvin
  6. 6

    En plus de la 16/32/64 peu de différences, même étrangeté des choses peuvent se produire.

    Il y a eu des machines où sizeof(int *) sera une valeur, probablement 4 mais où sizeof(char *) est plus grande. Les Machines qui naturellement adresse des mots au lieu de les octets à "augmenter" pointeurs de caractère pour spécifier quelle partie du mot que vous voulez vraiment dans le but de mettre en œuvre correctement le C/C++ standard.

    C'est maintenant très rare que les concepteurs de matériel ont appris la valeur de l'octet de l'adressabilité.

    • Le compilateur C pour Cray machines à vecteurs, tels que le T90, faire quelque chose de similaire. Matériel adresses sont de 8 octets, et le point 8 octets mots. void* et char* sont traitées dans le logiciel, et sont complétées avec un décalage 3 bits dans le mot, mais depuis il n'y a pas en fait d'une version 64 bits de l'adresse de l'espace, le décalage est stocké dans les 3 bits de la version 64 bits du mot. Donc char* et int* sont de la même taille, mais ils ont d'autres représentations internes -- et le code qui suppose que les pointeurs sont "vraiment" juste les nombres entiers peuvent échouer mal.
    InformationsquelleAutor Darron
  7. 6

    La taille du pointeur dépend fondamentalement de l'architecture du système dans lequel il est mis en œuvre. Par exemple, la taille d'un pointeur de 32 bits soit 4 octets (32 bits ) et de 8 octets(64 bits ) en 64 bits machines. Le peu de types dans une machine ne sont rien, mais l'adresse de mémoire, qu'il peut avoir. 32 bits machines peuvent avoir 2^32 espace d'adressage et 64 bits des machines peut avoir jusqu'à 2^64 espaces d'adressage. Donc un pointeur (variable qui pointe vers un emplacement de la mémoire) devrait être en mesure de tout de l'adresse mémoire ( 2^32 for 32 bit and 2^64 for 64 bit ), que des machines détient.

    À cause de cette raison, nous voyons la taille d'un pointeur de 4 octets ordinateur 32 bits et 8 octets dans un ordinateur 64 bits.

    InformationsquelleAutor Rndp13
  8. 5

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

    On peut dire qu'ils n'ont rien à voir avec le monde réel de la programmation.
    Mais en voici un exemple réel:
    Arduino avec 1-2-4k de ram (selon chip) avec 2 octets pointeurs.

    C'est récent, bon marché, accessible pour tout le monde et les valeurs de codage pour.

    InformationsquelleAutor Kobor42
  9. 4

    En plus de ce que les gens ont dit à propos de 64 bits (ou autre) des systèmes, il existe d'autres types de pointeur de pointeur vers l'objet.

    Un pointeur vers membre pourrait être presque n'importe quelle taille, selon la façon dont ils sont mis en œuvre par votre compilateur: ils ne sont même pas nécessairement tous de la même taille. Essayez un pointeur vers membre d'une GOUSSE de classe, et puis un pointeur vers membre hérité de l'une des classes de base d'une classe avec plusieurs bases. Quel plaisir.

    InformationsquelleAutor Steve Jessop
  10. 3

    De ce que je me souviens, il est basé sur la taille d'une adresse de mémoire. Ainsi, sur un système avec une adresse 32 bits régime, sizeof sera de retour le 4, car c'est 4 octets.

    • Il n'y a pas une telle exigence. Il n'est même pas une exigence que sizeof(unsigned int) == sizeof(signé int). De la taille d'un pointeur vers un int sera toujours, par définition, sizeof(int *), pour un char sizeof(char *) etc. En s'appuyant sur toute autre hypothèse, c'est une mauvaise idée pour la portabilité.
    • Ah, je vois maintenant. Merci pour l'info.
    • Pourrait toujours retourner 2, si CHAR_BIT est de 16 ans. sizeof() compte le nombre de caractères, pas des octets.
    • En C++ sizeof (unsigned int) == sizeof (signed int), cette exigence est trouvé dans 3.9.1/3. "Pour chacun de la norme entier signé types, il existe un correspondant (mais différentes) standard type entier non signé: unsigned char, unsigned short int, unsigned int, unsigned long int, et unsigned long long int, dont chacun occupe la même quantité de stockage et a le même alignement exigences correspondantes entier signé de type"
    InformationsquelleAutor Will Mc
  11. 3

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

    InformationsquelleAutor Sean Reilly
  12. 3

    Non, de la taille d'un pointeur peut varier en fonction de l'architecture. Il existe de nombreuses exceptions.

    InformationsquelleAutor Judge Maygarden
  13. 3

    Taille du pointeur et l'int est de 2 octets Turbo C compilateur sous windows 32 bits de la machine.

    Donc taille du pointeur est compilateur spécifique. Mais en général, la plupart des compilateurs sont mis en œuvre à l'appui de pointeur de 4 octets variable en 32 bits et 8 octets pointeur de variable en machine 64 bit).

    Donc taille du pointeur n'est pas la même dans toutes les machines.

    InformationsquelleAutor finalsemester.co.in
  14. 2

    Dans Win64 (Cygwin GCC 5.4), nous allons voir l'exemple ci-dessous:

    D'abord, tester 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 ci-dessous:

    std::cout<<"sizeof(int):            "<<sizeof(int)<<std::endl;
std::cout<<"sizeof(int*):           "<<sizeof(int*)<<std::endl;
std::cout<<std::endl;

std::cout<<"sizeof(double):         "<<sizeof(double)<<std::endl;
std::cout<<"sizeof(double*):        "<<sizeof(double*)<<std::endl;
std::cout<<std::endl;

std::cout<<"sizeof(list_node):      "<<sizeof(list_node)<<std::endl;
std::cout<<"sizeof(list_node*):     "<<sizeof(list_node*)<<std::endl;
std::cout<<std::endl;

std::cout<<"sizeof(test_struc):     "<<sizeof(test_struc)<<std::endl;
std::cout<<"sizeof(test_struc*):    "<<sizeof(test_struc*)<<std::endl;

    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 qu'en 64 bits, sizeof(pointer) est 8.

    InformationsquelleAutor Jayhello
  15. 1

    La raison de la taille de votre pointeur est de 4 octets est parce que vous êtes compilation pour une architecture 32 bits. Comme FryGuy souligné, sur une architecture 64 bits, vous verriez 8.

    InformationsquelleAutor Will Bickford
  16. 1

    Un pointeur est un conteneur pour une adresse. Sur un ordinateur 32 bits, votre plage d'adresses de 32 bits, donc un pointeur sera toujours 4 octets. Sur un ordinateur 64 bits ont été vous avez une adresse de gamme de 64 bits, un pointeur sera de 8 octets.

    • Sur une machine 32 bits 32 bits, octets, sizeof(char *) peut être de 1.
    • "...avec 32 bits octets". Je ne sais pas si ça existait...de fantaisie que.
    • Sur un 32 bits de canard, sizeof(char *) renvoie PI
    InformationsquelleAutor Ed S.
  17. 0

    Juste pour l'exhaustivité et l'intérêt historique, dans le 64bit monde, il y avait différentes plate-forme de conventions sur les tailles de long et long long types, nommé LLP64 et LP64, principalement entre les systèmes de type Unix et Windows. Un vieux standard nommé ILP64 également fait int = 64 bits de large.

    Microsoft maintenu LLP64 où longlong = 64 bits de large, mais longtemps resté à 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

    InformationsquelleAutor Hernán