¿El tamaño de (algún puntero) siempre es igual a cuatro?

Por ejemplo: sizeof(char*) devuelve 4. Al igual que int* , long long* , todo lo que he intentado. ¿Hay alguna excepción a esto?

La garantía que obtienes es esa sizeof(char) == 1 . No hay otras garantías, incluida ninguna garantía de que sizeof(int *) == sizeof(double *) .

En la práctica, los punteros serán del tamaño 2 en un sistema de 16 bits (si puede encontrar uno), 4 en un sistema de 32 bits y 8 en un sistema de 64 bits, pero no se gana nada confiando en un determinado tamaño.

Incluso en una plataforma simple x86 de 32 bits, puede obtener una variedad de tamaños de puntero, pruebe esto como ejemplo:

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

Bajo Visual C ++ 2008, obtengo 4, 12 y 8 para los tamaños de la función de apuntadores a miembros.

Raymond Chen habló de esto aquí .

Solo otra excepción a la lista ya publicada. En plataformas de 32 bits, los punteros pueden tomar 6, no 4 , bytes:

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

Si comstack este progtwig con Open Watcom y lo ejecuta, obtendrá 6, porque los indicadores lejanos que admite consisten en valores de desplazamiento de 32 bits y de segmento de 16 bits

si está comstackndo para una máquina de 64 bits, entonces puede ser 8.

Técnicamente hablando, el estándar C solo garantiza que sizeof (char) == 1, y el rest depende de la implementación. Pero en las architectures modernas x86 (por ejemplo, chips Intel / AMD) es bastante predecible.

Probablemente haya escuchado procesadores descritos como de 16 bits, 32 bits, 64 bits, etc. Esto generalmente significa que el procesador usa N bits para enteros. Como los punteros almacenan direcciones de memoria y las direcciones de memoria son enteros, esto le indica de manera efectiva cuántos bits se van a usar para los punteros. sizeof generalmente se mide en bytes, por lo que el código comstackdo para procesadores de 32 bits informará que el tamaño de los punteros será 4 (32 bits / 8 bits por byte) y el código para los procesadores de 64 bits indicará que el tamaño de los punteros será 8 (64 bits / 8 bits por byte). Aquí es donde proviene la limitación de 4 GB de RAM para procesadores de 32 bits: si cada dirección de memoria corresponde a un byte, para direccionar más memoria necesita enteros mayores a 32 bits.

Además de las diferencias de 16/32/64 bits, pueden ocurrir cosas aún más extrañas.

Ha habido máquinas en las que sizeof (int *) tendrá un valor, probablemente 4, pero donde sizeof (char *) es más grande. Las máquinas que abordan palabras de forma natural en lugar de bytes tienen que “boost” los indicadores de caracteres para especificar qué parte de la palabra realmente desea para implementar correctamente el estándar C / C ++.

Esto es ahora muy inusual ya que los diseñadores de hardware han aprendido el valor de la direccionabilidad de bytes.

Los punteros de 8 bits y 16 bits se utilizan en la mayoría de los microcontroladores de bajo perfil. Eso significa que cada lavadora, micro, nevera, televisores antiguos, e incluso automóviles.

Se podría decir que no tienen nada que ver con la progtwigción del mundo real. Pero aquí hay un ejemplo del mundo real: Arduino con 1-2-4k ram (dependiendo del chip) con punteros de 2 bytes.

Es reciente, es barato, accesible para todos y vale la pena codificarlo.

El tamaño del puntero depende básicamente de la architecture del sistema en el que se implementa. Por ejemplo, el tamaño de un puntero en 32 bits es de 4 bytes (32 bits) y 8 bytes (64 bits) en máquinas de 64 bits. Los tipos de bits en una máquina no son más que direcciones de memoria, que puede tener. Las máquinas de 32 bits pueden tener un espacio de direcciones de 2^32 y las máquinas de 64 bits pueden tener hasta 2^64 espacios de direcciones. Por lo tanto, un puntero (variable que apunta a una ubicación de memoria) debería poder apuntar a cualquiera de las direcciones de memoria ( 2^32 for 32 bit and 2^64 for 64 bit ) que posee una máquina.

Por esta razón, vemos que el tamaño de un puntero es de 4 bytes en una máquina de 32 bits y de 8 bytes en una máquina de 64 bits.

Además de lo que la gente ha dicho sobre los sistemas de 64 bits (o lo que sea), existen otros tipos de puntero que de puntero a objeto.

Un puntero a miembro puede ser de cualquier tamaño, dependiendo de cómo el comstackdor los implemente: no son necesariamente del mismo tamaño. Pruebe un puntero-a-miembro de una clase POD, y luego un puntero-a-miembro heredado de una de las clases base de una clase con múltiples bases. Qué divertido.

Por lo que recuerdo, está basado en el tamaño de una dirección de memoria. Entonces, en un sistema con un esquema de direcciones de 32 bits, sizeof devolverá 4, ya que son 4 bytes.

En general, sizeof (casi cualquier cosa) cambiará cuando compiles en diferentes plataformas. En una plataforma de 32 bits, los punteros son siempre del mismo tamaño. En otras plataformas (64 bit siendo el ejemplo obvio) esto puede cambiar.

No, el tamaño de un puntero puede variar según la architecture. Hay numerosas excepciones.

El tamaño del puntero e int es de 2 bytes en el comstackdor Turbo C en la máquina de Windows de 32 bits.

Por lo tanto, el tamaño del puntero es específico del comstackdor. Pero, en general, la mayoría de los comstackdores se implementan para admitir una variable de puntero de 4 bytes en 32 bits y una variable de puntero de 8 bytes en una máquina de 64 bits).

Por lo tanto, el tamaño del puntero no es el mismo en todas las máquinas.

La razón por la cual el tamaño de su puntero es de 4 bytes se debe a que está comstackndo para una architecture de 32 bits. Como señaló FryGuy, en una architecture de 64 bits vería 8.

Un puntero es solo un contenedor para una dirección. En una máquina de 32 bits, su rango de direcciones es de 32 bits, por lo que un puntero siempre será de 4 bytes. En una máquina de 64 bits, si tiene un rango de direcciones de 64 bits, un puntero será de 8 bytes.

En Win64 (Cygwin GCC 5.4) , veamos el siguiente ejemplo:

Primero, prueba la siguiente estructura:

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

El código de prueba está abajo:

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

El resultado está abajo:

 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 

Puede ver que en 64 bits, sizeof(pointer) es 8 .

Solo por completitud e interés histórico, en el mundo de 64 bits había diferentes convenciones de plataforma en los tamaños de largo y largo tipo, llamados LLP64 y LP64, principalmente entre sistemas de tipo Unix y Windows. Un antiguo estándar llamado ILP64 también hizo int = ancho de 64 bits.

Microsoft mantuvo LLP64 donde longlong = 64 bit de ancho, pero permaneció por mucho tiempo en 32, para facilitar la transferencia.

 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 

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