C++ conversion de type implicite entre les types intrinsèques

Question

En C++ opérateurs binaires pour les types intrinsèques, les deux opérandes doivent avoir le même type, sinon, l'un des opérandes se convertissent au type de l'autre opérande basé sur une hiérarchie:

long double 
double 
float 
unsigned long long int 
long long int 
unsigned long int 
long int 
unsigned int 
int 

Ma question est: Pourquoi unsigned T est dans un niveau supérieur à T. est-ce juste un choix arbitraire ou il y a quelques avantages à convertir T en Unsigned T et non l'inverse.

Mise à jour:

//where `unsigned int` to `int` work better. 
int a=-3; 
unsigned int b=3; 
cout << a+b; /* this will output the right result if b get converted to int, 
which is not what really happen.*/ 

---

//where `int` to `unsigned int` work better. 
int a=3; 
unsigned int b=pow(2,20); 
cout << a+b; /* this will output the right result if a get converted to unsigned int, 
which is fortunately what really happen.*/ 

Je ne vois pas comment convering T-Unsigned T a plus d'avantages que l'inverse.

Answer 1

Il est essentiellement un choix arbitraire qui remonte aux premiers jours de C.

Pour autant que je sache, la règle était essentiellement dans la pré-norme K & RC que si un opérande d'un opérateur avait un type non signé, le résultat serait également non signé (cela s'appelle unsigned-preserving). Lorsque C a été normalisé, cette règle a été remplacée par la règle actuellement utilisée par C et C++, qui permet de supprimer la propriété unsigned, à condition que la valeur puisse être représentée dans le type cible (cela s'appelle value -conservation). La raison en était que les nouvelles règles fournissaient moins de surprises aux programmeurs qui ne se doutaient de rien en faisant des calculs arithmétiques signés/non signés.

La conversion T-unsigned T peut avoir deux interprétations:

1. Il est une des règles de maintien au-dessus de l'ancien (non signé) conservant.
2. C'est la seule chose sensée à faire qui n'exige pas un type plus grand que unsigned long long pour des choses comme: 1ULL > -1LL, parce que la conversion signé à unsigned est toujours définie (en vertu de la caractéristique wrap-around des entiers non signés), mais la conversion inverse ne l'est pas.

Answer 2

Je suppose que la logique est que la taille réelle de int est 1 bit de moins de unsigned int depuis le MSB est utilisé pour le signe. Ainsi, la plage de valeurs absolues de la variable signée est la moitié de celle de la variable non signée.