Entier additionnant les blues, court += petit problème

Programme en C#:

short a, b;
a = 10;
b = 10;
a = a + b; //Error : Cannot implicitly convert type 'int' to 'short'.

//we can also write this code by using Arithmetic Assignment Operator as given below

a += b; //But this is running successfully, why?

Console.Write(a);
  • La première échoue à cause de courtes + short = int telle que définie dans le cahier des charges, tout comme octet + octet = int, cependant j'aurais attendu la deuxième aussi un échec, donc je suis impatient de voir le raisonnement ici.
  • avez-vous trouvé une raison quelconque ?
  • Cela est répondu de façon aussi détaillée que possible ci-dessous par Eric Lippert, donc je ne suis pas vraiment sûr de ce que votre demande ici. En bref est parce que a += b est le même que a = (short)(a+b)
  • Double Possible de byte + octet = int... pourquoi?
InformationsquelleAutor Mohammad Jahangeer Ansari | 2010-12-03
  1. 71

    Il y a deux questions ici. La première est: "pourquoi est court, plus court entraîner int?"

    Eh bien, supposons que court, plus court a été de courte et de voir ce qui se passe:

    short[] prices = { 10000, 15000, 11000 };
short average = (prices[0] + prices[1] + prices[2]) / 3;

    Et la moyenne est, bien sûr, -9845 si ce calcul est effectué en short. La somme est plus grande que la plus grande possible, en bref, il s'enroule autour de négatif, et puis vous divisez le nombre négatif.

    Dans un monde où l'arithmétique entière s'enroule autour de il est beaucoup plus judicieux de faire tous les calculs en int, un type qui est susceptible d'avoir assez de gamme typique de calculs, pas de débordement.

    La deuxième question est:

    • court, plus court est de type int
    • attribution d'int à court est illégal
    • a +=b est le même que a = a + b
    • donc à court += court devrait être illégal
    • alors, pourquoi est-ce légal?

    La question a une prémisse inexacte; la troisième ligne ci-dessus est faux. La spécification C# états dans la section 7.17.2

    Autrement, si l'opérateur est
    un prédéfinies de l'opérateur, en cas de retour
    type de l'opérateur sélectionné est
    explicitement convertie dans le type de
    x, et si y est implicitement convertible
    pour le type de x ou de l'opérateur est un
    opérateur de décalage, puis l'opération est
    évalué comme x = (T)(x op y), où T
    est le type de x, sauf que x est
    évaluées qu'une seule fois.

    Le compilateur insère la fonte sur votre nom. Le bon raisonnement est:

    • court, plus court est de type int
    • attribution d'int à court est illégal
    • + s1= s2 est le même que s1 = (short)(s1 + s2)
    • donc ce devrait être légal

    Si elle n'a pas insérer de la fonte pour vous, alors il serait impossible d'utiliser des raccourcis sur de nombreux types.

    • votre premier échantillon n'est pas bon. Si vous remplacez short avec int tout fonctionne correctement, mais si nous mettons plus grand nombre (pour faire de la somme doit être supérieur à 2^31), il sera la cause int débordement. ma question est pourquoi short + short = int (et pour byte) et int + int = int (pas longtemps par exemple).
    • Pourquoi il a été décidé que l'int ne devrait pas s'élargir à longs? je peux comprendre le raisonnement de l'élargissement du calcul sur des octets et des shorts, mais il semble tout aussi probable que l'arithmétique sur int peut déborder, ainsi. Est-ce juste une concession au fait que sur les architectures 32 bits il y a de commode instructions de maintenir les résultats dans les registres 32 bits? Ou est-il quelque chose de plus profond à jouer ici?
    • Est-il vraiment "probable"? J'écris des compilateurs pour une vie et je m'occupe tous les jours avec de la compilation de programmes qui ont plus que, disons, 2^15 types. Si je suis en additionnant le nombre de types dans un tas de différentes assemblées, j'ai pu facilement débordement d'un court-circuit. Je n'ai jamais eu un problème dans le compilateur de l'espace où je pouvais raisonnablement dépassement de capacité d'un int. Le compilateur serait manquer de mémoire virtuelle longtemps avant qu'il a réussi à faire des opérations impliquant un programme qui dispose de deux milliards de types en elle. Il n'est tout simplement pas probable dans la plupart des scénarios d'avoir 32 bits de dépassement.
    • Oui, l'arithmétique des nombres entiers peuvent déborder. Si vous voulez éviter cela, vous pouvez utiliser l'objet de l'opérateur pour s'assurer que les débordements d'entiers résultat dans les exceptions. Si vous vous sentez qu'il est probable que vous allez travailler avec des entiers assez grande pour que les mathématiques courantes opérateurs sur eux peuvent déborder, alors vous devez faire tout votre arithmétique dans la nostalgie en premier lieu.
    • Lippert, je me demandais juste pourquoi le comportement est différent pour short et int.
    • int est utilisé dans de nombreux contextes de calcul, dont certains n'ont aucun rapport avec la mémoire/espace de processus. En tant que matériel informatique augmentation de puissance & capacité, ces limites vont être dépassé assez vite sur une base régulière. Mais peut-être une meilleure façon d'exprimer mon point est que si le compilateur décide de creuser plus petits types plus large de types lors de l'exécution de l'arithmétique pour éviter les imprévus de débordement, il convient de le faire avec tous les types qui ont une disposition plus large de type qui préserve à la plage et à la représentation de la précision. Le choix d'arrêter à l'int (et ne pas s'élargir à de long) est un peu inattendu.
    • Parce que les shorts et les services de renseignements sont très différent. Le plus réaliste des calculs effectués dans les entiers utilisent seulement une fraction minuscule de la gamme d'un int; ces mêmes calculs utilisent les tous les ou plus que tout de la gamme de court. La plupart des processeurs modernes font leur math entier de 32 bits en mode natif, vous avez à aller chemin du retour dans le temps pour trouver les processeurs qui ne de travailler en 16 bits en natif. J'ai travaillé sur des compilateurs pour les 16 bits de Windows en 1997.
    • OK, donc vous avez de nous (1) dire que int + int est long? Le faire revient à dire que tous les calculs se font toujours dans la nostalgie de tous les temps. Vous ne voulez pas rendre les gens insérer jette dans chaque calcul d'entier. (2) C# ont des comportements différents en fonction de l'architecture, que C est? (3) automatiquement élargir à un plus grand type, comme VBScript n'; abandonner le typage statique en C#. (4) autre chose? Chacune de ces approches a grave de la performance ou de la portabilité des coûts. Les coûts sont en vaut la peine?
    • Tous ceux qui sont de bons points. Du n ° 1, le C# est un langage où tout arithmétique est effectuée dans les services de renseignements de tous les temps. Outre les implications sur les performances, je ne vois pas de raison de préférer une plus étroite de type à un plus large. La Performance pourrait très bien être un facteur décisif, cependant. Le n ° 2, je suis d'accord que le comportement différent sur différentes architectures est pas souhaitable et doit être évitée. Je ne pense pas que nous voulons abandonner le typage statique soit. BTW, ne vous méprenez pas, je suis juste essayer de comprendre le raisonnement derrière les décisions de conception qui entrent dans la création d'un langage comme C#.
    • Je suppose que je dirais que, parfois, il serait bien d'avoir plus de contrôle fin de la quand le type l'élargissement a lieu. J'ai souvent voulu effectuer des calculs sur des octets ou des shorts que je n'en voulait pas se faire par la promotion de int (depuis que je suis essentiellement exécution de calculs au niveau du bit). Une syntaxe (peut-être similaire à la coché/décoché blocs) pour permettre ce serait sympa.
    • Pourquoi voulez-vous éviter ces promotions? Je vous assure que le common language runtime, runtime couche et, en fin de compte, le CPU élargir ceux de type int. Supposons que, pour les besoins de la discussion que nous voulais à court + court séjour en short. IL couche n'a pas d'opcodes pour cette opération. Il ne dispose que d'opcodes pour entier plus. Le CLR est en train de convertir ces courts-métrages à ints, peu importe. Supposons que nous avons ajouté à court outre, les opérateurs de l'IL; maintenant, qu'est-ce que la gigue va faire? La puce va élargir les opérandes de 32 bits lorsqu'il enregisters eux.
    • Généralement, les octets et les shorts sont utilisés pour représenter des nombres - et si vous voulez qu'ils se comportent avec la sémantique des nombres. Mais parfois, vous avez juste besoin d'un commandés sac de bits et que vous voulez utiliser les opérations arithmétiques pour leurs effets secondaires. L' ^, |, &, << et >> les opérateurs sur les bits de conserver le type de l'expression, elles sont appliquées à - mais parfois, il peut être utile de s' +, -, *, et / pourraient faire aussi bien. L'arithmétique avec les services d'appoint de temps en temps utiles. Toutefois, je comprends votre point de savoir si c'est suffisamment précieux pour que suffisamment de gens à concevoir, développer et tester pour C#.
    • Aussi, j'ai eu l'impression qu'au moins sur l'architecture x86, il est possible d'effectuer déplacer, charger et de l'arithmétique sur les 16 bits non étendue des registres. Et vous pouvez également accéder à la basse et à haute 8-bits subregisteres (eg. AL et AH dans AX). De toute évidence, le comportement non-x86 architectures pourrait être très différent.
    • Belle réponse....

    InformationsquelleAutor Eric Lippert
  2. 12

    Bien, le += opérateur dit que vous serez l'augmentation de la valeur de a avec un short, tout = dit que vous aurez remplacer la valeur, avec le résultat d'une opération. L'opération a + b donne un int, ne sachant pas qu'il peut faire autrement, et que vous essayez d'assigner l'int d'un court-circuit.

    • alors quelle est la différence entre l'augmentation de la valeur de vs ajouter de la valeur ?
    • Je n'avais pas vraiment prévu cela. J'ai pensé += était juste une abréviation!
    • Je comprends que le = opérateur affecte une nouvelle valeur (dans ce cas, le mauvais type), mais le += utilise une mise en œuvre différente (c'est à dire, il ajoute comme nous le prévoyons, à l').
    • nous sommes également en sachant que a+=b même que a=a+b...
    • J'ai aussi toujours pensé que a+=b était juste un raccourci pour a=a+b, donc j'aimerais vraiment voir une confirmation ici pour être tout à fait convaincu.
    • Bråthen il semble être comme ceci: a+=b = a=a+b à moins que l'opérateur += est surchargé, et il semble qu'il est de type short, et il n'y a pas + pour short, shortA + shortB s'élargit et devient (int)shortA + (int)shortB.
    • Il semble donc, mais je veux encore la confirmation pour être sûr 😉
    • il n'y a pas une telle chose comme "la surcharge de l'opérateur+=". Composé d'opérateurs ne peuvent pas être surchargés en C#.

    InformationsquelleAutor David Hedlund
  3. 9

    Vous devez utiliser:

    a = (short)(a + b);

    À la différence entre les comportements d'attribution et d'affectation d'addition, j'imagine que ça a quelque chose à voir avec cela (à partir de msdn)

    x+=y
is equivalent to
x = x + y
except that x is only evaluated once. The meaning of the + operator is
dependent on the types of x and y (addition for numeric operands, 
concatenation for string operands, and so forth).

    Cependant, c'est un peu vague, donc mabye quelqu'un avec une compréhension plus profonde peut commentaire.

    • a =(court) a + b // c'est aussi ne fonctionne pas chers,,,, montrant même problème....
    • avez-vous essayer avec les deux ensembles de parenthèses? le code dans votre commentaire, c'est différent.
    • Où faut-il dire que sur MSDN? C'est faux si le + est un opérateur prédéfini, qui, dans ce cas, c'est clairement. Dans ce cas, il est équivalent à x = (T)(x + y), tel que spécifié. Si vous pouvez m'envoyer le lien vers la page, je vais les porter à l'attention de la documentation des gestionnaires.
    • Bien sûr, c'est sur cette page: msdn.microsoft.com/en-us/library/sa7629ew.aspx
    InformationsquelleAutor UpTheCreek
  4. 7

    Cela se produit parce que l'int est le plus petit type signé pour qui + est défini. Rien de plus petit est le premier promu en int. Le += opérateur est défini à l'égard de +, mais avec un cas spécial de la règle de gestion des résultats qui ne correspondent pas à la cible.

    • Cette réponse est incorrecte. += n'est pas définie pour chaque type numérique. Voir la section 7.17.2 de la spécification C#.
    InformationsquelleAutor Marcelo Cantos
  5. 1

    C'est parce que += est mis en œuvre comme une fonction surchargée (dont l'un est courte, et le compilateur choisit le plus spécifique de la surcharge). Pour l'expression (a + b), le compilateur s'élargit le résultat d'un int par défaut avant de l'affecter.

    • surcharge de l'opérateur ne peut en œuvre avec l'utilisateur à l'opérateur définie comme la classe , la structure. mais c'est + un opérateur arithmétique, qui est intégré.L'opérateur += ne peut pas être surchargé directement, mais des types définis par l'utilisateur peuvent surcharger l'opérateur+, pour les détails, consultez le lien,,msdn.microsoft.com/en-us/library/sa7629ew(v=VS.71).aspx
    • jak est correct. L'opérateur += est pas une fonction surchargée en C#.
    InformationsquelleAutor Stefan Mai