Pourquoi Decimal.Divide (int, int) fonctionne-t-il, mais pas (int / int)?

Comment se fait-il que la division de deux nombres int 32 bits comme (int / int) me revienne 0, mais si j'utilise Decimal.Divide()j'obtiens la bonne réponse? Je ne suis en aucun cas un gars ac #.

intest un type entier; diviser deux entiers effectue une division entière , c'est-à-dire que la partie fractionnaire est tronquée car elle ne peut pas être stockée dans le type de résultat (aussi int!). Decimal, en revanche, a une partie fractionnaire. En invoquant Decimal.Divide, vos intarguments sont implicitement convertis en Decimals.

Vous pouvez appliquer une division non entière sur les intarguments en convertissant explicitement au moins l'un des arguments en un type à virgule flottante, par exemple:

int a = 42;
int b = 23;
double result = (double)a / b;

Dans le premier cas, vous faites une division entière, donc le résultat est tronqué (la partie décimale est coupée) et un entier est renvoyé.

Dans le second cas, les entiers sont d'abord convertis en décimales et le résultat est un décimal. Par conséquent, ils ne sont pas tronqués et vous obtenez le résultat correct.

La ligne suivante:

int a = 1, b = 2;
object result = a / b;

... sera effectuée en utilisant l' arithmétique entière . Decimal.Divided'autre part prend deux paramètres du type Decimal, donc la division sera effectuée sur des valeurs décimales plutôt que sur des valeurs entières. C'est l'équivalent de ceci:

int a = 1, b = 2;
object result = (Decimal)a / (Decimal)b;

Pour examiner cela, vous pouvez ajouter les lignes de code suivantes après chacun des exemples ci-dessus:

Console.WriteLine(result.ToString());
Console.WriteLine(result.GetType().ToString());

La sortie dans le premier cas sera

0
System.Int32

..et dans le second cas:

0,5
System.Decimal

Je compte Decimal.Divide(decimal, decimal)convertit implicitement ses 2 arguments int en décimales avant de renvoyer une valeur décimale (précise) où 4/5 est traité comme une division entière et renvoie 0

Vous souhaitez lancer les chiffres:

double c = (double) a / (double) b;

Remarque: Si l'un des arguments en C # est un double, une double division est utilisée, ce qui entraîne un double. Donc, ce qui suit fonctionnerait aussi:

double c = (double) a / b;

voici un petit programme:

static void Main(string[] args)
        {
            int a=0, b = 0, c = 0;
            int n = Convert.ToInt16(Console.ReadLine());
            string[] arr_temp = Console.ReadLine().Split(' ');
            int[] arr = Array.ConvertAll(arr_temp, Int32.Parse);
            foreach (int i in arr)
            {
                if (i > 0) a++;
                else if (i < 0) b++;
                else c++;
            }
            Console.WriteLine("{0}", (double)a / n);
            Console.WriteLine("{0}", (double)b / n);
            Console.WriteLine("{0}", (double)c / n);
            Console.ReadKey();
        }

Si vous recherchez une réponse 0 <a <1, int / int ne suffira pas. int / int effectue une division entière. Essayez de lancer l'un des int en double dans l'opération.

Dans mon cas, rien n'a fonctionné ci-dessus.

ce que je veux faire, c'est diviser 278 par 575 et multiplier par 100 pour trouver le pourcentage.

double p = (double)((PeopleCount * 1.0 / AllPeopleCount * 1.0) * 100.0);

%: 48,3478260869565 -> 278/575 ---> 0%: 51,6521739130435 -> 297/575 ---> 0

si je multiplie le PeopleCount par 1,0, cela le rend décimal et la division sera de 48,34 ... multiplie également par 100,0 et non par 100.

La réponse indiquée comme telle est presque là, mais je pense qu'il vaut la peine d'ajouter qu'il y a une différence entre l'utilisation du double et du décimal.

Je ne ferais pas un meilleur travail pour expliquer les concepts que Wikipédia, je vais donc simplement fournir les pointeurs:

arithmétique en virgule flottante

type de données décimal

Dans les systèmes financiers, il est souvent nécessaire de garantir l'exactitude d'un certain nombre de décimales (base 10). Ceci est généralement impossible si les données d'entrée / source sont en base-10 mais nous effectuons l'arithmétique en base-2 (car le nombre de décimales nécessaires pour l'expansion décimale d'un nombre dépend de la base; un tiers prend une infinité de décimales endroits pour exprimer en base-10 comme 0,333333 ..., mais il ne prend qu'une décimale en base-3: 0,1).

Les nombres à virgule flottante sont plus rapides à utiliser (en termes de temps CPU; en termes de programmation, ils sont tout aussi simples) et préférés chaque fois que vous souhaitez minimiser les erreurs d'arrondi (comme dans les applications scientifiques).