Types de Données Numériques

Nombres entiers

Les types de données entiers sont les plus couramment utilisés pour représenter des nombres entiers. Le type de données int peut contenir des valeurs dans la plage de -2,147,483,648 à 2,147,483,647.

main


              12345678910
            
#include <iostream>

int main()
{ 
	int goodNumber = 12;
	int tooLarge = 2147483648;

    std::cout << "Printing goodNumber: " << goodNumber << std::endl;
	std::cout << "Printing tooLarge: " << tooLarge << std::endl;
}

Cela se produit parce que lorsque vous déclarez une variable int, elle alloue précisément 4 octets de la mémoire de votre PC. Et les nombres supérieurs à 2147483647 (ou inférieurs à -2147483648) ne tiennent pas dans ces 4 octets. Heureusement, d'autres types de données disponibles peuvent vous allouer plus (ou moins) d'espace selon vos besoins. Voici le tableau :

Data Type	Range	Size
`short`	-32,768 to 32,767	2 bytes
`int`	-2,147,483,648 to 2,147,483,647	4 bytes
`long`	-9223372036854775808 to 9223372036854775807	8 bytes

Ainsi, vous pouvez utiliser long pour stocker de grands nombres (par exemple, la population mondiale). Vous pouvez également utiliser short si vous êtes certain(e) que votre nombre ne dépassera pas la plage de -32,768 à 32,767 (par exemple, pour stocker l'âge d'un utilisateur). L'utilisation de short occupe moins d'espace mémoire.

main


              123456789101112
            
#include <iostream>

int main()
{ 
	short age = 22;
	int likes = 143200;
	long population = 8200000000;

	std::cout << "Age: " << age << std::endl;
    std::cout << "Likes: " << likes << std::endl;
    std::cout << "World's population: " << population << std::endl;
}

Remarque

Faites attention au type de données que vous sélectionnez. Si la plage d'un type est dépassée, le compilateur C++ ne vous avertira pas, et vous pourriez recevoir une valeur inattendue sans aucune indication d'erreur.

Nombres à virgule flottante

Les types de données ci-dessus sont conçus pour stocker des nombres entiers. Si nous essayions d'assigner 1.6 à l'un d'eux, voici ce que nous obtiendrions:

main


              12345678
            
#include <iostream>

int main()
{
    // Change the data type to `float` o `double`
	int num = 1.6;
    std::cout << num << std::endl;
}

Le type int tronque la partie décimale d'un nombre. Ce comportement est le même pour les types short et long. Pour stocker des nombres à virgule (décimaux)**, vous devriez utiliser soit le type float soit double.

Type de données	Précision	Taille
`float`	7 chiffres décimaux	4 octets
`double`	15 chiffres décimaux	8 octets

Voici un exemple d'utilisation de double pour stocker 1.6.

main


              12345678910
            
#include <iostream>

int main()
{  
	float floatNum = 123.45678;
	double doubleNum = 123.45678;

    std::cout << "using float:" << floatNum - 123 << std::endl; 
    std::cout << "using double:" << doubleNum - 123 << std::endl; 
}

Note

Étant donné que le type float ne possède qu'une précision de sept chiffres, le nombre 123.456789 dépasse déjà cette limite. Cela peut entraîner des résultats inexacts (comme le montre l'exemple ci-dessous). Il est donc préférable d'utiliser double par défaut, à moins d'être certain que la précision de float soit suffisante.

Évidemment, vous pouvez utiliser float ou double pour stocker des nombres entiers, car il s'agit de nombres décimaux dont la partie décimale est égale à 0. Toutefois, par bonne pratique, si une variable stocke des valeurs qui ne peuvent être que des nombres entiers (par exemple, population ou likes), short/int/long devraient être utilisés.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 3