Question

Considering :

double data; 
double array[10]; 
std::vector<int> vec(4, 100); 
MyClass myclass;   

Is there a difference between :

sizeof(double);
sizeof(double[10]);
sizeof(std::vector<int>);
sizeof(MyClass);

and

sizeof(data);
sizeof(array);
sizeof(vec);
sizeof(myclass);

Are the two syntaxes different or strictly equivalent ? Are all of them evaluated at compile-time ? If not, which one is evaluated at run-time ?

Answer 1

The only differences are in syntax and convenience.

Syntactically, you’re allowed to leave out the parentheses in one case, but not the other:

double d;

sizeof(double); // compiles
sizeof(d);      // compiles
sizeof d;       // compiles
sizeof double;  // does NOT compile

As far as convenience goes, consider something like:

float a;

x = sizeof(float);

y = sizeof(a);

If, for example, you sometime end up changing a from a float to a double, you’d also need to change sizeof(float) to sizeof(double) to match. If you use sizeof(a) throughout, when you change a from a float to a double, all your uses of sizeof will automatically change too, without any editing. The latter is more often a problem in C than C++, such as when calling malloc:

float *a = malloc(10 * sizeof(float));

vs.

float *a = malloc(10 * sizeof(*a));

In the first case, changing the first float to double will produce code that compiles, but has a buffer overrun. In the second case, changing the (only) float to double works fine.