Size of references in 64bit environments

Question

Came across this one while browsing the response to another question on SO (References Vs Variable Gets). My question is that for all 64bit environments is it guaranteed that a reference to a variable will be of 64 bits even if the original had a lesser size? As in char references in 64bit environment would be >sizeof(char)? Is there any section in the standard which specifies this explicitly?

EDIT: For more clarity -- char c1 = 'a'; char& c2 = c1; My question is sizeof(c2) > sizeof(c1) in 64bit machines?

Answer 1

Yes. All references are the size of the architecture's width; on a 64-bit system, everything from char to long double references are 64 bits long.

Answer 2

Internally, references are just pointers. Pointers take up 32 bits on a 32-bit system, 64 bits on a 64-bit system, etc. You can get the size of a pointer by doing sizeof(char*).

All pointers are the same size no matter what they are pointing to; for instance, a char* is the same size as long*. So all pointers on 64-bit systems take up 64 bits.

Answer 3

The Standard (ISO C++-03) says the following thing about references

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

Please someone correct me if I am wrong or if I have not understood his question correctly.

EDIT:

My question is sizeof(c2) > sizeof(c1) in 64bit machines?

No, as @Chubsdad noticed sizeof(c2) = sizeof (c1), the relevant quote from the Standard is

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 4

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

sizeof applied to references is basically the size of the referrand.

So if 'r' is a integer reference to 'i', it is unspecified if there is an actual storage for 'r'. However sizeof(r) internally stands for sizeof(i).

If 'r' is a reference to a 'char', the sizeof(r) will be always sizeof(char) == 1 by definition.

Answer 5

Although sizeof(ref_var) returns the size of the referenced object, space is still required to store a reference in a structure, for instance, and in common implementations the space allocated to store a reference is the same as the space allocated to store a pointer. That may not be required by the standard, but this code at least shows the effect:

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

I make no pretense that it is 'great code' - it isn't - but it demonstrates a point. Compiled on MacOS X 10.6.4 with the C++ compiler from the GNU Compiler Collection (GCC 4.5.1) in default (64-bit) mode, the output is:

1
16
24

When compiled in 32-bit mode, the output is:

1
16
20

The first line of output demonstrates that 'sizeof(ref_var)' does indeed return the size of the referenced object. The second line shows that a structure with no reference in it has a size of 16 bytes. The third line shows that a very similar structure with a reference embedded in it at an 8-byte boundary (on a system where sizeof(int) == 4) is 8 bytes larger than the simpler structure under a 64-bit compilation and 4 bytes larger under a 32-bit compilation. By inference, the reference part of the structure occupies more than 4 bytes and not more than 8 bytes under the 64-bit compilation, and occupies not more than 4 bytes under the 32-bit compilation. This suggests that (in at least one popular implementation of C++) that a reference in a structure occupies the same amount of space as a pointer - as asserted in some of the other answers.

So, it may be implementation dependent, but the comment that a reference occupies the same space as a pointer holds true in at least one (rather widely used) implementation.