sizeof() 用于表达式

Question

Can anyone explain me this code:

int a[]={1,2,3},b[]={6,7,8},c;

c=sizeof(!a+b);

cout<<c;

I'm getting as output: 8. But I don't understand why.

Answer 1

a and b in this context decay to pointer types.

So the expression !a+b is an int* type. We need to go into a little more detail here : !a is actually a bool type, and that added to an int* type is an int* type (think pointer arithmetic following the implicit conversion of the bool to an int ).

sizeof(int*) is 8 on your platform.

---

Note: sizeof is always evaluated at compile-time in C++.

Answer 2

You have to read sizeof(!a+b); , from innermost to outermost expression.

1. a decays to int* .
2. b decays to int*
3. !a is of type bool , since the logical NOT operator is applied to a .
4. !a+b is of type bool + int* --> int + int* --> int*

So you basically do:

sizeof(int*)

which is the size of a pointer, which, in your system is equal to 8.

Answer 3

_{[I added another answer to discard the upvotes I got for my now deleted answer.]}

There are a few things that are happening here.

The first is that arrays naturally decays to pointers. When an array is passed, as-is, when a pointer is expected it will be equal to a pointer to the arrays first element. In other words, the expression a is then equal to &a[0] .

The second thing to remember is that boolean values can be implicitly converted to an int with value 0 (for false ) or 1 (for true ).

The third thing to remember is that about pointer arithmetic, that integers can be added to (or subtracted from) pointers.

The fourth thing to remember is that about operator precedence . The expression !a + b is equal to (!a) + b .

And the last thing to remember is that addition is commutative . Ie x + y is the same as y + x .

Putting this all together, a decays to a pointer to its first element. Then that pointer is passed to the logical not operator ! which will turn the expression !a into a bool value of false (since the decayed pointer of a is not a null pointer). Then that false is converted to the integer 0 which is added to the decayed pointer of b . The result is a pointer, pointing to the first element of b ( b + 0 ).

You then pass this pointer to sizeof , and you're apparently on a 64-bit system where the size of a pointer is 64 bits, ie eight bytes.

Answer 4

Expressions as the operand of sizeof operator are not evaluated, it determines the size by the type of its operand. The expression !a+b is of type int * (after the array to pointer conversion), and sizeof(!a+b) is giving the size of int * on your platform.
Note that, though array as an operand of sizeof do not decay to pointer to it's first element, but in the expression !a+b (pointer arithmetic) they will.