C++, Qt, OpenGL, CUDA

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.

^ [[nombres_aleatoires|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[types_en_detail|Chapitre suivant]] ^

__ ajouter une note pour indiquer qu'il existe d'autres syntaxes, en particulier avec parenthèses __

====== Utiliser la mémoire : les variables ======

===== La mémoire et les variables =====

Très schématiquement, un ordinateur peut être décomposé en deux éléments :

  * le processeur, qui réalise les calculs et les opérations logiques ;
  * les mémoires, qui contiennent les informations (programmes à exécuter, données à traiter, valeurs calculées).

{{ :memoires.png |}}

On distingue les mémoires de stockage (comme les disques durs) et les mémoires de travail (mémoire vive ou RAM //Random Access Memory//). Cette dernière peut être utilisée pour enregistrer les résultats des calculs dans un programme. On peut représenter la mémoire comme un ensemble de "cases", chaque "case" pouvant recevoir des valeurs.

En C++, on utilise des variables pour manipuler la mémoire. Par exemple, le code précédent peut s'écrire de la façon suivante, en utilisant une variable ''x'' :

<code cpp>
int x { 123 + 456 };
cout << x << endl;
cout << x * 789 << endl;
cout << x * 428 << endl;
cout << x * 384 << endl;
cout << x * 126 << endl;
cout << x * 842 << endl;
cout << x * 962 << endl;
cout << x * 107 << endl;
cout << x * 640 << endl;
cout << x * 862 << endl;
cout << x * 364 << endl;
</code>

Dans ce code, au lieu d'afficher le premier calcul avec ''cout'', on enregistre le résultat dans une variable ''x'', puis on réutilise cette variable ''x'' dans les lignes suivantes. Il existe différentes manières d'écrire une variable, nous allons voir cela en détail.

Pour commencer, comment s'écrit une variable en C++ ? Pour écrire une variable, vous devez donner plusieurs informations, dans l'ordre :

  * un **type** (par exemple ''int'' dans le code précédent) ;
  * un **identifiant** (par exemple ''x'' dans le code précédent) ;
  * une **valeur** (par exemple le résultat de l’addition de 123 et 456 dans le code précédent).

Une variable existe à partir de moment où vous la créez, pas avant. Vous ne pouvez pas utiliser une variable dans une ligne de code et la définir dans une ligne qui suit.

<code cpp>
cout << x << endl; // erreur : la variable x est inconnue à cette ligne, elle est
                   // définie uniquement à partir de la ligne suivante
int x { 123 + 456 };
</code>

Vous pouvez créer autant de variables que vous en avez besoin dans votre programme :

<code cpp>
int x { 123 + 456 };
int y { x * 789 };
cout << x << ' ' << y << endl;
</code>

Nous allons voir en détail chaque élément de la définition et l'initialisation d'une variable.

===== Le type =====

Vous n'avez pas encore vu ce terme, mais vous avez déjà manipulé les types. En effet, "nombre entier", "nombre réel" ou "chaîne de caractères" sont des types. En C++, les types ne s'écrivent pas de cette manière, il faut utiliser des mots-clés correspondant à des types. Pour les types que vous connaissez déjà :

  * ''int'' (abréviation de //integer//, "entier" français) correspond à un nombre entier ;
  * ''double'' correspond à un nombre réel (vous verrez par la suite pourquoi on utilise ce terme en C++) ;
  * ''string'' correspond aux chaînes de caractères ; __ oups, j'ai oublié de parlé de string __
  * ''char'' correspond à un caractère ;
  * ''bool'' correspond aux booléens.

Vous avez vu également dans les chapitres précédents comment s'écrivent les littérales correspondantes à chaque type :

  * pour un ''int'' : par exemple ''123'' ou ''456'' ;
  * pour un ''double'' : par exemple ''123.456'' ou ''123.456e789'' ;
  * pour un ''string'' : par exemple ''"hello, world!"'' ou ''"bonjour!"'' ;
  * pour un ''char'' : par exemple 'a' ou 'z' ;
  * pour un ''bool'' : uniquement ''true'' ou ''false''.

Il existe bien sûr d'autres types, plus ou moins complexes, et vous pourrez créer vos propres types par la suite.

Le type d'une variable en C++ est définitif, il n'est pas possible de le changer une fois que vous avez défini une variable, vous ne pouvez donc pas écrire :

<code cpp>
int x { 123 }; // x correspond à une entier
x = "Bonjour"; // erreur : vous ne pouvez pas écrire une chaîne de caractères
               // dans un entier
</code>

Lorsque vous ne modifiez pas une variable après l'avoir initialisée, on peut considérer que cette variable est constante. Vous pouvez indiquer cette information au compilateur en ajoutant le mot-clé ''const'' ("constant") comme modificateur de type. Ainsi :

  * ''int'' : représente un type entier ;
  * ''int const'' : représente un type entier constant.

Indiquer cette information permet au compilateur de faire certaines optimisations (ce que vous ne verrez pas forcément sur un petit programme, mais cela peut avoir un impact sur un programme complexe) et surtout cela permet au compilateur de vérifier que vous ne modifiez pas cette variable par la suite.

<code cpp>
int x { 123 };
x = 456; // ok, x n'est pas constant

int const y { 123 };
y = 456; // erreur, y est constant
</code>

L'utilisation de ''const'' apporte une garantie plus forte sur votre code, vous devez systématiquement réfléchir aux rôles de vos variables et si elles doivent être modifiées durant l'exécution de votre programme ou non. Et donc utiliser le mot-clé ''const'' aussi souvent que nécessaire.

<note info>**Notion de contrat**

Le typage des variables et l'utilisation de ''const'' est une forme de contrat que vous passez avec le compilateur. Vous lui dites que vous allez respecter un certain nombre de contraintes (les valeurs seront d'un type défini, les variables ne seront pas modifiées), celui-ci pourra alors vérifier que vous respectez ces contraintes et fera éventuellement des optimisations.

La programmation par contrat est une approche qui permet d'améliorer la qualité de votre code et qui est plus complet que ce qui est présenté ici. Vous verrez dans la suite du cours comment utiliser efficacement la programmation par contrat en C++, en particulier pour créer vos propres types.</note>

===== L'identifiant =====

L'identifiant d'une variable est le nom de cette variable. Vous pouvez utiliser cet identifiant dans vos codes en remplacement d'une valeur dans un calcul par exemple. Si vous utilisez plusieurs variables, chaque identifiant doit être unique, vous ne pouvez pas définir plusieurs variables utilisant le même nom :

<code cpp>
int const x { 123 }; // x correspond à une entier
int const x { 456 }; // erreur : l'identifiant x est déjà utilisé
</code>

Pour écrire un identifiant, vous pouvez utiliser les caractères alphanumériques minuscules et majuscules (''a'' à ''z'', ''A'' à ''Z'' et ''0'' à ''9'') et le tiret bas ''_'' (//underscore//, correspond à la touche 8 sur un clavier français). De plus, un identifiant doit obligatoirement commencer par une lettre.

Par exemple, les noms suivants sont des identifiants valides : 

  * ''x'' ;
  * ''y'' ;
  * ''unevariable'' ;
  * ''uneVariable'' ;
  * ''une_variable'' ;
  * ''UnEvArIaBlE''.

En revanche, les identifiants suivants ne sont pas valides :

  * ''_une_variable'' : commence par un tiret bas ;
  * ''123variable'' : commence par un chiffre ;
  * ''variable_réelle'' : contient un caractère interdit (''é'').

Comme vous le voyez, le langage C++ laisse de grandes libertés pour choisir un identifiant... ce qui peut poser des problèmes. Exemple de mauvais identifiant :

  * ''jjfndsfkjgukzv'' ne veut rien dire, n'apporte pas d'information sur le rôle de cette variable
  * ''une_variable'' trop générique
  * ''variable1'', ''variable2'', etc. idem
  * ''UnEvArIaBlE'' inutilement trop illisible
  * ''une_variable_qui_contient_le_resultat_du_premier_calcul'' inutilement trop longue

Bonne pratique de codage : règles que vous vous imposez ainsi qu'aux développeurs qui participent à un projet, pour faciliter la lecture du code par tous. Le but est d'avoir des noms homogènes, simples et informatifs.

Il existe déjà des "règles de codage" toutes faites, vous pouvez utiliser vos propres règles. Les conventions de nommage les plus connues : ''une_variable'' (STL, Boost), ''uneVariable'' (Qt)

<note info>pour le moment, 3 sources de règles pour écrire du code :

  * le langage C++, imposé par le compilateur ;
  * les règles de conception, imposées par la qualité logicielle ;
  * les règles de codage, que vous vous imposez.
</note>

===== La valeur =====

Une variable contient obligatoirement une valeur. Il est possible de définir une variable sans l'initialiser, mais cette variable pourra alors contenir une valeur aléatoire. Cependant, vous imaginez bien qu'un programme ne va pas forcément fonctionner correctement si certaines variables sont initialisées avec des valeurs aléatoires. Nous n'allons pas voir toutes les syntaxes possibles pour initialiser une variable, mais uniquement celle qui sont recommandées.

Une variable peut être initialisée avec une valeur par défaut (//value initialization//), avec une littérale (//direct initialization//) ou avec une expression (//copy initialization//).

  * initialisation par défaut : ''Type Identifiant {};'' ;
  * initialisation avec une littérale : ''Type Identifiant { Valeur };'' ;
  * initialisation avec une expression : ''Type Identifiant { Expression };''.

Le signe ''='' utilisé pour attribuer une valeur à une variable s'appelle l'opérateur d'affectation.

Plus concrètement, avec du code :

<code cpp main.cpp>
#include <iostream>
#include <string>
using namespace std;

int main() {
    // Initialisation par défaut
    int const x_default {};
    double const y_default {};
    std::string const s_default {};
    char const c_default {};
    bool const b_default {};
    
    // Initialisation avec une valeur
    int const x_value { 123 };
    double const y_value { 123.456 };
    std::string const s_value { "hello, world!" };
    char const c_value { 'a' };
    bool const b_value { true };
    
    // Initialisation avec une expression
    int const x_expression { 123 + 456 };
    double const y_expression { 12.34 + 56.78 };
    bool const b_expression { 123 > 456 };
}
</code>

Comme vous avez vu dans les codes précédents, il est possible d'afficher la valeur d'une variable directement avec ''cout''. Celui-ci est capable de connaître le type de la variable et d'afficher correctement la valeur, comme si vous aviez écrit une littérale directement avec ''cout''. Vous pouvez également utiliser directement une variable dans un calcul.

<code cpp>
int const x { 123 };
std::cout << "La valeur de x est : " << x << std::endl;
int const y { x * 45 };
</code>

===== De nouveaux opérateurs arithmétiques =====

Modifier une variable non const : utilisation de =

Combinaison opérateur et affectation :

<code>
a = a +b; 
a += b;

a = a * b;
a *= b;

etc.
</code>

===== Variable temporaire et non temporaire =====

En pratique, lorsque l'on écrit :

<code cpp>
int x = y + z;
</code>

Que se passe-t-il en réalité ?

  - chargement de y et z depuis la mémoire dans le processeur;
  - calcul et résultat dans le processeur;
  - retourne résultat du processeur vers mémoire.

Le résultat du processeur est une variable non nommée (type, valeur) temporaire (= intermédiaire de calcul, pas en mémoire). Cette variable temporaire s'appelle une //rvalue// (le nom vient du fait qu'une rvalue ne peut être qu'a droite du signe d'affectation).

Au contraire, x, y, et z sont des variables nommées non temporaires. Cela s'appelle un lvalue (left value, qui peut être à gauche).

Bien faire attention à la différence : c'est l'expression (y+z) qui est une rvalue, y et z en eux même sont des lvalue.

<note warning>Note sur bool

Certains types sont convertissable automatiquement en booléen, pour pouvoir tester s'ils sont valide ou non. C'est le cas par exemple des littérales chaînes de caractères. Il est possible d'écrire le code suivant sans que cela ne produise d'erreur :

<code cpp>
bool b { "hello, world" };
</code>
</note>

^ [[nombres_aleatoires|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[types_en_detail|Chapitre suivant]] ^

{{tag> Cours C++}}
C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Outils de la Page
