Les littéraux à virgule flottante sans suffixe sont de type double , ceci est traité dans le projet de section standard C ++ 2.14.4 Littéraux flottants :
[...] Le type d'un littéral flottant est double sauf s'il est explicitement spécifié par un suffixe. [...]
alors est-ce une erreur d'assigner 3.0un double littéral à un flottant ?
float a = 3.0
Non, ce n'est pas le cas, il sera converti, ce qui est couvert dans la section 4.8 Conversions en virgule flottante :
Une prvalue de type à virgule flottante peut être convertie en une prvalue d'un autre type à virgule flottante. Si la valeur source peut être exactement représentée dans le type de destination, le résultat de la conversion est cette représentation exacte. Si la valeur source se situe entre deux valeurs de destination adjacentes, le résultat de la conversion est un choix défini par l'implémentation de l'une de ces valeurs. Sinon, le comportement n'est pas défini.
Nous pouvons lire plus de détails sur les implications de cela dans GotW # 67: double ou rien qui dit:
Cela signifie qu'une constante double peut être implicitement (c'est-à-dire silencieusement) convertie en constante flottante, même si cela perd de la précision (c'est-à-dire des données). Cela a été autorisé pour des raisons de compatibilité et d'utilisabilité C, mais cela vaut la peine de garder à l'esprit lorsque vous travaillez en virgule flottante.
Un compilateur de qualité vous avertira si vous essayez de faire quelque chose dont le comportement n'est pas défini, à savoir mettre une quantité double dans un flottant qui est inférieure à la valeur minimale ou supérieure à la valeur maximale qu'un flottant est capable de représenter. Un très bon compilateur fournira un avertissement facultatif si vous essayez de faire quelque chose qui peut être défini mais qui pourrait perdre des informations, à savoir mettre une quantité double dans un flottant qui se situe entre les valeurs minimale et maximale représentables par un flottant, mais qui ne peut pas être représenté exactement comme un flotteur.
Il y a donc des mises en garde pour le cas général dont vous devez être conscient.
D'un point de vue pratique, dans ce cas, les résultats seront très probablement les mêmes même s'il y a techniquement une conversion, nous pouvons le voir en essayant le code suivant sur godbolt :
#include <iostream>
float func1()
{
return 3.0;
}
float func2()
{
return 3.0f ;
}
int main()
{
std::cout << func1() << ":" << func2() << std::endl ;
return 0;
}
et nous voyons que les résultats pour func1et func2sont identiques, en utilisant à la fois clanget gcc:
func1():
movss xmm0, DWORD PTR .LC0[rip]
ret
func2():
movss xmm0, DWORD PTR .LC0[rip]
ret
Comme le souligne Pascal dans ce commentaire, vous ne pourrez pas toujours compter dessus. L'utilisation de 0.1et 0.1fentraîne respectivement une différence entre l'assembly généré car la conversion doit maintenant être effectuée explicitement. Le code suivant:
float func1(float x )
{
return x*0.1;
}
float func2(float x)
{
return x*0.1f ;
}
aboutit à l'assemblage suivant:
func1(float):
cvtss2sd %xmm0, %xmm0 # x, D.31147
mulsd .LC0(%rip), %xmm0 #, D.31147
cvtsd2ss %xmm0, %xmm0 # D.31147, D.31148
ret
func2(float):
mulss .LC2(%rip), %xmm0 #, D.31155
ret
Que vous puissiez déterminer si la conversion aura un impact sur les performances ou non, l'utilisation du type correct documente mieux votre intention. L'utilisation de conversions explicites, par exemple, static_castaide également à clarifier que la conversion était destinée par opposition à accidentelle, ce qui peut signifier un bogue ou un bogue potentiel.
Remarque
Comme le souligne supercat, la multiplication par par exemple 0.1et 0.1fn'est pas équivalente. Je vais simplement citer le commentaire car il était excellent et un résumé ne lui rendrait probablement pas justice:
Par exemple, si f était égal à 100000224 (ce qui est exactement représentable sous forme de flottant), le multiplier par un dixième devrait donner un résultat arrondi à 10000022, mais multiplier par 0,1f donnera à la place un résultat qui arrondit par erreur à 10000023 Si l'intention est de diviser par dix, la multiplication par la constante double 0,1 sera probablement plus rapide que la division par 10f, et plus précise que la multiplication par 0,1f.
Mon point initial était de démontrer un faux exemple donné dans une autre question, mais cela démontre finement que des problèmes subtils peuvent exister dans les exemples de jouets.
3.0en float pour vous. Le résultat final est indiscernable defloat a = 3.0f.