0Pricing
C++ Academy · Leçon

Types entiers et à virgule flottante

Choisir le type numérique approprié en comprenant les tailles, les plages de valeurs et les compromis liés à la précision

Types entiers et à virgule flottante est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Deux univers numériques

C++ possède deux familles de types numériques : les entiers (sans fractions, exacts) et les types à virgule flottante (approximatifs, avec fractions). Choisissez la famille adaptée à votre besoin.

Types entiers

Types entiers intégrés et tailles courantes sur les systèmes 64 bits :

  • char — 1 octet
  • short — 2 octets
  • int — 4 octets
  • long — 4 ou 8 octets
  • long long — 8 octets

Signés et non signés

Ajoutez unsigned pour supprimer la plage des valeurs négatives. L'arithmétique non signée revient à zéro modulo 2^N — parfois utile, mais souvent source d'erreurs.

unsigned int u = 0;
u -= 1;  // wraps around to 4,294,967,295

Entiers de largeur fixe

Utilisez les types de <cstdint> lorsque vous avez besoin de tailles exactes — pour les protocoles, les formats de fichiers ou la portabilité entre plateformes.

#include <cstdint>
int8_t   tiny  = 100;
int32_t  word  = 100000;
int64_t  big   = 1LL << 40;
uint64_t huge  = 18446744073709551615ULL;

Types à virgule flottante

Trois types à virgule flottante de précision croissante :

  • float — 32 bits, environ 7 chiffres décimaux
  • double — 64 bits, environ 15 chiffres décimaux
  • long double — généralement 80 ou 128 bits

Format IEEE 754

Les nombres flottants suivent la norme IEEE 754 : signe, exposant, mantisse. Ils peuvent représenter des valeurs très grandes et très petites, mais pas exactement.

Pièges des nombres à virgule flottante

La plupart des nombres décimaux ne peuvent pas être représentés exactement en binaire. 0.1 + 0.2 n'est pas exactement égal à 0.3.

double sum = 0.1 + 0.2;
std::cout << (sum == 0.3);   // false on most systems
std::cout << sum;            // 0.3 but printed approximately

Comparer les nombres flottants en toute sécurité

Ne comparez jamais les nombres flottants avec ==. Comparez-les dans une petite tolérance (epsilon).

bool approxEqual(double a, double b, double eps = 1e-9) {
    return std::abs(a - b) < eps;
}

Valeurs flottantes spéciales

Les nombres flottants possèdent trois valeurs spéciales : NaN (pas un nombre), +inf et -inf. Utilisez les prédicats de <cmath> pour les détecter.

#include <cmath>
double x = std::sqrt(-1.0);
if (std::isnan(x)) std::cout << "Not a number";
if (std::isinf(x)) std::cout << "Infinity";

Quand utiliser chaque type

Choisissez selon le domaine :

  • Comptages et index → int ou size_t
  • Calculs scientifiques ou graphiques → double
  • Argent → jamais double ! Utilisez des entiers mis à l'échelle (en centimes) ou une bibliothèque décimale

Les tailles des types varient selon la plateforme

La norme ne garantit que des tailles minimales. int peut occuper 16, 32 ou 64 bits. Pour assurer la portabilité, utilisez les types de largeur fixe de <cstdint> dans les structures de données.

Vérification rapide

Quel type devez-vous utiliser pour représenter précisément des valeurs monétaires ?

Récapitulatif

Les entiers sont exacts ; les nombres flottants sont approximatifs. Choisissez int ou des entiers de largeur fixe pour les comptages, double pour les calculs scientifiques, et n'utilisez jamais de nombres flottants pour l'argent. Comparez les nombres flottants avec une tolérance, jamais avec ==.

Questions Fréquemment Posées

La leçon « Types entiers et à virgule flottante » est-elle gratuite ?

Oui — le texte complet de « Types entiers et à virgule flottante » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Types entiers et à virgule flottante » ?

Choisir le type numérique approprié en comprenant les tailles, les plages de valeurs et les compromis liés à la précision Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Types entiers et à virgule flottante » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Types entiers et à virgule flottante
  2. L’en-tête cmath : pow, sqrt, abs, round
  3. Nombres aléatoires avec l’en-tête random
  4. Limites numériques et comportement en cas de dépassement
← Retour à C++ Academy