Conversion implicite C ++ (Signé + Non signé)

Je comprends qu'en ce qui concerne les conversions implicites, si nous avons un unsigned opérande de type et un type signé opérande, et le type non signé opérande est la même chose que (ou plus) que le type de la signature de l'opérande, la signature de l'opérande sera converti en non signé.

Donc:

unsigned int u = 10;  
signed int s = -8;

std::cout << s + u << std::endl;

//prints 2 because it will convert `s` to `unsigned int`, now `s` has the value
//4294967288, then it will add `u` to it, which is an out-of-range value, so,
//in my machine, `4294967298 % 4294967296 = 2`

Ce que je ne comprends pas, j'ai lu que si la signature de l'opérande a un plus grand type de la unsigned opérande:

  • si toutes les valeurs du type non signé fit dans le plus grand type, alors unsigned opérande est converti en type signé
  • si les valeurs dans le type non signé ne rentrent pas dans le plus grand type, puis la signature de l'opérande sera converti en unsigned type

donc, dans le code suivant:

signed long long s = -8;
unsigned int u = 10;
std::cout << s + u << std::endl;

u seront convertis signé long parce que les valeurs int peut s'adapter à la longue signée de temps??

Si c'est le cas, dans ce scénario, le plus petit type de valeurs ne rentre pas dans le plus grand?

source d'informationauteur 2013Asker

  1. 16

    Pertinents citation du Standard:

    5 Expressions [expr]

    10 de Nombreux opérateurs binaires qui attendent des opérandes de l'arithmétique ou de la
    type d'énumération cause de conversions et le rendement des types de résultats dans un cas similaire
    façon. Le but est de donner un type commun, qui est aussi le type de
    le résultat. Ce modèle est appelé l'habitude de l'arithmétique des conversions,
    qui sont définis comme suit:

    [2 clauses sur l'égalité des types ou des types de signe égal omis]

    — Sinon, si l'opérande qui a unsigned integer a rang
    supérieur ou égal au rang de la catégorie de l'autre opérande,
    l'opérande de type entier signé doit être converti dans le type de
    l'opérande de type entier non signé.

    — Sinon, si le type de
    l'opérande entier signé de type peut représenter toutes les valeurs
    le type de l'opérande de type entier non signé, l'opérande
    avec type entier non signé doit être converti dans le type de la
    opérande de type entier signé.

    — Sinon, les deux opérandes doivent être
    converti à l'entier non signé de type correspondant au type de
    l'opérande de type entier signé.

    Considérons la suite 3 exemple de cas pour chacune des 3 paragraphes ci-dessus sur un système où sizeof(int) < sizeof(long) == sizeof(long long) (facilement adaptable à d'autres cas)

    #include <iostream>

signed int s1 = -4;
unsigned int u1 = 2;

signed long int s2 = -4;
unsigned int u2 = 2;

signed long long int s3 = -4;
unsigned long int u3 = 2;

int main()
{
    std::cout << (s1 + u1) << "\n"; //4294967294
    std::cout << (s2 + u2) << "\n"; //-2 
    std::cout << (s3 + u3) << "\n"; //18446744073709551614  
}

    Live exemple de sortie.

    Premier alinéa de l': types de rang égal, de sorte que le signed int opérande est converti en unsigned int. Cela implique une valeur de transformation, qui (en utilisant en complément à deux) donne te imprimés de valeur.

    Deuxième alinéa: type signé a de plus haut rang, et (sur cette plate-forme!) peut représenter toutes les valeurs de type non signé, donc non signé opérande est converti en type signé, et vous obtenez -2

    Troisième alinéa: type signé de nouveau a de plus haut rang, mais (sur cette plate-forme!) ne peut pas représenter toutes les valeurs de type non signé, de sorte que les deux opérandes sont convertis à unsigned long longet d'après la valeur de la transformation sur la signature de l'opérande, vous obtenez les imprimés de valeur.

    Noter que lorsque le non signé opérande serait assez grand (par exemple 6 dans ces exemples), alors que le résultat final serait de donner 2 pour tous les 3 exemples, parce que de unsigned integer overflow.

    (Ajouté) Note que vous obtenez encore plus de résultats inattendus lorsque vous faites des comparaisons sur ces types. Considérons l'exemple ci-dessus 1 avec <:

    #include <iostream>

signed int s1 = -4;
unsigned int u1 = 2;
int main()
{
    std::cout << (s1 < u1 ? "s1 < u1" : "s1 !< u1") << "\n";  //"s1 !< u1"
    std::cout << (-4 < 2u ? "-4 < 2u" : "-4 !< 2u") << "\n";  //"-4 !< 2u"
}

    Depuis 2u est faite unsigned explicitement par le u suffixe les mêmes règles s'appliquent. Et le résultat n'est probablement pas ce que vous attendez lorsque l'on compare les -4 < 2 lors de l'écriture en C++ -4 < 2u...

  2. 2

    signed int ne rentre pas dans unsigned long long. Ainsi, vous aurez cette conversion:
    signed int -> unsigned long long.

  3. 0

    Noter que le C++11 standard ne parle pas de la plus grande ou plus petite des types ici, il parle avec des types plus bas ou plus haut rang.

    De considérer le cas de long int et unsigned int où les deux sont en 32 bits. Le long int a une plus grande place que la unsigned intmais depuis long int et unsigned int sont à la fois 32 bits, long int ne peut pas représenter toutes les valeurs de unsigned int.

    Par conséquent, nous tombons dans le dernier cas (C++11: 5.6p9):

    • Sinon, les deux opérandes sont convertis à l'entier non signé de type correspondant à la
      type de l'opérande de type entier signé.

    Cela signifie que les long int et la unsigned int seront convertis en unsigned long int.