为什么'auto'不尊重一元减运算符？

Question

I'm quite new to C++ but I find this behaviour of auto weird:

class A{};

int main() {
    A a;
    auto x = -(sizeof(a));
    cout << x << endl;
    return 0;
}

Variable x is unsigned in this case although I used the unary minus operator at the initialiation of the variable. How come that only the return type of sizeof ( std::size_t ) is considered but not the fact that the stored number will be negative because of the used operator?

I'm aware of size_t being an unsigned int.

I've tried this with GCC 8.1.0 and C++17.

Answer 1

The actual issue here is that use of unary minus operator, just like the rest of built-in arithmetic operators, is a subject to integral promotions . So surprisingly the result of applying unary minus to size_t will be still size_t and there is no need to blame auto .

Counter-example. In this case due to integral promotions type of x will be int so output will be -1 :

unsigned short a{1};
auto x{-a};
cout << x << endl;

Answer 2

Your expression -(sizeof(a)) applies the unary - operator to a value of unsigned type. The unary - operator does not turn an unsigned integral value into a signed one; it rather defines which unsigned value will be the result of such an operation as follows (cf. unary arithmetic operators at cppreference.com ):

The builtin unary minus operator calculates the negative of its promoted operand. For unsigned a, the value of -a is 2^b -a, where b is the number of bits after promotion.

Hence, even if it may be surprising, auto works correctly, as the result of applying unary - operator to an unsigned value is still an unsigned value.

Answer 3

The result of (unary) - applied to an unsigned value is unsigned, and sizeof returns an unsigned value.

The operand of the unary - operator shall have arithmetic or unscoped enumeration type and the result is the negation of its operand. Integral promotion is performed on integral or enumeration operands. The negative of an unsigned quantity is computed by subtracting its value from 2^n, where n is the number of bits in the promoted operand. The type of the result is the type of the promoted operand.

[expr.unary.op]

The result of sizeof and sizeof... is a constant of type std​::​size_t

[expr.sizeof]

To avoid implementation defined behaviour, you have to convert to int before applying the -

If the destination type is signed, the value is unchanged if it can be represented in the destination type; otherwise, the value is implementation-defined.

[conv.integral]

class A{};

int main() {
    A a;
    auto x = -(int{sizeof(a)});
    cout << x << endl;
    return 0;
}

Answer 4

If we take a look at: https://en.cppreference.com/w/cpp/language/sizeof , the result is of type size_t which is unsigned . You explicity need to declare it as an signed int to allow negative values.

Instead of auto you can write int which allows negative values.