Nouveautés pour les variables

On a découvert dès le début du cours de C qu'il existait un grand nombre de types de variable différents :

• int
• long
• float
• double
• char
• etc.

Le problème s'est posé lorsqu'on a voulu stocker des booléens. Faute d'avoir un type de donnée spécialisé dans le stockage des booléens, on a fait comme la plupart des programmeurs C font : on a utilisé un type entier, comme int.



Or, si on utilise int pour les booléens, on risque de les confondre avec des variables destinées à stocker des nombres, puisque int est à la base fait pour stocker des nombres !

Petit exemple tout simple :

Code : C

La variable majeur est un booléen, car elle signifie soit vrai soit faux.
La variable age, elle, est un nombre. Elle peut valoir par exemple 21.

Mais comment fait-on pour savoir laquelle de ces variables est un booléen et laquelle est un nombre ?
On peut se baser sur le nom de la variable, c'est sûr, mais il aurait été plus pratique et plus clair d'avoir un type spécial pour les booléens.

Ca tombe bien ! Il y a justement en C++ un nouveau type de base : le type bool. Toute variable de ce type peut prendre 2 valeurs :

• true, qui signifie vrai.
• false, qui signifie faux.

(je vous conseille de retenir ces 2 valeurs par coeur, vous en aurez besoin )

Du coup, le code qu'on a vu plus haut s'écrirait comme ceci en C++ :

Code : C++

Voilà une bonne chose qui nous permettra d'éviter des ambigüités dans nos programmes

Rappel : les booléens dans les conditions

Je tiens juste à vous faire un petit rappel. Si vous avez bien suivi le cours de C, ça ne devrait pas vous choquer

En théorie, on peut tester un booléen comme ceci dans une condition :

Code : C++

Mais en général, si la variable a un nom clair, on préfèrera enlever la partie == true. C'est tout à fait possible et l'ordinateur le comprend très bien :

Code : C++

Ce code est plus lisible et plus court que le précédent. On comprend bien que la condition est "S'il est majeur".

Par ailleurs, le point d'exclamation sert à exprimer la négation. Dans notre cas, ce code signifierait "S'il n'est pas majeur" :

Code : C++

Ce n'est pas une nouveauté du C++ car ça existait déjà en C, mais je tenais juste à vous informer que cette technique fonctionnait toujours avec le type bool

En C, les variables devaient être déclarées (= créées) au début des fonctions. Vous avez vu cela dans le chapitre sur les variables au tout début du cours

Vous deviez donc faire toutes vos déclarations avant de commencer les instructions :

Code : C

La nouveauté en C++, c'est que l'on peut désormais déclarer des variables n'importe où dans une fonction. C'est plus pratique lorsqu'on programme, ça nous évite d'avoir à remonter au début de la fonction si on n'a besoin d'une variable qu'à un moment de la fonction. Cela peut aussi améliorer la lisibilité du code surtout dans de grosses fonctions.

On pourrait donc écrire le code précédent comme ceci en C++ :

Code : C++



Précision importante : les variables ainsi créées sont locales aux blocs où elles ont été déclarées. Je m'explique.
On dit que les accolades { et } délimitent des blocs. Dans le code ci-dessus, vous devriez en voir deux : la fonction et le bloc if. Comme la variable prixAchat a été déclarée dans le bloc if, elle sera supprimée à la fin du bloc if. Si elle avait été déclarée au début de la fonction en revanche, elle aurait été accessible dans toute la fonction.

Voilà, c'est assez simple à comprendre mais il faut le savoir ! La variable est détruite à la fin du bloc dans lequel elle a été déclarée.

Code : C++

Déclaration dans une boucle

Dans le même ordre d'idée, il y a une nouveauté vraiment très pratique (comprenez : je m'en sers tout le temps ). On peut déclarer une variable directement dans une instruction for.

Prenons un exemple. Vous codez votre programme, tout va bien. Puis à un moment, pour une raison ou une autre, vous avez besoin de faire une boucle qui se répète 10 fois. Vous allez sûrement faire un for. Mais pour boucler 10 fois, vous aurez besoin d'une variable de boucle qui va retenir le nombre de tours de boucle (quand on n'est pas inspiré on appelle en général cette variable i ).

En C, c'est un peu embêtant parce qu'il faut remonter au début de la fonction pour rajouter la déclaration de la variable. En plus, on ne sait pas trop quand elle sera utilisée en lisant la déclaration :

Code : C

La nouveauté en C++, c'est que vous pouvez déclarer votre variable i directement dans l'instruction for. Elle sera détruite à la fin de la boucle, quand vous n'en aurez plus besoin.
Avantages : vous n'avez pas à remonter au début de la fonction pour déclarer la variable, et celle-ci est automatiquement détruite à la fin de la boucle. Pas d'utilisation inutile de la mémoire.

Le code C++ ressemblera donc à cela :

Code : C++

Ca n'a l'air de rien, mais je vous assure qu'en pratique quand on programme, ça c'est vraiment génial
Vous me verrez donc le faire la plupart du temps dans la suite du cours.

Si je vous dis "malloc" et "free", ça vous rappelle de joyeux souvenirs non ?

Code : C

L'allocation dynamique est une technique qui permet de gérer vous-même l'allocation de mémoire pour vos variables. C'est notamment très pratique dans le cas de l'allocation de tableaux dont on ne connaît pas la taille avant compilation (revoyez le chapitre sur l'allocation dynamique au besoin !).

En C++, les allocations dynamiques existent toujours et on en fait toujours. D'ailleurs, les fonctions malloc et free sont toujours utilisables. Cependant, le C++ dispose de nouveaux opérateurs spécialisés dans les allocations dynamiques : new et delete.

Allocation dynamique d'une variable

new et delete ne s'utilisent pas exactement de la même manière que malloc et free.
On va dans un premier temps apprendre à s'en servir pour allouer une variable simple, puis on verra ensuite le cas de l'allocation de tableaux.

On souhaite donc allouer dynamiquement une variable (de type int par exemple).
En C++, on va d'abord devoir créer le pointeur et l'initialiser à NULL, ça on n'y coupe pas :

Code : C++

Allocation de mémoire

L'allocation de mémoire avec new se fait comme ceci :

Code : C++

Comparé à la "version C", il n'y a pas photo
On n'a plus besoin d'utiliser l'opérateur sizeof() du C. Ici, on indique juste le type de variable à créer.

Libération de mémoire

Lorsque vous avez fini d'utiliser votre variable et que vous n'en avez plus besoin, vous devez la libérer avec l'opérateur delete. Ultra-simple :

Code : C++

Résumé

En résumé, voici à quoi ressemble un code d'allocation / libération de mémoire en C++ :

Code : C++

Allocation dynamique d'un tableau

Si on veut allouer un tableau, l'opération est là encore très simple. On n'a plus besoin de faire un calcul du type 20 * sizeof(int) comme on devait le faire en C.

On commence par créer le pointeur :

Code : C++

Allocation de mémoire

Ensuite, l'allocation se fait comme ceci :

Code : C++

Dans ce cas, un tableau de 20 cases sera alloué. Bien entendu, il est aussi possible de remplacer ce nombre par une variable :

Code : C++

La longueur du tableau sera définie par la valeur de la variable taille.

Libération de mémoire

Lorsque vous n'avez plus besoin du tableau, vous devez le libérer... avec cette fois l'opérateur delete[] pour bien préciser qu'il s'agit d'un tableau. Vous n'avez pas besoin de préciser la taille entre crochets, mais n'oubliez pas ces crochets ils sont importants.

Code : C++

Résumé

Code : C++

Vous souvenez-vous du chapitre sur les structures et énumérations ?
On y avait appris à créer nos propres types de variables. On avait notamment utilisé l'exemple d'une structure nommée Coordonnees :

Code : C

Le problème des structures en C, c'est qu'il fallait placer le mot-clé struct au début de chaque déclaration d'une variable de type personnalisé :

Code : C

Pour éviter d'avoir à répéter ce mot à chaque déclaration, on avait découvert l'instruction typedef qu'on utilisait comme ceci avant la définition de notre structure :

Code : C

Du coup, on pouvait déclarer une variable sans avoir à écrire struct devant :

Code : C

La nouveauté

En C++, qu'on se rassure, les structures existent toujours (il y a même encore mieux, mais n'anticipons pas ).

La nouveauté du C++, c'est que le typedef est désormais automatique. A chaque fois que l'on déclare une structure (ou une énumération), un typedef est réalisé automatiquement par le compilateur. On peut donc n'écrire que l'instruction de déclaration de la structure :

Code : C++

Grâce à cela, le mot-clé struct devient totalement inutile lors d'une déclaration de variable :

Code : C++

Nous arrivons maintenant au point le plus important (et délicat) de ce chapitre. Ouvrez grandes vos oreilles (ou plutôt vos yeux ).

Le C++ introduit un nouveau concept : les références. Une référence est un synonyme d'une autre variable. On verra ce que ça veut dire un peu plus loin
Vous allez voir que les références ressemblent beaucoup aux pointeurs. Elles ont en effet été créées pour simplifier l'utilisation des pointeurs. Attention toutefois : je vous préviens qu'au début vous risquez de confondre les références avec les pointeurs (c'est assez perturbant quand on voit ça la première fois j'avoue ).

Les références à l'intérieur d'une fonction

Pour créer une référence, on doit utiliser le symbole & dans la déclaration :

Code : C++



Bon, on a créé une référence. Et alors ?
Et alors si vous compilez le code ci-dessus, le compilateur va vous insulter poliment :

Citation : Compilateur C++

Si vous lisez l'anglais (et si vous ne le lisez pas vous devriez), vous avez compris le problème : le compilateur veut qu'on initialise immédiatement la référence.
Et ça c'est très important : une référence doit être immédiatement initialisée dès le début, contrairement aux pointeurs. Et ce n'est pas tout : une fois initialisée, la référence ne pourra plus changer !

Il y a donc deux règles que j'aimerais que vous reteniez par coeur :

• Règle 1 : une référence doit être initialisée dès sa déclaration.
• Règle 2 : une fois initialisée, une référence ne peut plus être modifiée.

Initialisation d'une référence

On va donc initialiser notre référence.
Comme je vous l'ai dit un peu plus tôt, une référence est un synonyme d'une autre variable. Cela veut donc dire qu'il faut créer une autre variable pour y trouver un minimum d'intérêt

Allez hop, il est l'heure de ressortir la bonne vieille variable qui a fait ses preuves : la variable... age !
(le premier qui ose dire que je fais des cours pas originaux il va tâter de mon sabre )

Code : C++

Pour initialiser une référence, vous avez juste besoin d'écrire le nom de la variable dont elle sera le synonyme. Pas besoin d'écrire &age comme on le faisait avant avec les pointeurs.

Utilisation de la référence

Bon, maintenant notre référence est créée. On a un synonyme de la variable age.
Comment on s'en sert concrètement ? Exactement comme la variable age ! Pas besoin de mettre une étoile * devant pour dire qu'on veut obtenir la valeur. Les références permettent, vous allez le voir, de simplifier l'écriture de nos programmes pour éviter au maximum les erreurs (un oubli d'une étoile est si vite arrivé !).

Regardez ce petit programme complet qui affiche la variable age, la modifie, et la réaffiche, le tout en passant par une référence :

Code : C++

Résultat :

Code : Console

Comme vous pouvez le voir, une référence s'utilise exactement comme la variable d'origine. C'est le compilateur qui fait la "conversion" et qui sait qu'il doit affecter la variable "age" lorsqu'on travaille avec la référence.

Comparatif pointeur / référence

En C++, les pointeurs existent toujours. Les références sont juste une alternative aux pointeurs. Elles ont surtout l'avantage d'être plus simples à utiliser, mais elles ne peuvent pas les remplacer complètement.
Pourquoi ? On l'a vu : une référence ne peut pas faire référence à une nouvelle variable une fois qu'elle a été initialisée. Un pointeur, lui, peut toujours pointer vers une nouvelle variable au cours de l'exécution du programme.



Il est très courant de confondre les pointeurs et les références lorsqu'on débute (si ça peut vous rassurer, moi aussi j'ai pas mal confondu au début). Je vais donc vous donner 2 codes source : le premier utilise les pointeurs, le second les références. Si à un moment vous avez un doute et que vous vous mettez à confondre pointeurs et références, servez-vous de l'exemple ci-dessous pour vous assurer que vous faites les choses correctement :

-------- Code d'exemple avec un pointeur --------	-------- Code d'exemple avec une référence --------
Code : C++ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 int main() { int age = 21; int *pointeurSurAge = &age; cout << *pointeurSurAge; *pointeurSurAge = 40; cout << *pointeurSurAge; return 0; }	Code : C++ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 int main() { int age = 21; int &referenceSurAge = age; cout << referenceSurAge; referenceSurAge = 40; cout << referenceSurAge; return 0; }

Voilà, j'espère que ce comparatif vous permettra d'y voir plus clair
Ce qu'il faut retenir dans l'histoire, c'est que les références sont là pour simplifier l'écriture du code source. Comme on n'a plus besoin d'utiliser le symbole * à chaque fois qu'on veut accéder à la variable age, on minimise les risques d'erreur dans nos programmes.

Les références vers des structures

Si vous faites une référence vers une structure, il faudra utiliser le symbole point "." et non le symbole flèche "->" lorsque vous voulez accéder à un élément d'une structure.

Code : C++

Code : Console

Une fois de plus, vous voyez qu'une référence s'utilise exactement comme une variable

Les références lors d'un appel de fonction

Les codes qu'on a vus jusqu'ici n'étaient pas très utiles. En pratique, on n'est pas suffisamment maso pour créer des références juste "pour le plaisir" si elles ne sont pas indispensables.

En fait, comme pour les pointeurs, les références révèlent toute leur utilité lorsqu'on appelle une fonction.

Voyons voir ça dans un exemple :

Code : C++

On transmet la référence à la fonction RemiseAZero le plus simplement du monde, sans avoir à mettre de symbole &.

Code : C++

Le but des références est là encore très clair : éviter d'avoir à taper des symboles en plus pour minimiser les erreurs.

La fonction doit bien préciser qu'elle reçoit une référence. On doit donc placer le symbole & dans la déclaration (et dans le prototype) :

Code : C++

Ensuite, à l'intérieur de la fonction, on se sert de la référence comme si c'était une variable (dans le cas présent, on utilise donc le symbole point et non la flèche -> ) :

Code : C++

Comparaison pointeur / référence

Une fois de plus, je crois qu'il est utile que je vous fasse un comparatif du même code utilisant d'un côté un pointeur, de l'autre une référence.

----------------------- Code d'exemple avec un pointeur -------------------	----------------- Code d'exemple avec une référence ---------------------
Code : C++ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 int main() { Coordonnees point; remiseAZero(&point); return 0; } void remiseAZero(Coordonnees *pointAModifier) { pointAModifier->x = 0; pointAModifier->y = 0; }	Code : C++ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 int main() { Coordonnees point; remiseAZero(point); return 0; } void remiseAZero(Coordonnees &pointAModifier) { pointAModifier.x = 0; pointAModifier.y = 0; }

Ces codes fonctionnent tous deux très bien en C++. Autant que possible, on utilisera des références en C++, sauf quand l'utilisation d'un pointeur est obligatoire.



A retenir : s'il y a un code que vous devez retenir pour les références, c'est celui de l'appel d'une fonction utilisant une référence (celui que nous venons de voir). Dans 99,99% des cas, on utilise les références lorsqu'on fait appel à une fonction.

1

char *maChaine = new char[100];

1
2

bool visible;
visible = "true";

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

void fonction(int &nombre);

int main()
{
    int nombre = 3;

    fonction(&nombre);

    return 0;
}

void fonction(int &nombre)
{
    nombre = 15;
}

1
2

int nombre = 3;
int *kesako = nombre;