conversions de type implicites dans les expressions int doubler

Question

J'ai essayé de réduire les conversions de type implicites lorsque j'utilise des constantes nommées dans mon code. Par exemple, plutôt que d'utiliser

const double foo = 5;

J'utiliser

const double foo = 5.0;

de sorte qu'une conversion de type n'a pas besoin d'avoir lieu. Cependant, dans les expressions où je fais quelque chose comme ça ...

const double halfFoo = foo / 2;

etc. Est-ce que 2 a évalué comme un entier et est-il converti implicitement? Dois-je utiliser un 2.0 à la place?

Answer 1

Le 2 est implicitement converti en un double car foo est double. Vous ne devez faire attention parce que si foo était, par exemple, serait effectué un nombre entier, la division entière, puis le résultat sera stocké dans halfFoo.

Je pense qu'il est bon de toujours utiliser littéraux à virgule flottante (par exemple 2.0 ou 2. où vous avez l'intention qu'ils soient utilisés comme valeurs à virgule flottante. Il est plus cohérent et peut vous aider à trouver des bogues pernicieux qui peuvent surgir avec ce genre de chose.

Answer 2

Ceci est connu comme type Coercion. Wikipedia a un peu agréable à son sujet:

  

conversion de type implicite, également connu sous contrainte, est une conversion de type automatique par le compilateur. Certaines langues permettent, voire exigent, compilateurs pour fournir la contrainte.

     

Dans une expression de type mixte, les données d'un ou plusieurs sous-types peuvent être convertis en un super-type au besoin lors de l'exécution afin que le programme fonctionnera correctement.

     

...

     

Ce comportement doit être utilisé avec prudence, car les conséquences imprévues peuvent surgir. Les données peuvent être perdues lorsque des représentations à virgule flottante sont converties en représentations intégrales comme les composantes fractionnaires des valeurs à virgule flottante seront tronqués (arrondi). A l'inverse, la conversion d'une représentation intégrale à une virgule flottante, on peut aussi perdre sa précision, étant donné que le type à virgule flottante peut être incapable de représenter le nombre entier exactement (par exemple, le flotteur peut être un type simple précision IEEE 754, qui ne peut pas représenter le 16777217 entier exactement, alors qu'un type entier 32 bits peuvent). Cela peut conduire à des situations telles que le stockage de la même valeur entière en deux variables de type entier et le type réel qui return false si par rapport à l'égalité.

Dans le cas de C et C ++, la valeur d'une expression de types intégraux (à savoir Longs, entiers, shorts, chars) est le plus grand type intégral dans l'expression. Je ne sais pas, mais j'imagine quelque chose de semblable se produit (en supposant des valeurs à virgule flottante sont « plus » que les entiers) avec des expressions impliquant nombres à virgule flottante.

Answer 3

Strictement parlant, ce que vous essayez d'atteindre semble être contre-productif.

Normalement, on s'efforcer de réduire le nombre de explicites conversions de type dans un programme C et, en général, de réduire toutes et toutes les dépendances de type dans le code source. Code de bonne C doit être le type indépendant que possible. Cela signifie généralement qu'il est une bonne idée d'éviter les éléments explicites syntaxiques qui définissent des types spécifiques aussi souvent que possible. Il est préférable de faire

const double foo = 5; /* better */

que

const double foo = 5.0; /* worse */

parce que ce dernier est redondant. Les règles de conversion de type implicite du langage C fera en sorte que les anciens fonctionne correctement. La même chose peut être dit au sujet des comparaisons. Ce

if (foo > 0)

est mieux que

if (foo > 0.0)

parce que, encore une fois, le premier est plus de type indépendant.

conversion de type implicite dans ce cas est une très bonne chose, pas une mauvaise chose. Il vous aide à écrire un code de type générique indépendant. Pourquoi vous essayez de les éviter?

Il est vrai que dans certains cas, vous n'avez pas d'autre choix que d'exprimer explicitement le type (comme l'utilisation 2.0 au lieu de 2 et ainsi de suite). Mais, normalement, on le ferait que si l'on a vraiment. Pourquoi quelqu'un ferait sans un réel besoin est au-delà de moi.