Variables et types en C++

Introduction

Dans ce laboratoire, vous allez apprendre les variables et les types en C++. Vous allez apprendre à définir des variables et à utiliser différents types de variables.

Aperçu du contenu

Les programmes informatiques manipulent (ou traitent) des données. Une variable est utilisée pour stocker une donnée à des fins de traitement. Elle est appelée variable car vous pouvez modifier la valeur stockée.

• Variables
• Identificateurs
• Déclaration de variables
• Constantes
• Expressions
• Affectation
• Types de base
• Littéraux pour les types de base et les chaînes de caractères

Variables

Une variable est un emplacement de stockage nommé qui stocke une valeur d'un type de données particulier. En d'autres termes, une variable a un nom, un type et stocke une valeur.

• Une variable a un nom (ou identificateur), par exemple radius, area, age, height. Le nom est nécessaire pour identifier de manière unique chaque variable, afin d'attribuer une valeur à la variable et de récupérer la valeur stockée.
• Une variable a un type tel que int ou double.
• Une variable peut stocker une valeur de ce type particulier. Une variable est associée à un type et ne peut stocker que des valeurs du type particulier.
• Le type détermine la taille et la disposition des données, la plage de ses valeurs et l'ensemble des opérations qui peuvent être appliquées.

Le diagramme suivant illustre deux types de variables : int et double. Une variable int stocke un entier (nombre entier). Une variable double stocke un nombre réel.

Identificateurs

Un identificateur est nécessaire pour nommer une variable (ou toute autre entité telle qu'une fonction ou une classe). C++ impose les règles suivantes pour les identificateurs :

• Un identificateur est une séquence de caractères composée de lettres majuscules et minuscules (a-z, A-Z), de chiffres (0-9) et du tiret bas "_".
• Les espaces blancs (espace, tabulation, saut de ligne) et autres caractères spéciaux (tels que +, -, *, /, '@', etc.) ne sont pas autorisés.
• Un identificateur doit commencer par une lettre ou un tiret bas. Il ne peut pas commencer par un chiffre. Les identificateurs commençant par un tiret bas sont généralement réservés à l'utilisation système.
• Un identificateur ne peut pas être un mot clé réservé ou un littéral réservé (par exemple, int, double, if, else, for).
• Les identificateurs sont sensibles à la casse. Un rose n'est PAS un Rose et n'est PAS un ROSE.

Convention de nommage des variables

Le nom d'une variable est un nom de substantif, ou une locution nominale composée de plusieurs mots. Le premier mot est en minuscules, tandis que les mots suivants commencent par une majuscule, sans espace entre les mots. Par exemple, thefontSize, roomNumber, xMax et thisIsAVeryLongVariableName, qui est connue sous le nom de camel-case.

Recommandations

1. Il est important de choisir un nom qui soit auto-déscriptif et reflète étroitement la signification de la variable, par exemple, numberOfStudents ou numStudents.
2. N'utilisez pas de noms sans sens comme a, b, c, d, i, j, k, i1, j99. Évitez les noms à une seule lettre, sauf s'ils sont des noms courants comme x, y, z pour les coordonnées, i pour l'indice.
3. Il est parfaitement acceptable d'utiliser des noms longs de 30 caractères environ pour s'assurer que le nom reflète précisément sa signification.
4. Utilisez les noms de substantifs singuliers et pluriels avec prudence pour différencier les variables singulières et pluriels. Par exemple, utilisez la variable row pour désigner un seul numéro de ligne et rows pour désigner plusieurs lignes.

Déclaration de variable

Vous devez d'abord déclarer son nom et son type avant de l'utiliser, selon l'une des syntaxes suivantes :

Par exemple

int mark1;           // Déclarer une variable int appelée mark1
mark1 = 76;          // Utiliser mark1
int mark2;           // Déclarer la variable int mark2
mark2 = mark1 + 10;  // Utiliser mark2 et mark1
double average;      // Déclarer la variable double average
average = (mark1 + mark2) / 2.0;   // Utiliser average, mark1 et mark2
int mark1;           // Erreur : déclarer deux fois
mark2 = "Hello";     // Erreur : assigner une valeur d'un type différent
int number;             // Déclarée mais non initialisée
cout << number << endl; // Utilisée avant d'être initialisée, sans avertissement/erreur, mais résultat inattendu.

Notez que :

• En C++, vous devez déclarer le nom d'une variable avant de pouvoir l'utiliser.
• C++ est un langage "fortement typé". Une variable a un type. Une fois le type d'une variable déclaré, elle ne peut stocker que des valeurs appartenant à ce type particulier.
• Chaque variable ne peut être déclarée qu'une fois.
• En C++, vous pouvez déclarer une variable n'importe où dans le programme, tant qu'elle est déclarée avant d'être utilisée.
• Le type d'une variable ne peut pas être changé dans le programme.
• Une variable qui est juste déclarée mais non initialisée contient des données inappropriées. C/C++ n'émettra aucun avertissement/erreur si vous utilisez une variable avant de l'initialiser - ce qui peut entraîner des résultats inattendus.

Constantes (const)

Les constantes sont des variables non modifiables, déclarées avec le mot clé const. Leur valeur ne peut pas être modifiée pendant l'exécution du programme. De plus, const doit être initialisée lors de la déclaration. Par exemple :

const double PI = 3.1415926;  // Nécessite une initialisation

Convention de nommage des constantes : Utiliser des mots en majuscules, joints par des tirets bas. Par exemple, MIN_VALUE.

Expressions

Une expression est une combinaison d'opérateurs (tels que '+', '-', '*', '/') et d'opérandes (variables ou valeurs littérales), qui peut être évaluée pour produire une seule valeur d'un certain type. Par exemple :

1 + 2 * 3           // donne un int 7

int sum, number;
sum + number        // évalué en une valeur de type int

double principal, interestRate;
principal * (1 + interestRate)  // évalué en une valeur de type double

Affectation (=)

Une instruction d'affectation :

1. affecte une valeur littérale (du côté droit) à une variable (du côté gauche) ; ou
2. évalue une expression (du côté droit) et affecte la valeur résultante à une variable (du côté gauche).

Le côté droit doit être une valeur ; et le côté gauche doit être une variable (ou une adresse mémoire).

La syntaxe de l'instruction d'affectation est la suivante :

L'instruction d'affectation doit être interprétée de la manière suivante : L'expression du côté droit (RHS) est d'abord évaluée pour produire une valeur résultante (appelée rvalue ou valeur droite). La rvalue est ensuite affectée à la variable du côté gauche (LHS) (ou lvalue, qui est un emplacement qui peut contenir une rvalue).

Types de base

Le tableau ci-dessous montre la taille, la valeur minimale et maximale typique des types primitifs. Encore une fois, notez que les tailles dépendent de l'implémentation.

L'opérateur sizeof

C/C++ fournit un opérateur unaire sizeof pour obtenir la taille de l'opérande (en octets). Le programme suivant utilise l'opérateur sizeof pour afficher la taille des types fondamentaux (enregistrez le code suivant dans test.cpp dans /home/labex/Code).

/*
 * Affiche la taille des types fondamentaux.
 */
#include <iostream>
using namespace std;

int main() {
   cout << "sizeof(char) est " << sizeof(char) << " octets " << endl;
   cout << "sizeof(short) est " << sizeof(short) << " octets " << endl;
   cout << "sizeof(int) est " << sizeof(int) << " octets " << endl;
   cout << "sizeof(long) est " << sizeof(long) << " octets " << endl;
   cout << "sizeof(long long) est " << sizeof(long long) << " octets " << endl;
   cout << "sizeof(float) est " << sizeof(float) << " octets " << endl;
   cout << "sizeof(double) est " << sizeof(double) << " octets " << endl;
   cout << "sizeof(long double) est " << sizeof(long double) << " octets " << endl;
   cout << "sizeof(bool) est " << sizeof(bool) << " octets " << endl;
   return 0;
}

Sortie :

sizeof(char) est 1 octets
sizeof(short) est 2 octets
sizeof(int) est 4 octets
sizeof(long) est 4 octets
sizeof(long long) est 8 octets
sizeof(float) est 4 octets
sizeof(double) est 8 octets
sizeof(long double) est 12 octets
sizeof(bool) est 1 octets

L'instruction typedef

Taper unsigned int plusieurs fois peut devenir ennuyeux. L'instruction typedef peut être utilisée pour créer un nouveau nom pour un type existant. Par exemple, vous pouvez créer un nouveau type appelé "uint" pour "unsigned int" comme suit. Vous devriez placer le typedef immédiatement après #include. Utilisez typedef avec soin car cela rend le programme difficile à lire et à comprendre.

typedef unsigned int uint;

Beaucoup de compilateurs C/C++ définissent un type appelé size_t, qui est un typedef de unsigned int.

typedef unsigned int size_t;

Constantes pour les types de base et les chaînes de caractères

Littéraux entiers

Un nombre entier, tel que 123 et -456, est traité comme un int par défaut. Par exemple :

int number = -123;
int sum = 4567;

En plus des entiers décimaux de base 10 par défaut, vous pouvez utiliser un préfixe '0x' pour une valeur en hexadécimal et le préfixe '0b' pour une valeur binaire (dans certains compilateurs), par exemple :

int number1 = 1234;       // Décimal
int number2 = 01234;      // Octal 1234, Décimal 2322
int number3 = 0x1abc;     // Hexadécimal 1ABC, Décimal 15274
int number4 = 0b10001001; // Binaire (peut ne pas fonctionner dans certains compilateurs)

Un littéral long est identifié par un suffixe 'L' ou 'l' (évitez le minuscule, qui peut être confondu avec le nombre un). Un long long int est identifié par un suffixe 'LL'. Vous pouvez également utiliser le suffixe 'U' pour unsigned int, 'UL' pour unsigned long et 'ULL' pour unsigned long long int. Par exemple :

long number = 12345678L;     // Suffixe 'L' pour long
long sum = 123;              // int 123 est automatiquement converti en long 123L
long long bigNumber = 987654321LL;  // Nécessite le suffixe 'LL' pour long long int

Aucun suffixe n'est nécessaire pour les littéraux short. Mais vous ne pouvez utiliser que des valeurs entières dans la plage autorisée. Par exemple :

short midSizeNumber = -12345;

Littéraux à virgule flottante

Un nombre avec une virgule, tel que 55.66 et -33.44, est traité comme un double par défaut. Vous pouvez également les exprimer en notation scientifique, par exemple 1.2e3, -5.5E-6, où e ou E représente l'exposant en puissance de 10. Vous pouvez précéder la partie fractionnaire ou l'exposant d'un signe plus (+) ou moins (-). L'exposant doit être un entier.

Vous DEVEZ utiliser un suffixe 'f' ou 'F' pour les littéraux float, par exemple -1.2345F. Par exemple :

float average = 55.66;      // Erreur! Le côté droit est un double. Nécessite le suffixe 'f' pour float.
float average = 55.66f;

Utilisez le suffixe 'L' (ou 'l') pour long double.

Littéraux booléens

Il n'y a que deux littéraux bool, soit true et false. Par exemple :

bool done = true;
bool gameOver = false;
int i;
if (i == 9) {   // Renvoie soit true soit false
  ......
}

Littéraux de caractères

Un littéral de char imprimable est écrit en entourant le caractère d'une paire de apostrophes simples, par exemple 'z', '$' et '9'. En C++, les caractères sont représentés à l'aide du code ASCII sur 8 bits et peuvent être traités comme des entiers signés sur 8 bits dans les opérations arithmétiques. En d'autres termes, char et l'entier signé sur 8 bits sont interchangeables. Vous pouvez également assigner un entier dans la plage [-128, 127] à une variable char ; et [0, 255] à un unsigned char. Par exemple :

char letter = 'a';             // Identique à 97
char anotherLetter = 98;       // Identique à la lettre 'b'
cout << letter << endl;        // Affiche 'a'
cout << anotherLetter << endl; // Affiche 'b' au lieu du nombre
anotherLetter += 2;            // 100 ou 'd'
cout << anotherLetter << endl; // Affiche 'd'
cout << (int)anotherLetter << endl;  // Affiche 100

Littéraux de chaînes de caractères

Un littéral de String est composé de zéro ou plusieurs caractères entourés d'une paire de guillemets doubles, par exemple "Hello, world!", "The sum is ", "". Par exemple :

String directionMsg = "Turn Right";
String greetingMsg = "Hello";
String statusMsg = "";             // Chaîne vide

Exemple (Littéraux)

/* Test des types primitifs */
#include <iostream>
using namespace std;

int main() {
   char gender ='m';             // char est entre apostrophes simples
   bool isMarried = true;         // true(non nul) ou false(0)
   unsigned short numChildren = 8; // [0, 255]
   short yearOfBirth = 1945;      // [-32767, 32768]
   unsigned int salary = 88000;   // [0, 4294967295]
   double weight = 88.88;       // Avec partie fractionnaire
   float gpa = 3.88f;           // Nécessite le suffixe 'f' pour float

   // "cout <<" peut être utilisé pour afficher la valeur de n'importe quel type
   cout << "Genre est " << gender << endl;
   cout << "Est marié est " << isMarried << endl;
   cout << "Nombre d'enfants est " << numChildren << endl;
   cout << "Année de naissance est " << yearOfBirth << endl;
   cout << "Salaire est " << salary << endl;
   cout << "Poids est " << weight << endl;
   cout << "Moyenne est " << gpa << endl;
   return 0;
}

Sortie :

Genre est m
Est marié est 1    // true
Nombre d'enfants est 8
Année de naissance est 1945
Salaire est 88000
Poids est 88.88
Moyenne est 3.88

Résumé

Dans cette partie, nous avons présenté plusieurs types fondamentaux. Vous devriez savoir comment représenter une variable et comment opérer sur elle. Gardez à l'esprit quelle est la taille de chaque type en mémoire et la plage de chaque type.