Variables et types de données en C++ : Guide expert sur int, double, char, string, bool

Les variables en C++

En C++, une variable est un emplacement de stockage nommé qui permet au programmeur de conserver et manipuler des données. Chaque variable possède un type explicite qui détermine son empreinte mémoire, sa plage de valeurs autorisées et les opérations qui peuvent être effectuées sur elle.

Ce tutoriel couvre :

• Les variables en C++
• Les types de variables de base
• Les règles de déclaration
• La hiérarchie des types de données
• Les identifiants et conventions de nommage
• Le qualificateur const
• Les règles de portée
• Conversion de type implicite et explicite
• Les variables register
• Commentaires et séquences d'échappement

Types de base des variables en C++

int – Nombres entiers sans partie fractionnaire ou exponentielle (ex. : 120, -90).

double – Nombres à virgule flottante à double précision (ex. : 11.22, 2.345).

char – Caractères simples entre guillemets simples (ex. : 'a', 'm', 'F', 'P', '}').

float – Valeurs à virgule flottante à simple précision (ex. : 1.3, 2.6).

string – Séquence de caractères entre guillemets doubles (ex. : "Comment allez-vous ?").

bool – Contient soit true soit false.

Règles de déclaration des variables en C++

• Les noms peuvent contenir des lettres, des chiffres et des tirets bas.
• Ils ne peuvent pas commencer par un chiffre.
• La convention favorise les minuscules ; les majuscules au début désignent généralement des constantes.
• Les noms ne doivent pas entrer en conflit avec les mots-clés du langage (ex. : int).
• Commencer par un tiret bas est autorisé mais déconseillé en raison des règles d'identifiants réservés.

Types de données des variables en C++

C++ offre un riche ensemble de types primitifs. Le type void n'a pas de valeur et est généralement utilisé comme type de retour d'une fonction qui ne renvoie rien.

Les types arithmétiques se divisent en deux catégories :

1. Types à virgule flottante : float (≈32 bits), double (≈64 bits) et long double (≈96/128 bits selon l'implémentation).
2. Types entiers : entiers, caractères et bool. Les types entiers peuvent être signés ou non signés.

Les types signés représentent des valeurs négatives, zéro et positives. Par exemple, un char signé sur 8 bits va de –127 à 127.

Les types non signés ne contiennent que des valeurs non négatives. Un char non signé sur 8 bits va de 0 à 255.

Noms de variables ou identifiants

Les identifiants peuvent contenir des lettres, des chiffres et des tirets bas. Leur longueur est illimitée et ils sont sensibles à la casse :

int guru99, gurU99, GuRu99, GURU99;

Les mots-clés réservés ne peuvent pas être réutilisés comme identifiants. L'adoption de conventions de nommage claires améliore la lisibilité : utilisez des minuscules pour les variables, camelCase ou snake_case pour les noms composés, et mettez en majuscule les noms de classes.

Exemples de déclaration et définition

int a = 5; 
int b; 
char c = 'A'; 
int a, b; 
a = b = 1000; 
int a(5); 
int b{5};

Qualificateur const en C++

Utilisez const lorsqu'une valeur doit rester inchangée après l'initialisation :

const int bufSize = 512; // taille du tampon d'entrée

Une variable const doit être initialisée ; sinon le compilateur émet une erreur.

const int i = get_size(); // OK : initialisation à l'exécution
const int j = 42; // OK : initialisation à la compilation
const int k; // erreur : const non initialisé
const int i = 42; 
const int ci = i; // OK : copie de i

Portée des variables en C++

La portée définit où un nom est visible. Les variables sont accessibles depuis leur point de déclaration jusqu'à la fin du bloc englobant.

#include <iostream>
int main() {
    int sum = 0;
    for (int val = 1; val <= 10; ++val)
        sum += val;
    std::cout << "Somme de 1 à 10 inclus est " << sum << std::endl;
    return 0;
}

• main a une portée globale.
• sum a une portée de bloc dans main.
• val a une portée locale dans la boucle for.

Portée imbriquée

#include <iostream>
using namespace std;
int reused = 42; // portée globale
int main() {
    int unique = 0; // portée de bloc
    cout << reused << " " << unique << endl; // 42 0
    int reused = 0; // réutilisation locale masque le global
    cout << reused << " " << unique << endl; // 0 0
    cout << ::reused << " " << unique << endl; // 42 0
    return 0;
}

Conversion de type de variable

C++ effectue des conversions implicites sous certaines conditions. Règles clés :

• Non-bool vers bool : 0 devient false ; toute autre valeur devient true.

  bool b = 42; // b est true

• bool vers arithmétique : true devient 1, false devient 0.

  bool b = true; int i = b; // i est 1

• Flottant vers entier : tronque vers zéro.

  int i = 3.14; // i est 3

• Entier vers flottant : la partie fractionnaire est perdue.

  int i = 3; double pi = i; // pi est 3.0

• Débordement non signé : la valeur s'enroule modulo la base.

  unsigned char c = -1; // 255 sur des char 8 bits

• Débordement signé : comportement indéfini.

Lors du mélange d'entiers signés et non signés, les valeurs signées négatives peuvent se convertir inattendument en grandes valeurs non signées.

Variables register

Utilisez le mot-clé register pour suggérer qu'une variable fréquemment accédée soit stockée dans un registre CPU. Les compilateurs modernes ignorent généralement cet indicateur, effectuant leurs propres optimisations.

register int i;

Commentaires

Les commentaires sont ignorés par le compilateur et servent à documenter le code :

• Une ligne – commence par //.
• Multi-lignes – délimités par /* ... */.

/* Ceci est un commentaire */
/* Les commentaires C++ peuvent aussi
   s'étendre sur plusieurs lignes */

Séquences d'échappement

Les séquences d'échappement représentent des caractères non imprimables ou spéciaux :

Échappement	Description
\n	Nouvelle ligne
\t	Tabulation horizontale
\\	Antislash
\b	Retour arrière
\r	Retour chariot
\v	Tabulation verticale
\f	Saut de page
\a	Alerte (bip)
\"	Guillemet double
\'	Guillemet simple
\?	Point d'interrogation

cout << '\n'; // nouvelle ligne
cout << "\tguru99!\n"; // tab + texte + nouvelle ligne

Les séquences généralisées utilisent des valeurs hexadécimales ou octales :

\7 // bip
\12 // nouvelle ligne
\40 // espace
\x4D // 'M'

Résumé

• Les variables fournissent un stockage nommé et sont typées.
• Types primaires : int, double, char, float, string, bool.
• La portée définit la visibilité ; les portées imbriquées peuvent masquer des noms.
• Conversions implicites et explicites existent mais doivent être utilisées avec précaution.
• Les indications register peuvent améliorer les performances mais sont consultatives.
• Commentaires et séquences d'échappement aident la lisibilité et la sortie correcte.