Pourquoi 'auto' ne respecte-t-il pas l'opérateur unaire moins ?

Question

Je suis assez novice en C++ mais je trouve ce comportement de auto bizarre :

class A{};

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

La variable x est unsigned dans ce cas bien que j'ai utilisé l'opérateur unaire moins à l'initialisation de la variable. Comment se fait-il que seul le type de retour de sizeof ( std::size_t ) est pris en compte mais pas le fait que le nombre stocké sera négatif à cause de l'opérateur utilisé ?

Je suis au courant de size_t étant un int non signé.

J'ai essayé cela avec GCC 8.1.0 et C++17.

Answer 1

Le problème réel ici est que l'utilisation de l'opérateur moins unaire, tout comme le reste des opérateurs arithmétiques intégrés, est sujette à l'approbation de la Commission européenne. promotions intégrales . Il est donc surprenant que le résultat de l'application du moins unaire à size_t sera toujours size_t et il n'y a pas besoin de blâmer auto .

Contre-exemple. Dans ce cas, en raison des promotions intégrales de type x sera int donc la sortie sera -1 :

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

Answer 2

Votre expression -(sizeof(a)) applique la méthode unaire - à une valeur de type non signé. L'opérateur unaire - ne transforme pas une valeur intégrale non signée en une valeur signée ; il définit plutôt quelle valeur non signée sera le résultat d'une telle opération comme suit (cf. opérateurs arithmétiques unaires chez cppreference.com ):

L'opérateur unaire moins construit calcule la négative de son opérande promu. Pour un a non signé, la valeur de -a est 2^b -a, où b est le nombre de bits après la promotion.

Ainsi, même si cela peut être surprenant, auto fonctionne correctement, comme le résultat de l'application de l'unaire - à une valeur non signée reste une valeur non signée.

Answer 3

Le résultat de (unaire) - appliquée à une valeur non signée est non signée, et sizeof renvoie une valeur non signée.

L'opérande de l'opérateur unaire - doit être d'un type arithmétique ou d'un type d'énumération non scopé. et le résultat est la négation de son opérande. La promotion intégrale est effectuée sur des opérandes de type intégral ou énumération. La négation d'une quantité non signée est calculée en soustrayant sa valeur de 2^n, où n est la valeur de l'opérateur. de 2^n, où n est le nombre de bits de l'opérande promu. Le type du résultat est le type de l'opérande promu.

[expr.unary.op]

Le résultat de sizeof y sizeof... est une constante de type std::size_­t

[expr.sizeof]

Pour éviter le comportement défini par l'implémentation, vous devez convertir en int avant d'appliquer le -

Si le type de destination est signé, la valeur est inchangée si elle peut être représentée dans le type de destination. représentée dans le type de destination ; sinon, la valeur est définie par l'implémentation.

[conv.integral]

class A{};

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

Answer 4

Si nous jetons un coup d'oeil : https://en.cppreference.com/w/cpp/language/sizeof le résultat est de type size_t qui est unsigned . Vous devez explicitement le déclarer comme un signed int pour autoriser les valeurs négatives.

Au lieu de auto vous pouvez écrire int qui autorise les valeurs négatives.