sizeof(value) vs sizeof(type)?

Question

Considering : ``` double data; double array[10]; std::vector vec(4, 100); MyClass myclass; ``` Is there a difference between : ``` sizeof(double); sizeof(double[10]); sizeof(std::vector); 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 ?

Accepted Answer

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.

sizeof(value) vs sizeof(type)?

Solution

Problem