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

Question

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

Answer 1

int est un type entier; La division de deux ints effectue une division entier , c’est-à-dire que la partie fractionnaire est tronquée, car elle ne peut pas être stockée dans le type de résultat (également Decimal!). Decimal.Divide, en revanche, a une partie fractionnaire. En appelant <=>, vos <=> arguments sont implicitement convertis en <=> s.

.

Vous pouvez appliquer une division non entière sur <=> arguments 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;

Answer 2

Dans le premier cas, vous divisez un nombre entier, le résultat est donc tronqué (la partie décimale est découpée) et un entier est renvoyé.

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

Answer 3

La ligne suivante:

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

... sera effectué à l'aide de arithmétique entière . Decimal.Divide D'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. Cela équivaut à 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

Answer 4

Je pense que Decimal.Divide(decimal, decimal) convertit implicitement ses arguments en 2 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

Answer 5

Vous souhaitez lancer les numéros:

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

Remarque: si l'un des arguments de C # est un double, une double division est utilisée, ce qui donne un double. Ainsi, les éléments suivants fonctionneraient 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();
        }

Answer 6

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

Answer 7

Dans mon cas, rien n'a fonctionné plus haut.

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 --- & Gt; 0 %: 51,6521739130435 - & Gt; 297/575 --- & Gt; 0

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

Answer 8

La réponse marquée en tant que telle est presque là, mais je pense qu’il convient d’ajouter qu’il existe une différence entre l’utilisation de doubles et de décimales.

Je ne ferais pas un meilleur travail en expliquant les concepts que Wikipedia, je vais donc simplement fournir les indications:

Arithmétique en virgule flottante

type de données décimal

Dans les systèmes financiers, il est souvent nécessaire de pouvoir garantir un certain nombre de précision de la position décimale (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 requis pour le développement décimal d'un nombre dépend de la base; un tiers prend une infinité de décimales). pour exprimer en base-10 0,333333 ..., mais il n’ya qu’une décimale en base-3: 0,1).

Les nombres en virgule flottante sont plus rapides à utiliser (en termes de temps de calcul; leur programmation est également simple) et sont privilégiés chaque fois que vous souhaitez minimiser les erreurs d'arrondi (comme dans les applications scientifiques).