A propos de la fonction pow en C++

Question

Je viens d'essayer trois morceaux de code:

#include<cstdio> 
#include<cmath> 
#include<cstring> 
int main() 
{ 
    int a = 3; 
    int b = pow(10,a); 
    printf("%d",b); 
    return 0; 
} 
//Output:1000 

#include<cstdio> 
#include<cmath> 
#include<cstring> 
int main() 
{ 
    int a = 3; 
    int b = pow(10,a-1); 
    printf("%d",b); 
    return 0; 
} 
//Output:99 

#include<cstdio> 
#include<cmath> 
#include<cstring> 
int main() 
{ 
    int a = 3; 
    int b = pow(10,a-2); 
    printf("%d",b); 
    return 0; 
} 
//Output:10 

Je voudrais savoir pourquoi le deuxième bloc de code sortie 99, est-ce à cause de la précision en virgule flottante? Ou est-ce parce que je devrais employer des nombres de flotteur dans la fonction de pow? (Tels que 10.0) Je suis habituellement confus au sujet de l'exactitude de C++, je vous serai reconnaissant pour votre aide.

Answer 1

La conversion d'une valeur à virgule flottante en nombre entier se fait par troncature - l'entier suivant est le plus proche de zéro. Si pow est imprécis et trop bas, alors la troncature l'exacerbe.

lround(pow(10,2)) pourrait être plus approprié.

Answer 2

Pour entier exposants le modèle suivant peut être très pratique:

template <typename T> inline constexpr T pow(T base, int exponent) 
{ 
    return (exponent == 0) ? static_cast<T>(1.0) : ((exponent>0) ? base*pow(base, exponent-1) : pow(static_cast<T>(1.0)/base, -exponent)); 
} 

Si vous prévoyez de l'utiliser avec un standard C++ avant 11 C++, il suffit de retirer le mot-clé constexpr.