Constantes et littéraux en C++

Salut les futurs programmeurs ! Aujourd'hui, nous allons entreprendre un voyage passionnant à travers le monde des constantes et littéraux en C++. Ne vous inquiétez pas si ces termes semblent un peu intimidants - d'ici la fin de cette leçon, vous les utiliserez comme un pro ! Mettons-nous à l'eau !

Quelles sont les constantes et les littéraux ?

Avant de rentrer dans les détails, comprenons ce que sont les constantes et les littéraux. Pensez à eux comme les éléments "inaltérables" de votre code - comme le nombre de jours dans une semaine ou la valeur de pi. Ce sont les amis fiables qui restent toujours les mêmes, peu importe ce qui se passe dans votre programme.

Littéraux entiers

Commençons par quelque chose de familier - les nombres ! En C++, lorsque nous écrivons un nombre entier directement dans notre code, nous l'appelons un littéral entier. C'est comme écrire un nombre sur un morceau de papier - simple et direct.

int monAge = 25;
int nombreDePlanetes = 8;
int nombreNegatif = -10;

Dans ces exemples, 25, 8 et -10 sont des littéraux entiers. Ils sont simplement là, être des nombres, sans virgule décimale ou chose fancy.

Mais attendez, il y a plus ! C++ nous permet d'écrire des littéraux entiers dans différents systèmes de numération :

int nombreDecimal = 42;     // Décimal (base 10)
int nombreOctal = 052;      // Octal (base 8) - commence par 0
int nombreHexadecimal = 0x2A;       // Hexadécimal (base 16) - commence par 0x
int nombreBinaire = 0b101010;// Binaire (base 2) - commence par 0b (C++14 et suivants)

Ne vous inquiétez pas si l'octal, l'hexadécimal ou le binaire semblent confus. Pour l'instant, sachez simplement qu'ils sont des moyens différents de représenter le même nombre. C'est comme parler différentes langues - "vingt-cinq", "veinticinco" et "vingt-cinq" signifient toutes la même chose !

Littéraux à virgule flottante

Maintenant, ajoutons quelques points décimaux à la mixture ! Les littéraux à virgule flottante sont des nombres avec des points décimaux ou en notation scientifique.

float pi = 3.14159f;
double nombreAvogadro = 6.022e23;
long double nombreTrèsPrécis = 1.23456789L;

Ici, 3.14159f est un littéral float (notez le 'f' à la fin), 6.022e23 est un littéral double en notation scientifique (e23 signifie ×10^23), et 1.23456789L est un littéral long double (notez le 'L' à la fin).

Littéraux booléens

Les littéraux booléens sont les plus simples de tous - il n'y en a que deux !

bool estIncroyable = true;
bool estEnnuyeux = false;

C'est tout ! Juste true et false. Ils sont comme le "oui" et le "non" du monde de la programmation.

Littéraux de caractères

Les littéraux de caractères représentent des caractères yks et sont entourés de simples quotes.

char premièreInitiale = 'J';
char sautDeLigne = '\n';
char tabulation = '\t';

Les deux derniers exemples montrent des caractères spéciaux : '\n' pour un saut de ligne et '\t' pour une tabulation. Ce sont appelés séquences d'échappement.

Littéraux de chaînes

Les littéraux de chaînes sont des séquences de caractères entourées de doubles quotes.

std::string salutation = "Bonjour, le monde !";
std::string citation = "Être ou ne pas être, telle est la question.";

Souvenez-vous, les chaînes utilisent des doubles quotes, tandis que les caractères yks utilisent des quotes simples !

Définir des constantes

Maintenant que nous connaissons les littéraux, voyons comment nous pouvons les utiliser pour créer des constantes - des valeurs qui ne changent pas tout au long de notre programme.

Le préprocesseur #define

Une façon de définir des constantes est d'utiliser la directive de préprocesseur #define :

#define PI 3.14159
#define MAX_ETUDIANTS 30

// Utilisation
double aireCercle = PI * rayon * rayon;
if (nombreEtudiants > MAX_ETUDIANTS) {
std::cout << "La classe est pleine !";
}

La directive #define dit au compilateur de remplacer chaque occurrence de PI par 3.14159 et MAX_ETUDIANTS par 30 avant de compiler le code.

Le mot-clé const

Une manière plus moderne et préférée de définir des constantes est d'utiliser le mot-clé const :

const double PI = 3.14159;
const int MAX_ETUDIANTS = 30;

// L'utilisation est la même que avec #define

Le mot-clé const dit au compilateur que ces variables ne peuvent pas être modifiées après l'initialisation.

Mettre tout ensemble

Terminons avec un petit programme qui utilise diverses constantes et littéraux :

#include <iostream>
#include <string>

#define NOM_JEU "Aventure en C++"

int main() {
const int MAX_LEVEL = 100;
const double MULTIPLIER_XP = 1.5;

int niveauActuel = 1;
double xpActuelle = 0.0;
bool aTermineTutorial = false;
char rangJoueur = 'D';
std::string nomJoueur = "Newbie";

std::cout << "Bienvenue dans " << NOM_JEU << " !" << std::endl;
std::cout << "Joueur : " << nomJoueur << std::endl;
std::cout << "Niveau : " << niveauActuel << "/" << MAX_LEVEL << std::endl;
std::cout << "XP : " << xpActuelle << std::endl;
std::cout << "Rang : " << rangJoueur << std::endl;
std::cout << "Tutorial terminé : " << (aTermineTutorial ? "Oui" : "Non") << std::endl;

return 0;
}

Ce programme utilise tous les types de constantes et littéraux que nous avons discutés. Il définit un nom de jeu avec #define, fixe un niveau maximum et un multiplicateur d'XP avec const, et utilise divers littéraux pour initialiser les statistiques du joueur.

Conclusion

Félicitations ! Vous avez刚刚 fait vos premiers pas dans le monde des constantes et littéraux en C++. Souvenez-vous, ceux-ci sont les briques de votre programme - les valeurs inchangeables que vous utiliserez pour créer des choses incroyables. Comme vous continuez votre voyage en programmation, vous vous retrouverez à utiliser ces concepts tous les jours. Continuez à pratiquer, restez curieux, et bon codage !

Type de littéral	Exemple	Description
Entier	42, -10, 0, 1000	Nombres entiers
Octal	052, 077	Nombres en base-8 (commencent par 0)
Hexadécimal	0x2A, 0xFF	Nombres en base-16 (commencent par 0x)
Binaire	0b101010	Nombres en base-2 (commencent par 0b, C++14 et suivants)
à Virgule Flottante	3.14, 2.5f, 1e10	Nombres avec des points décimaux ou en notation scientifique
Booléen	true, false	Valeurs logiques
Caractère	'A', '\n', '\t'	Caractères yks ou séquences d'échappement
Chaîne	"Hello", "C++"	Séquences de caractères

Credits: Image by storyset