Les variables et les types

L’utilité des programmes « Hello World » présentés dans le chapitre précédent est plutôt discutable. Nous avons dû écrire plusieurs lignes de code, les compiler, puis exécuter le programme résultant, uniquement pour obtenir le résultat d’une phrase simple écrite à l’écran. Il aurait certainement été beaucoup plus rapide de taper nous-mêmes la phrase de sortie.

Cependant, la programmation ne se limite pas à l’impression de textes simples à l’écran. Pour aller un peu plus loin et devenir capable d’écrire des programmes qui exécutent des tâches utiles qui nous épargnent vraiment du travail, nous devons introduire le concept de variables.

Imaginons que je vous demande de vous rappeler le chiffre 5, puis de mémoriser le nombre 2 en même temps. Vous venez de stocker deux valeurs différentes dans votre mémoire (5 et 2). Maintenant, si je vous demande d’ajouter 1 au premier chiffre , vous devriez conserver les chiffres 6 (c’est-à-dire 5 + 1) et 2 dans votre mémoire. Ensuite, nous pourrions, par exemple, soustraire ces valeurs et obtenir 4 comme résultat.

L’ensemble du processus décrit ci-dessus est comparable à ce qu’un ordinateur peut faire avec deux variables. Le même processus peut être exprimé en C ++ avec l’ensemble d’instructions suivant:

a = 5;
b = 2;
a = a + 1;
resultat = a - b;

Évidemment, il s’agit d’un exemple très simple, car nous n’avons utilisé que deux petites valeurs entières, mais considérons que votre ordinateur peut stocker des millions de nombres comme ceux-ci en même temps et effectuer des opérations mathématiques sophistiquées avec eux.

Nous pouvons maintenant définir une variable comme une partie de la mémoire pour stocker une valeur.

Chaque variable a besoin d’un nom qui l’identifie et la distingue des autres. Par exemple, dans le code précédent, les noms de variable étaient a, b et resultat, mais nous aurions pu appeler les variables n’importe quel nom que nous aurions pu trouver, tant qu’il s’agissait d’identifiants C ++ valides.

Les identifiants

Un identifiant valide est une séquence d’une ou plusieurs lettres, chiffres ou caractères de soulignement (_). Les espaces, les signes de ponctuation et les symboles ne peuvent pas faire partie d’un identifiant. De plus, les identifiants doivent toujours commencer par une lettre. Ils peuvent également commencer par un caractère de soulignement (_), mais ces identificateurs sont, dans la plupart des cas, considérés comme réservés aux mots-clés spécifiques au compilateur ou aux identificateurs externes, ainsi que les identificateurs contenant deux caractères de soulignement successifs. Ils ne peuvent en aucun cas commencer par un chiffre.

Très important: le langage C ++ est un langage « sensible à la casse ». Cela signifie qu’un identifiant écrit en majuscules n’est pas équivalent à un autre portant le même nom mais écrit en minuscules. Ainsi, par exemple, la variable RESULTAT n’est pas identique à la variable resultat ou à la variable de résultat. Ce sont trois identifiants différents identifiant trois variables différentes.

Types de données

Les valeurs des variables sont stockées quelque part dans un emplacement non spécifié dans la mémoire de l’ordinateur sous forme de zéros et de uns. Notre programme n’a pas besoin de connaître l’emplacement exact où une variable est stockée; il peut simplement s’y référer par son nom. Ce que le programme doit savoir, c’est le type de données stockées dans la variable. Stocker un entier simple n’est pas la même chose que stocker une lettre ou un grand nombre à virgule flottante; Même s’ils sont tous représentés par des zéros et des uns, ils ne sont pas interprétés de la même manière et, dans de nombreux cas, ils n’occupent pas la même quantité de mémoire.

Les types de données fondamentaux sont des types de base implémentés directement par le langage qui représentent les unités de stockage de base prises en charge de manière native par la plupart des systèmes. Ils peuvent principalement être classés en:

Types de caractère: Ils peuvent représenter un seul caractère, tel que ‘A’ ou ‘$’. Le type le plus élémentaire est char, qui est un caractère d’un octet. D’autres types sont également fournis pour les caractères plus larges.

Types d’entiers numériques: Ils peuvent stocker une valeur entière, telle que 7 ou 1024. Ils existent en différentes tailles et peuvent être signés ou non signés, selon qu’ils supportent des valeurs négatives ou non.

Types à virgule flottante: Ils peuvent représenter des valeurs réelles, telles que 3.14 ou 0.01, avec différents niveaux de précision, en fonction du type utilisé pour les trois types à virgule flottante.

Type booléen: le type booléen, appelé bool en C ++, ne peut représenter qu’un des deux états, vrai ou faux.

Voici la liste complète des types fondamentaux en C ++:

Dans chacun des groupes ci-dessus, la différence entre les types correspond uniquement à leur taille (c.-à-d. Combien ils occupent en mémoire): le premier type de chaque groupe est le plus petit et le dernier est le plus grand, chaque type étant au moins égal à  celui qui le précède dans le même groupe. En dehors de cela, les types d’un groupe ont les mêmes propriétés.

Remarquez dans le panneau situé au-dessus de l’élément autre que char (qui a une taille exactement égale à un octet), aucun des types fondamentaux n’a de taille standard spécifiée (mais une taille minimale au maximum). Par conséquent, le type n’est pas requis (et dans de nombreux cas n’est pas) exactement cette taille minimale. Cela ne signifie pas que ces types ont une taille indéterminée, mais qu’il n’y a pas de taille standard sur tous les compilateurs et toutes les machines; chaque implémentation du compilateur peut spécifier les tailles de ces types qui correspondent le mieux à l’architecture dans laquelle le programme va s’exécuter. Cette spécification de taille plutôt générique pour les types donne au langage C ++ beaucoup de flexibilité pour être adapté afin de fonctionner de manière optimale sur tous les types de plates-formes, actuelles et futures.

Les tailles de type ci-dessus sont exprimées en bits; plus un type a de bits, plus il peut représenter de valeurs distinctes, mais en même temps, il consomme également plus d’espace en mémoire:

8-bit = 256 = 2⁸
16-bit = 65 536 = 2¹⁶
32-bit 4 = 294 967 296= 2³²
64-bit = 18 446 744 073 709 551 616 = 2⁶⁴

Pour les types entiers, avoir plus de valeurs représentables signifie que la plage de valeurs qu’ils peuvent représenter est plus grande; Par exemple, un entier non signé de 16 bits pourrait représenter 65 536 valeurs distinctes dans la plage 0 à 65 535, tandis que son équivalent signé pourrait représenter, dans la plupart des cas, les valeurs comprises entre -32768 et 32767. Notez que la plage de les valeurs positives sont approximativement divisées par deux dans les types signés par rapport aux types non signés, en raison du fait que l’un des 16 bits est utilisé pour le signe; Il s’agit d’une différence de gamme relativement modeste, qui justifie rarement l’utilisation de types non signés uniquement sur la gamme de valeurs positives qu’ils peuvent représenter.

Pour les types à virgule flottante, la taille affecte leur précision, en ayant plus ou moins de bits pour leur significatif et leur exposant.

Si la taille ou la précision du type ne pose pas de problème, char, int et double sont généralement sélectionnés pour représenter les caractères, les entiers et les valeurs à virgule flottante, respectivement. Les autres types de leurs groupes respectifs ne sont utilisés que dans des cas très particuliers.

Les types décrits ci-dessus (caractères, nombres entiers, virgule flottante et booléen) sont collectivement appelés types arithmétiques. Mais il existe deux types fondamentaux supplémentaires: void, qui identifie le manque de type; et le type nullptr, qui est un type spécial de pointeur. Les deux types seront discutés plus loin dans un chapitre à venir sur les pointeurs.

C ++ prend en charge une grande variété de types basés sur les types fondamentaux décrits ci-dessus; Ces autres types sont appelés types de données composés et constituent l’un des principaux atouts du langage C ++. Nous les verrons aussi plus en détail dans les prochains chapitres.

Déclaration de variables

C ++ est un langage fortement typé, nécessitant que chaque variable soit déclarée avec son type avant sa première utilisation. Cela indique au compilateur la taille à réserver en mémoire pour la variable et comment interpréter sa valeur. La syntaxe pour déclarer une nouvelle variable en C ++ est simple: nous écrivons simplement le type suivi du nom de la variable (c’est-à-dire son identifiant). Par exemple:

int a;
float mynumber;

Ce sont deux déclarations valides de variables. Le premier déclare une variable de type int avec l’identifiant a. La seconde déclare une variable de type float avec l’identifiant mynumber. Une fois déclarées, les variables a et mynumber peuvent être utilisées dans le reste de leur portée dans le programme.

Si vous déclarez plusieurs variables du même type, elles peuvent toutes être déclarées dans une même instruction en séparant leurs identificateurs par des virgules. Par exemple:

int a, b, c ;

Cela déclare trois variables (a, b et c), toutes de type int, et a exactement la même signification que:

int a;
int b;
int c;

Initialisation de variables

Lorsque les variables de l’exemple ci-dessus sont déclarées, elles ont une valeur indéterminée jusqu’à ce qu’une valeur leur soit affectée pour la première fois. Mais il est possible qu’une variable ait une valeur spécifique à partir du moment où elle est déclarée. Ceci s’appelle l’initialisation de la variable.

En C ++, il existe trois façons d’initialiser des variables. Ils sont tous équivalents et rappellent l’évolution de la langue au fil des ans:

Le premier, connu sous le nom d’initialisation de type C (car hérité du langage C), consiste à ajouter un signe égal suivi de la valeur à laquelle la variable est initialisée:

identificateur de type = valeur_initial;
Par exemple, pour déclarer une variable de type int appelée x et l’initialiser à une valeur de zéro à partir du même moment où elle est déclarée, nous pouvons écrire:

int x = 0;

Une deuxième méthode, appelée initialisation du constructeur (introduite par le langage C ++), englobe la valeur initiale entre parenthèses (()):

identificateur de type (valeur_initial);
Par exemple:

int x (0);

Enfin, une troisième méthode, appelée initialisation uniforme, similaire au précédent, mais utilisant des accolades ({}) au lieu de parenthèses (introduite par la révision de la norme C ++ en 2011):

identificateur de type {valeur_initial};
Par exemple:

int x {0};

Les trois méthodes d’initialisation des variables sont valides et équivalentes en C ++.