web-dev-qa-db-fra.com

Impossible de convertir implicitement le type 'int' en 'short'

J'ai écrit le petit programme suivant pour imprimer la séquence de Fibonacci:

static void Main(string[] args)
{
    Console.Write("Please give a value for n:");
    Int16 n = Int16.Parse(Console.ReadLine());

    Int16 firstNo = 0;
    Int16 secondNo = 1;

    Console.WriteLine(firstNo);
    Console.WriteLine(secondNo);

    for (Int16 i = 0; i < n; i++)
    {
        //Problem on this line                    
        Int16 answer = firstNo + secondNo;

        Console.WriteLine(answer);

        firstNo = secondNo;
        secondNo = answer;
    }

    Console.ReadLine();

}

Le message de compilation est:

Impossible de convertir implicitement le type 'int' en 'short'. Il existe une conversion explicite (il vous manque une distribution?)

Puisque tout ce qui est impliqué est un Int16 (court), alors pourquoi y a-t-il des conversions implicites? Et plus précisément pourquoi l'échec ici (et non lors de l'attribution initiale d'un int à la variable)?

Une explication serait très appréciée.

c#intshort
38
m.edmondson

Microsoft convertit votre Int16 variables dans Int32 lors de la fonction d'ajout.

Modifiez les éléments suivants:

Int16 answer = firstNo + secondNo;

dans...

Int16 answer = (Int16)(firstNo + secondNo);
79
m-y

Lire les réponses de Eric Lippert à ces questions

8
abhilash

Ajout de deux Int16 les valeurs donnent un Int32 valeur. Vous devrez le lancer sur Int16:

Int16 answer = (Int16) (firstNo + secondNo);

Vous pouvez éviter ce problème en basculant tous vos numéros sur Int32.

5
Martin Liversage

Le problème est que l'ajout de deux Int16 donne un Int32 comme d'autres l'ont déjà souligné.
Votre deuxième question, pourquoi ce problème ne se produit pas déjà lors de la déclaration de ces deux variables est expliquée ici: http://msdn.Microsoft.com/en-us/library/ybs77ex4% 28v = VS.71% 29.aspx :

short x = 32767;

Dans la déclaration précédente, le littéral entier 32767 est implicitement converti de int en short. Si le littéral entier ne tient pas dans un emplacement de stockage court, une erreur de compilation se produit.

Ainsi, la raison pour laquelle cela fonctionne dans votre déclaration est simplement que les littéraux fournis sont connus pour tenir dans un short.

3
Daniel Hilgarth

Pour une raison étrange, vous pouvez utiliser l'opérateur + = pour ajouter des courts-circuits.

short answer = 0;
short firstNo = 1;
short secondNo = 2;

answer += firstNo;
answer += secondNo;
2
Karl Gjertsen

L'opérateur plus convertit d'abord les opérandes en entier, puis fait l'addition. Le résultat est donc l'int. Vous devez le reconstituer de manière explicite, car les conversions d'un type "plus long" en type "plus court" sont rendues explicites, afin de ne pas perdre de données accidentellement avec une conversion implicite.

Quant à la raison pour laquelle int16 est converti en int, la réponse est, car c'est ce qui est défini dans spécification C # . Et C # est ainsi parce qu'il a été conçu pour correspondre étroitement à la façon dont fonctionne CLR, et CLR n'a qu'une arithmétique 32/64 bits et non 16 bits. D'autres langues en plus de CLR peuvent choisir d'exposer cela différemment.

2
Andrew Savinykh

La ligne

 Int16 answer = firstNo + secondNo;

est interprété comme

 Int16 answer = (Int32) (firstNo + secondNo);

Tout simplement parce que l'arithmétique Int16 n'existe pas.

La solution simple: Do ne pas utiliser Int16. Utilisez Int32 ou simplement int.

int est votre type d'entier par défaut. court et long ne sont utilisés que dans des cas particuliers.

1
Henk Holterman

Le résultat de la somme de deux Int16 variables est un Int32:

Int16 i1 = 1;
Int16 i2 = 2;
var result = i1 + i2;
Console.WriteLine(result.GetType().Name);

Il génère Int32.

1
Aliostad

En effet, le résultat de l'ajout de deux Int16 est un Int32. Vérifiez le paragraphe "conversions" ici: http://msdn.Microsoft.com/en-us/library/ybs77ex4%28v=vs.71%29.aspx

0
Paolo Tedesco