Tamaño de las referencias en entornos de 64 bits

Question

Se encontró con este mientras examinaba la respuesta a otra pregunta en SO (References Vs Variable Gets). Mi pregunta es que para todos los entornos de 64 bits ¿se garantiza que una referencia a una variable será de 64 bits, incluso si el original tenía un tamaño menor? Como en las referencias de char en el entorno de 64 bits sería> sizeof (char)? ¿Hay alguna sección en el estándar que especifique esto explícitamente?

EDITAR: Para mayor claridad - char c1 = 'a'; char & c2 = c1; Mi pregunta es sizeof (c2)> sizeof (c1) en máquinas de 64 bits?

Answer 1

El estándar (ISO C++ - 03) dice lo siguiente acerca de las referencias

It is unspecified whether or not a reference requires storage (3.7).

Por favor que alguien me corrija si estoy equivocado o si no he entendido su pregunta correctamente.

EDITAR:

Mi pregunta es sizeof (c2)> sizeof (c1) en máquinas de 64 bits?

No, ya que se dio cuenta @Chubsdadsizeof(c2) = sizeof (c1), la cita relevante de la norma es

When applied to a reference or a reference type, the result is the size of the referenced type. (ISO C++ $ 5.3.3/2)

Answer 2

$ 8.3.2/3 - It is unspecified whether or not a reference requires storage.

sizeof aplicado a las referencias es básicamente el tamaño de la referrand.

Así que si 'r' es una referencia entera a 'i', no se especifica si hay un almacenamiento real para 'r'. Sin embargo, sizeof(r) significa internamente sizeof(i).

Si 'r' es una referencia a un 'char', el sizeof(r) siempre será sizeof(char) == 1 por definición.

Answer 3

Aunque sizeof(ref_var) devuelve el tamaño del objeto al que se hace referencia, todavía se necesita espacio para almacenar una referencia en una estructura, y en implementaciones comunes el espacio asignado para almacenar una referencia es el mismo que el espacio asignado para almacenar una puntero. Eso no puede ser requerido por la norma, pero este código, al menos, muestra el efecto:

#include <iostream> 
using namespace std; 

char c1 = 'a'; 
char &c2 = c1; 
struct x 
{ 
    char c1; 
    char c2; 
    char c3; 
    char c4; 
    int i4a; 
    char &r1; 
    int i4b; 
    int i4c; 
    x() : r1(c1) { } 
}; 
struct y 
{ 
    char c1; 
    char c2; 
    char c3; 
    char c4; 
    int i4a; 
    int i4b; 
    int i4c; 
}; 
int main() 
{ 
    cout << sizeof(c2) << endl; 
    cout << sizeof(y) << endl; 
    cout << sizeof(x) << endl; 
    return 0; 
} 

No pretendo que es 'gran código' - no es - pero demuestra un punto. Compilado en el modo (64-bit) MacOS X 10.6.4 con compilador el C++ de la colección de compiladores de GNU (GCC 4.5.1) en forma predeterminada, la salida es:

1 
16 
24 

Cuando se compila en el modo de 32 bits, la salida es:

1 
16 
20 

la primera línea de la salida demuestra que 'sizeof(ref_var)' en efecto, devolver el tamaño del objeto referenciado. La segunda línea muestra que una estructura sin referencia tiene un tamaño de 16 bytes.La tercera línea muestra que una estructura muy similar con una referencia incrustada en un límite de 8 bytes (en un sistema donde sizeof(int) == 4) es 8 bytes más grande que la estructura más simple en una compilación de 64 bits y 4 bytes más grande en un 32- compilación de bits. Por deducción, la parte de referencia de la estructura ocupa más de 4 bytes y no más de 8 bytes en la compilación de 64 bits, y ocupa no más de 4 bytes en la compilación de 32 bits. Esto sugiere que (en al menos una implementación popular de C++) que una referencia en una estructura ocupa la misma cantidad de espacio que un puntero, como se afirma en algunas de las otras respuestas.

Por lo tanto, puede depender de la implementación, pero el comentario de que una referencia ocupa el mismo espacio que un puntero es válido en al menos una implementación (bastante utilizada).