La sizeof (qualche puntatore) è sempre uguale a quattro?

Ad esempio: sizeof(char*) restituisce 4. Come int* , long long* , tutto ciò che ho provato. Ci sono delle eccezioni a questo?

La garanzia che ottieni è sizeof(char) == 1 . Non ci sono altre garanzie, inclusa la garanzia che sizeof(int *) == sizeof(double *) .

In pratica, i puntatori saranno di dimensione 2 su un sistema a 16 bit (se ne trovi uno), 4 su un sistema a 32 bit e 8 su un sistema a 64 bit, ma non c’è nulla da guadagnare nel fare affidamento su un dato dimensione.

Anche su una semplice piattaforma x86 a 32 bit, puoi ottenere una varietà di dimensioni puntatore, provalo per un esempio:

 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; } 

In Visual c ++ 2008, ottengo 4, 12 e 8 per le dimensioni della funzione puntatori-membro.

Raymond Chen ne ha parlato qui .

Solo un’altra eccezione alla lista già pubblicata. Sulle piattaforms a 32 bit, i puntatori possono prendere 6, non 4 , byte:

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

Se compilate questo programma con Open Watcom ed eseguitelo, otterrete 6, perché i puntatori lontani che supporta consistono in offset a 32 bit e valori di segmento a 16 bit

se si sta compilando per una macchina a 64 bit, allora potrebbe essere 8.

Tecnicamente parlando, lo standard C garantisce solo sizeof (char) == 1, e il resto dipende dall’implementazione. Ma su architetture x86 moderne (ad es. Chip Intel / AMD) è abbastanza prevedibile.

Probabilmente hai sentito processori descritti come 16-bit, 32-bit, 64-bit, ecc. Questo di solito significa che il processore usa N-bit per i numeri interi. Poiché i puntatori memorizzano gli indirizzi di memoria e gli indirizzi di memoria sono interi, ciò indica in modo efficace quanti bit saranno utilizzati per i puntatori. sizeof viene in genere misurato in byte, quindi il codice compilato per processori a 32 bit riporterà la dimensione dei puntatori a 4 (32 bit / 8 bit per byte) e il codice per i processori a 64 bit riporterà la dimensione dei puntatori a 8 (64 bit / 8 bit per byte). È qui che arriva la limitazione di 4 GB di RAM per i processori a 32 bit: se ogni indirizzo di memoria corrisponde a un byte, per indirizzare più memoria sono necessari numeri interi maggiori di 32 bit.

Oltre alle differenze di 16/32/64 bit possono verificarsi anche cose più strane.

Ci sono state macchine in cui sizeof (int *) sarà un valore, probabilmente 4 ma dove sizeof (char *) è più grande. Le macchine che indirizzano naturalmente le parole anziché i byte devono “aumentare” i puntatori di caratteri per specificare quale parte della parola si desidera realmente per implementare correttamente lo standard C / C ++.

Questo è ora molto inusuale in quanto i progettisti di hardware hanno imparato il valore dell’affidabilità dei byte.

I puntatori a 8 e 16 bit sono utilizzati nella maggior parte dei microcontrollori a basso profilo. Ciò significa che ogni lavatrice, micro, frigorifero, vecchi televisori e persino automobili.

Si potrebbe dire che questi non hanno nulla a che fare con la programmazione del mondo reale. Ma ecco un esempio del mondo reale: Arduino con 1-2-4k ram (a seconda del chip) con 2 byte puntatori.

È recente, economico, accessibile a tutti e per cui vale la pena scrivere.

La dimensione del puntatore dipende fondamentalmente dall’architettura del sistema in cui è implementata. Ad esempio, la dimensione di un puntatore a 32 bit è 4 byte (32 bit) e 8 byte (64 bit) in macchine a 64 bit. I tipi di bit in una macchina non sono altro che l’indirizzo di memoria, che può avere. Le macchine a 32 bit possono avere uno spazio di indirizzamento 2^32 e le macchine a 64 bit possono avere fino a 2^64 spazi di indirizzamento. Quindi un puntatore (variabile che punta a una posizione di memoria) dovrebbe essere in grado di puntare a qualsiasi indirizzo di memoria ( 2^32 for 32 bit and 2^64 for 64 bit ) che una macchina tiene.

Per questo motivo vediamo la dimensione di un puntatore di 4 byte in una macchina a 32 bit e 8 byte in una macchina a 64 bit.

Oltre a ciò che le persone hanno detto a proposito dei sistemi a 64 bit (o qualsiasi altra cosa), esistono altri tipi di puntatori rispetto al puntatore all’object.

Un puntatore a membro potrebbe avere quasi tutte le dimensioni, a seconda di come sono implementate dal compilatore: non sono necessariamente anche tutte della stessa dimensione. Prova un puntatore a membro di una class POD e quindi un puntatore a membro ereditato da una delle classi base di una class con basi multiple. Che divertimento.

Da quello che ricordo, si basa sulla dimensione di un indirizzo di memoria. Quindi, su un sistema con uno schema di indirizzi a 32 bit, sizeof restituirà 4, poiché è 4 byte.

In generale, sizeof (praticamente qualsiasi cosa) cambierà quando compilerai su piattaforms diverse. Su una piattaforma a 32 bit, i puntatori hanno sempre le stesse dimensioni. Su altre piattaforms (64 bit è l’esempio ovvio) questo può cambiare.

No, la dimensione di un puntatore può variare a seconda dell’architettura. Ci sono numerose eccezioni.

La dimensione del puntatore e dell’int è 2 byte nel compilatore Turbo C sulla macchina Windows a 32 bit.

Quindi la dimensione del puntatore è specifica del compilatore. Ma generalmente la maggior parte dei compilatori è implementata per supportare una variabile puntatore a 4 byte nella variabile puntatore a 32 bit e 8 byte nella macchina a 64 bit).

Quindi la dimensione del puntatore non è la stessa in tutte le macchine.

Il motivo per cui la dimensione del puntatore è 4 byte è perché si sta compilando per un’architettura a 32 bit. Come ha sottolineato FryGuy, su un’architettura a 64 bit vedresti 8.

Un puntatore è solo un contenitore per un indirizzo. Su una macchina a 32 bit, l’intervallo di indirizzi è 32 bit, quindi un puntatore sarà sempre 4 byte. Su una macchina a 64 bit si dispone di un intervallo di indirizzi di 64 bit, un puntatore sarà 8 byte.

In Win64 (Cygwin GCC 5.4) , vediamo l’esempio seguente:

Innanzitutto, prova la seguente struttura:

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

Il codice di prova è qui sotto:

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

L'output è sotto:

 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 

Puoi vedere che a 64-bit, sizeof(pointer) è 8 .

Solo per completezza e interesse storico, nel mondo a 64 bit c’erano diverse convenzioni di piattaforma sulle dimensioni dei tipi lunghi e lunghi, denominati LLP64 e LP64, principalmente tra sistemi di tipo Unix e Windows. Anche un vecchio standard denominato ILP64 ha reso int = 64-bit wide.

Microsoft ha mantenuto LLP64 in cui longlong = 64 bit di larghezza, ma a lungo rimaneva a 32, per semplificare il porting.

 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 

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