Dans ce didacticiel, nous allons découvrir les types de données float et double à l'aide d'exemples. Nous examinerons également certaines des principales différences entre eux et quand les utiliser.
En C ++, les types de données floatet doublesont utilisés pour les valeurs à virgule flottante. Les nombres à virgule flottante sont utilisés pour les valeurs décimales et exponentielles . Par exemple,
// creating float type variables float num1 = 3.0f; float num2 = 3.5f; float num3 = 3E-5f; // 3x10^-5 // creating double type variables double num4 = 3.0; double num5 = 3.5; double num6 = 3E-5; // 3x10^-5
Il faut ajouter le suffixe fou Fà la fin d'une floatvaleur. En effet, le compilateur interprète les valeurs décimales sans le suffixe comme double.
Considérez ce code.
float a = 5.6;
Ici, nous avons attribué une doublevaleur à une floatvariable.
Dans ce cas, 5.6 est converti en floatpar le compilateur automatiquement avant d'être affecté à la variable a. Cela peut entraîner une perte de données. Pour en savoir plus, visitez la page Conversion de type C ++.
Différence entre flotteur et double
| flotte | double |
|---|---|
| Taille: 4 octets | Taille: 8 octets |
| Précision: en général, précision de 7 chiffres décimaux | Précision: en général, précision de 15 chiffres décimaux |
Exemple: 3.56f , 3e5fetc. | Exemple: 3.56 , 3e5etc. |
Remarque: sauf si vous avez une exigence spécifique, utilisez toujours à la doubleplace de float, car les floatvariables peuvent être susceptibles d'introduire des erreurs lorsque vous travaillez avec de grands nombres.
Exemple 1: float et double C ++
#include #include using namespace std; int main() ( // Creating a double type variable double a = 3.912348239293; // Creating a float type variable float b = 3.912348239293f; // Printing the two variables cout << "Double Type Number = " << a << endl; cout << "Float Type Number = " << b << endl; return 0; )
Production
Numéro de type double = 3,91235 Numéro de type flottant = 3,91235
Remarque: Le compilateur utilisé pour cet exemple (compilateur MinGW) autorisé pour 6 chiffres. Ainsi, nos valeurs de variable ont été arrondies et tronquées à 6 chiffres par le compilateur.
setprecision () pour spécifier les points décimaux
Nous pouvons spécifier le nombre de points décimaux à imprimer en coututilisant la setprecision()fonction.
Cette fonction est définie dans le iomanipfichier d' en- tête, qui signifie manipulation d'entrée / sortie .
Exemple 2: Utilisation de setprecision () pour les nombres à virgule flottante
#include #include using namespace std; int main() ( // Creating a double type variable double a = 3.912348239293; // Creating a float type variable float b = 3.912348239293f; // Setting the precision to 12 decimal places cout << setprecision(13); // Printing the two variables cout << "Double Type Number = " << a << endl; cout << "Float Type Number = " << b << endl; return 0; )
Production
Numéro de type double = 3,912348239293 Numéro de type flottant = 3,912348270416
Comme nous pouvons le voir dans l'exemple ci-dessus, nous avons spécifié la précision jusqu'à 13 chiffres.
cout << setprecision(13);
La valeur à virgule flottante que nous avons attribuée à nos variables se compose également de 13 chiffres.
Cependant, étant donné que sa précision ne dépasse floatpas 7 chiffres, il affiche les valeurs de garbage après que sa précision est dépassée.
Notre doublevariable affiche le nombre correct car il a une précision de 15 chiffres, tandis que le nombre lui-même se compose de 13 chiffres.
Comme alternative, nous pouvons spécifier différentes précisions pour différentes variables lors de leur impression.
Exemple 3: différentes précisions pour différentes variables
#include #include using namespace std; int main() ( // Creating a double type variable double a = 3.912348239293; // Creating a float type variable float b = 3.912348239293f; // Setting precision to 11 for double cout << "Double Type Number = " << setprecision(11) << a << endl; // Setting precision to 7 for float cout << "Float Type Number = " << setprecision(7) << b << endl; return 0; )
Production
Numéro de type double = 3,9123482393 Numéro de type flottant = 3,912348
À partir du programme ci-dessus, nous pouvons voir que nous avons défini deux valeurs de précision différentes pour floatet double.
Dans les deux cas, la précision est inférieure aux chiffres réels du nombre. Ainsi, le dernier chiffre est arrondi et le reste est tronqué.
Remarque: Si nous spécifions la précision supérieure à la précision du type de données lui-même (7 pour floatet 15 pour double), le compilateur nous donnera des valeurs de déchets après le dépassement de la limite de précision, comme on peut le voir avec la floatsortie de l' exemple 2 .
Travailler avec des nombres exponentiels
Comme mentionné ci-dessus, floatet doublepeut également être utilisé pour représenter des nombres exponentiels . Par exemple,
// ex = 325 X (10 25) double ex = 325E25;
C ++ produit des nombres exponentiels et des nombres très grands dans un format appelé format scientifique . La variable ex sera sortie dans ce format par défaut car il s'agit d'un très grand nombre.
Afin de forcer C ++ à afficher nos nombres à virgule flottante dans le scientificformat indépendamment de la taille du nombre, nous utilisons le spécificateur de format à l' scientificintérieur de cout.
double num = 3.25; // ex = 325 X (10 25) double ex = 325E25; // using scientific format cout << scientific << num; cout << scientific << ex;
En plus de cela, il existe un autre spécificateur de format appelé fixed, qui affiche les nombres à virgule flottante au format décimal.
Cela revient à afficher des nombres à virgule flottante en n'utilisant que coutsans setprecision(), à l'exception du fait qu'il fixedaffiche des nombres jusqu'à 6 décimales.
Par contre, l'utilisation uniquement coutaffiche les chiffres en fonction du compilateur spécifique (6 chiffres au total dans le cas du compilateur MinGW , y compris les chiffres avant la virgule décimale).
Exemple 4: Formats fixes et scientifiques
#include #include using namespace std; int main() ( // Creating a decimal double type variable double a = 3.912348239293; // Creating an exponential double type variable double ex1 = 325e+2; // Creating a float type variable float b = 3.912348239293f; // Creating an exponential float type variable float ex2 = 325e+2f; // Displaying output with fixed cout << "Displaying Output With fixed:" << endl; cout << "Double Type Number 1 = " << fixed << a << endl; cout << "Double Type Number 2 = " << fixed << ex1 << endl; cout << "Float Type Number 1 = " << fixed << b << endl; cout << "Float Type Number 2 = " << fixed << ex2 << endl; // Displaying output with scientific cout << "Displaying Output With scientific:" << endl; cout << "Double Type Number 1 = " << scientific << a << endl; cout << "Double Type Number 2 = " << scientific << ex1 << endl; cout << "Float Type Number 1 = " << scientific << b << endl; cout << "Float Type Number 2 = " << scientific << ex2 << endl; return 0; )
Production
Displaying Output With fixed: Double Type Number 1 = 3.912348 Double Type Number 2 = 32500.000000 Float Type Number 1 = 3.912348 Float Type Number 2 = 32500.000000 Displaying Output With scientific: Double Type Number 1 = 3.912348e+000 Double Type Number 2 = 3.250000e+004 Float Type Number 1 = 3.912348e+000 Float Type Number 2 = 3.250000e+004
long double
Apart from float and double, there is another data type that can store floating-point numbers. This is known as long double.
It usually occupies a space of 12 bytes (depends on the computer system in use), and its precision is at least the same as double, though most of the time, it is greater than that of double.
long double values should end with L. For example,
// declaring a long double variable long double num_ldb = 2.569L;
Remarque: les types de données à virgule flottante pris en charge par C ++ sont float, doubleet long double. Il n'y a pas long float.
