Variables et Types de Données en C++

Introduction aux variables en C++

Les variables et les types de données sont la base de tout programme. Une variable, c’est comme une boîte : elle contient une valeur que ton programme peut utiliser et modifier. En C++, comprendre les types de données et savoir choisir le bon type est essentiel pour écrire du code efficace et clair.

Dans cet article, on va voir :

Ce que sont les variables et comment les déclarer.
Les différents types de données en C++.
Les bonnes pratiques pour les utiliser.
Pour en savoir plus sur les opérateurs en C++.
Découvrez comment utiliser les pointeurs, tableaux et vecteurs pour manipuler les données efficacement.

Qu’est-ce qu’une variable en C++ ?

En programmation, une variable est un espace mémoire réservé pour stocker une valeur. Elle a :

Un nom : Pour identifier cette variable dans ton code.
Un type : Pour définir le genre de données qu’elle peut contenir.
Une valeur : Ce que la variable contient à un moment donné.

Exemple de déclaration :

int age = 25; // Une variable appelée "age" contenant le nombre 25

Les types de données en C++

En C++, chaque variable doit avoir un type défini. Voici les principaux types :

Types numériques

int : Entier (exemple : 42).
float : Nombre décimal, précision simple (exemple : 3.14).
double : Nombre décimal, précision double (exemple : 2.718281828).

int nombreEntier = 10;
float nombreDecimal = 3.14f;
double grandePrecision = 2.71828;

Type caractère

char : Contient un seul caractère. Utilise des guillemets simples.

char initiale = 'A';

Type booléen

bool : Contient true ou false.

bool estVrai = true;

Type vide

void : Utilisé pour indiquer qu'une fonction ne retourne aucune valeur.

void afficherMessage() {
    std::cout << "Bonjour, monde !" << std::endl;
}

Modificateurs de type

Les types peuvent être modifiés pour ajuster leur taille ou leur signe :

unsigned : Pour des valeurs positives uniquement.
long : Pour étendre la taille (exemple : long long pour les grands entiers).

Note importante : Par défaut, si vous déclarez une variable int sans préciser de modificateur, elle est signed. Cela signifie qu'elle peut contenir des valeurs négatives et positives. Pour déclarer une variable qui ne doit contenir que des valeurs positives, utilisez le modificateur unsigned.

unsigned int nombrePositif = 50;
long long grandNombre = 9223372036854775807;

// Par défaut, 'int' est signed :
int nombreSigned = -10; // Équivalent à signed int

Déclarer et initialiser des variables

Déclaration simple

Vous pouvez déclarer une variable sans lui attribuer de valeur immédiatement :

int nombre;
nombre = 42; // Affectation plus tard

Initialisation directe

C’est recommandé pour éviter les erreurs :

int age = 25; // Initialisation au moment de la déclaration

Constantes et variables immuables

Pour déclarer une valeur qui ne doit pas changer, utilise le mot-clé const :

const float PI = 3.14;

Une tentative de modifier PI après sa déclaration provoquera une erreur.

Les bonnes pratiques

Choisir le bon type : Prends un type adapté à la donnée (par exemple, pas de double pour un compteur).

int compteurDeVentes = 100;

Initialise toujours tes variables : Ne laisse jamais une variable sans valeur initiale. En C++, une variable non initialisée peut contenir n’importe quoi.

Exemples pratiques

Exemple 1 : Calcul d’aire d’un rectangle

#include <iostream>

int main() {
int largeur = 5; // en mètres
int longueur = 10; // en mètres
int aire = largeur * longueur;

    std::cout << "L'aire du rectangle est de " << aire << " m²" << std::endl;
    return 0;
}

Exemple 2 : Types booléens

#include <iostream>

int main() {
bool estActif = true;

    if (estActif) {
        std::cout << "Le programme est actif !" << std::endl;
    } else {
        std::cout << "Le programme est inactif." << std::endl;
    }

    return 0;
}

Exemple 3 : Utilisation de constantes

#include <iostream>

int main() {
const float PI = 3.14159;
float rayon = 7.0;
float circonference = 2 * PI * rayon;

    std::cout << "La circonférence du cercle est de " << circonference << std::endl;

    return 0;
}

Quiz : Testez vos connaissances

Vérifiez votre compréhension des notions abordées avec ces questions :

Quel type de donnée utiliseriez-vous pour stocker un nombre entier ?
a) float
b) int
c) char
Quelle est la différence entre signed et unsigned pour un type int ?
a) signed permet uniquement des valeurs positives.
b) unsigned permet uniquement des valeurs positives.
c) Il n’y a aucune différence.
Quelle est la bonne syntaxe pour déclarer une constante en C++ ?
a) const int PI = 3.14;
b) int const PI = 3.14;
c) Les deux sont correctes.
Que se passe-t-il si vous utilisez une variable non initialisée en C++ ?
a) Elle contient une valeur par défaut de 0.
b) Elle contient une valeur aléatoire.
c) Le programme ne compile pas.
Quelle est la sortie du code suivant ?
```
int a = 5;
unsigned int b = 10;
std::cout << a - b << std::endl;
```
a) -5
b) Une erreur de compilation.
c) Une grande valeur positive.

Réponses et explications

Réponse : b)
Le type int est utilisé pour stocker des nombres entiers. float est pour les nombres décimaux, et char pour les caractères.
Réponse : b)
unsigned permet uniquement des valeurs positives, tandis que signed (par défaut) permet des valeurs positives et négatives.
Réponse : c)
Les deux syntaxes const int PI = 3.14; et int const PI = 3.14; sont correctes pour déclarer une constante.
Réponse : b)
Une variable non initialisée en C++ contient une valeur aléatoire, ce qui peut entraîner des comportements imprévisibles.
Réponse : c)
La soustraction entre un int négatif et un unsigned int peut entraîner un dépassement de capacité, produisant une grande valeur positive.

Ce qu'il faut retenir au sujet des variables en C++

Les variables et les types de données sont essentiels pour écrire un code clair, efficace et robuste.
Choisissez un type de donnée adapté à la valeur que vous souhaitez stocker.
Donnez des noms explicites à vos variables pour améliorer la lisibilité du code.
Initialisez toujours vos variables pour éviter des comportements imprévisibles.
Ces concepts sont la base pour structurer des programmes fiables.

Dans le prochain article, nous explorerons :

Les conditions et boucles.
La gestion des adresses mémoire.