Tutoriel : Programmez avec le langage C++

Les programmes sont à la base de l'informatique. Ce sont eux qui vous permettent d'exécuter des actions sur votre ordinateur.

Prenons par exemple la figure suivante qui représente une capture d'écran de mon ordinateur. On y distingue 3 fenêtres correspondant à 3 programmes différents. Du premier plan à l'arrière-plan :

• le navigateur web Google Chrome, qui permet de consulter des sites web ;

• l'explorateur de fichiers, qui permet de gérer les fichiers sur son ordinateur ;

• le traitement de texte Microsoft Word, qui permet de rédiger lettres et documents.

Comme vous le voyez, chacun de ces programmes est conçu dans un but précis. On pourrait aussi citer les jeux, par exemple, qui sont prévus pour s'amuser : Starcraft II (figure suivante), World of Warcraft, Worms, Team Fortress 2, etc. Chacun d'eux correspond à un programme différent.

Tout d'abord, commencez par mesurer vos ambitions. Un jeu tel que Starcraft II nécessite des dizaines de développeurs à plein temps, pendant plusieurs années. Ne vous mettez donc pas en tête des objectifs trop difficiles à atteindre.

En revanche, si vous suivez ce cours, vous aurez de solides bases pour développer des programmes. Au cours d'un TP, nous réaliserons même notre propre navigateur web (simplifié) comme Mozilla Firefox et Google Chrome ! Vous saurez créer des programmes dotés de fenêtres. Avec un peu de travail supplémentaire, vous pourrez même créer des jeux 2D et 3D si vous le désirez. Bref, avec le temps et à force de persévérance, vous pourrez aller loin.

Alors oui, je n'oublie pas votre question : vous vous demandez comment réaliser des programmes. La programmation est un univers très riche. On utilise des langages de programmation qui permettent d'expliquer à l'ordinateur ce qu'il doit faire. Voyons plus en détail ce que sont les langages de programmation.

Votre ordinateur est une machine étonnante et complexe. À la base, il ne comprend qu'un langage très simple constitué de 0 et de 1. Ainsi, un message tel que celui-ci :

1010010010100011010101001010111010100011010010

… peut signifier quelque chose comme « Affiche une fenêtre à l'écran ».

Heureusement non.

S'il fallait écrire dans ce langage (qu'on appelle langage binaire), il ne faudrait pas des années pour concevoir un jeu comme Starcraft II mais plutôt des millénaires (sans rire !).

Pour se simplifier la vie, les informaticiens ont créé des langages intermédiaires, plus simples que le binaire. Il existe aujourd'hui des centaines de langages de programmation. Pour vous faire une idée, vous pouvez consulter une liste des langages de programmation sur Wikipédia. Chacun de ces langages a des spécificités, nous y reviendrons.

Tous les langages de programmation ont le même but : vous permettre de parler à l'ordinateur plus simplement qu'en binaire. Voici comment cela fonctionne :

1. Vous écrivez des instructions pour l'ordinateur dans un langage de programmation (par exemple le C++) ;

2. Les instructions sont traduites en binaire grâce à un programme de « traduction » ;

3. L'ordinateur peut alors lire le binaire et faire ce que vous avez demandé !

Résumons ces étapes dans un schéma (figure suivante).

Le fameux « programme de traduction » s'appelle en réalité le compilateur. C'est un outil indispensable. Il vous permet de transformer votre code, écrit dans un langage de programmation, en un vrai programme exécutable.

Reprenons le schéma précédent et utilisons un vrai vocabulaire d'informaticien (figure suivante).

Voilà ce que je vous demande de retenir pour le moment : ce n'est pas bien compliqué mais c'est la base à connaître absolument !

Les programmeurs (aussi appelés développeurs) connaissent en général plusieurs langages de programmation et non pas un seul. On se concentre rarement sur un seul langage de programmation.

Bien entendu, il faut bien commencer par l'un d'eux. La bonne nouvelle, c'est que vous pouvez commencer par celui que vous voulez ! Les principes des langages sont souvent les mêmes, vous ne serez pas trop dépaysés d'un langage à l'autre.

Néanmoins, voyons plus en détail ce qui caractérise le C++ par rapport aux autres langages de programmation… Et bien oui, c'est un cours de C++ ne l'oubliez pas !

Que vaut le C++ par rapport aux autres langages ?

Le C++ : langage de haut ou de bas niveau ?

Parmi les centaines de langages de programmation qui existent, certains sont plus populaires que d'autres. Sans aucun doute, le C++ est un langage très populaire. Des sites comme langpop.com tiennent à jour un classement des langages les plus couramment utilisés, si cette information vous intéresse. Comme vous pourrez le constater, le C, le Java et le C++ occupent régulièrement le haut du classement.

La question est : faut-il choisir un langage parce qu'il est populaire ? Il existe des langages très intéressants mais peu utilisés. Le souci avec les langages peu utilisés, c'est qu'il est difficile de trouver des gens pour vous aider et vous conseiller quand vous avez un problème. Voilà entre autres pourquoi le C++ est un bon choix pour qui veut débuter : il y a suffisamment de gens qui développent en C++ pour que vous n'ayez pas à craindre de vous retrouver tous seuls !

Bien entendu, il y a d'autres critères que la popularité. Le plus important à mes yeux est le niveau du langage. Il existe des langages de haut niveau et d'autres de plus bas niveau.

C'est un langage assez éloigné du binaire (et donc du fonctionnement de la machine), qui vous permet généralement de développer de façon plus souple et rapide.

Par opposition, un langage de bas niveau est plus proche du fonctionnement de la machine : il demande en général un peu plus d'efforts mais vous donne aussi plus de contrôle sur ce que vous faites. C'est à double tranchant.

Le C++ ? On considère qu'il fait partie de la seconde catégorie : c'est un langage dit « de bas niveau ». Mais que cela ne vous fasse pas peur ! Même si programmer en C++ peut se révéler assez complexe, vous aurez entre les mains un langage très puissant et particulièrement rapide. En effet, si l'immense majorité des jeux sont développés en C++, c'est parce qu'il s'agit du langage qui allie le mieux puissance et rapidité. Voilà ce qui en fait un langage incontournable.

Le schéma ci-dessous représente quelques langages de programmation classés par « niveau » (figure suivante).

Vous constaterez qu'il est en fait possible de programmer en binaire grâce à un langage très basique appelé l'assembleur. Étant donné qu'il faut déployer des efforts surhumains pour coder ne serait-ce qu'une calculatrice, on préfère le plus souvent utiliser un langage de programmation.

Résumé des forces du C++

• Il est très répandu. Comme nous l'avons vu, il fait partie des langages de programmation les plus utilisés sur la planète. On trouve donc beaucoup de documentation sur Internet et on peut facilement avoir de l'aide sur les forums. Il paraît même qu'il y a des gens sympas qui écrivent des cours pour débutants dessus. :-°

• Il est rapide, très rapide même, ce qui en fait un langage de choix pour les applications critiques qui ont besoin de performances. C'est en particulier le cas des jeux vidéo, mais aussi des outils financiers ou de certains programmes militaires qui doivent fonctionner en temps réel.

• Il est portable : un même code source peut théoriquement être transformé sans problème en exécutable sous Windows, Mac OS et Linux. Vous n'aurez pas besoin de réécrire votre programme pour d'autres plates-formes !

• Il existe de nombreuses bibliothèques pour le C++. Les bibliothèques sont des extensions pour le langage, un peu comme des plug-ins. De base, le C++ ne sait pas faire grand chose mais, en le combinant avec de bonnes bibliothèques, on peut créer des programmes 3D, réseaux, audio, fenêtrés, etc.

• Il est multi-paradigmes (outch !). Ce mot barbare signifie qu'on peut programmer de différentes façons en C++. Vous êtes encore un peu trop débutants pour que je vous présente tout de suite ces techniques de programmation mais l'une des plus célèbres est la Programmation Orientée Objet (POO). C'est une technique qui permet de simplifier l'organisation du code dans nos programmes et de rendre facilement certains morceaux de codes réutilisables. La partie II de ce cours sera entièrement dédiée à la POO !

Bien entendu, le C++ n'est pas LE langage incontournable. Il a lui-même ses défauts par rapport à d'autres langages, sa complexité en particulier. Vous avez beaucoup de contrôle sur le fonctionnement de votre ordinateur (et sur la gestion de la mémoire) : cela offre une grande puissance mais, si vous l'utilisez mal, vous pouvez plus facilement faire planter votre programme. Ne vous en faites pas, nous découvrirons tout cela progressivement dans ce cours.

Petit aperçu du C++

Pour vous donner une idée, voici un programme très simple affichant le message « Hello world! » à l'écran. « Hello World » est traditionnellement le premier programme que l'on effectue lorsqu'on commence la programmation. Ce sera l'un des premiers codes source que nous étudierons dans les prochains chapitres.

#include <iostream>
 
using namespace std;
 
int main()
{
	cout << "Hello world!" << endl;
	return 0;
}

La programmation a déjà une longue histoire derrière elle. Au début, il n'existait même pas de clavier pour programmer ! On utilisait des cartes perforées comme celle ci-dessous pour donner des instructions à l'ordinateur (figure suivante).

Autant vous dire que c'était long et fastidieux !

De l'Algol au C++

Les choses ont ensuite évolué, heureusement. Le clavier et les premiers langages de programmation sont apparus :

• 1958 : il y a longtemps, à l'époque où les ordinateurs pesaient des tonnes et faisaient la taille de votre maison, on a commencé à inventer un langage de programmation appelé l'Algol.

• 1960-1970 : ensuite, les choses évoluant, on a créé un nouveau langage appelé le CPL, qui évolua lui-même en BCPL, puis qui prit le nom de langage B (vous n'êtes pas obligés de retenir tout ça par coeur).

• 1970 : puis, un beau jour, on en est arrivé à créer encore un autre langage qu'on a appelé… le langage C. Ce langage, s'il a subi quelques modifications, reste encore un des langages les plus utilisés aujourd'hui. %le plus utilisé, d'après langpop.com cité plus haut !%

• 1983 : un peu plus tard, on a proposé d'ajouter des choses au langage C, de le faire évoluer. Ce nouveau langage, que l'on a appelé « C++ », est entièrement basé sur le C. Le langage C++ n'est en fait rien d'autre que le langage C avec plusieurs nouveautés. Il s'agit de concepts de programmation poussés comme la programmation orientée objet, le polymorphisme, les flux… Bref, des choses bien compliquées pour nous pour le moment mais dont nous aurons l'occasion de reparler par la suite !

Tout le monde n'a pas besoin des améliorations apportées par le langage C++. Le C est à lui seul suffisamment puissant pour être à la base des systèmes d'exploitation comme Linux, Mac OS X et Windows.

Ceux qui n'ont pas besoin des améliorations (mais aussi de la complexité !) apportées par le langage C++ se contentent donc très bien du langage C et ce, malgré son âge. Comme quoi, un langage peut être vieux et rester d'actualité.

Le concepteur

C'est Bjarne Stroustrup, un informaticien originaire du Danemark, qui a conçu le langage C++. Insatisfait des possibilités offertes par le C, il a créé en 1983 le C++ en y ajoutant les possibilités qui, selon lui, manquaient.

Bjarne Stroustrup est aujourd'hui professeur d'informatique à l'université Texas A&M, aux Etats-Unis. Il s'agit d'une importante figure de l'univers informatique qu'il faut connaître, au moins de nom (du moins si vous arrivez à le retenir !).

De nombreux langages de programmation se sont par la suite inspirés du C++. C'est notamment le cas du langage Java.

Le langage C++, bien que relativement ancien, continue à être amélioré. Une nouvelle version, appelée « C++1x », est d'ailleurs en cours de préparation. Il ne s'agit pas d'un nouveau langage mais d'une mise à jour du C++. Les nouveautés qu'elle apporte sont cependant trop complexes pour nous, nous n'en parlerons donc pas ici !

En résumé

• Les programmes permettent de réaliser toutes sortes d'actions sur un ordinateur : navigation sur le Web, rédaction de textes, manipulation des fichiers, etc.

• Pour réaliser des programmes, on écrit des instructions pour l'ordinateur dans un langage de programmation. C'est le code source.

• Le code doit être traduit en binaire par un outil appelé compilateur pour qu'il soit possible de lancer le programme. L'ordinateur ne comprend en effet que le binaire.

• Le C++ est un langage de programmation très répandu et rapide. C'est une évolution du langage C car il offre en particulier la possibilité de programmer en orienté objet, une technique de programmation puissante qui sera présentée dans ce livre.

Alors à votre avis, de quels outils un programmeur a-t-il besoin ?

Si vous avez attentivement suivi le chapitre précédent, vous devez en connaître au moins un !

Vous voyez de quoi je parle ?

Eh oui, il s'agit du compilateur, ce fameux programme qui permet de traduire votre langage C++ en langage binaire !

Il en existe plusieurs pour le langage C++. Mais nous allons voir que le choix du compilateur ne sera pas très compliqué dans notre cas.

Bon, de quoi d'autre a-t-on besoin ?

Je ne vais pas vous laisser deviner plus longtemps. Voici le strict minimum pour un programmeur :

• Un éditeur de texte pour écrire le code source du programme en C++. En théorie un logiciel comme le Bloc-Notes sous Windows ou vi sous Linux fait l'affaire. L'idéal, c'est d'avoir un éditeur de texte intelligent qui colore tout seul le code, ce qui vous permet de vous y repérer bien plus facilement. Voilà pourquoi aucun programmeur sain d'esprit n'utilise le Bloc-Notes.

• Un compilateur pour transformer (« compiler ») votre code source en binaire.

• Un débugger (« Débogueur » ou « Débugueur » en français) pour vous aider à traquer les erreurs dans votre programme (on n'a malheureusement pas encore inventé le « correcteur », un truc qui corrigerait tout seul nos erreurs).

A priori, si vous êtes un casse-cou de l'extrême, vous pourriez vous passer de débugger. Mais bon, je sais pertinemment que 5 minutes plus tard vous reviendriez me demander où on peut trouver un débugger qui marche bien.

À partir de maintenant on a 2 possibilités :

• Soit on récupère chacun de ces 3 programmes séparément. C'est la méthode la plus compliquée, mais elle fonctionne. Sous Linux en particulier, bon nombre de programmeurs préfèrent utiliser ces 3 programmes séparément. Je ne détaillerai pas cette solution ici, je vais plutôt vous parler de la méthode simple.

• Soit on utilise un programme « 3-en-1 » (oui oui, comme les liquides vaisselle) qui combine éditeur de texte, compilateur et débugger. Ces programmes « 3-en-1 » sont appelés IDE (ou en français « EDI » pour « Environnement de Développement Intégré »).

Il existe plusieurs environnements de développement. Au début, vous aurez peut-être un peu de mal à choisir celui qui vous plaît. Une chose est sûre en tout cas: vous pouvez faire n'importe quel type de programme, quel que soit l'IDE que vous choisissez.

Les projets

Quand vous réalisez un programme, on dit que vous travaillez sur un projet. Un projet est constitué de plusieurs fichiers de code source : des fichiers .cpp, .h, les images du programme, etc.

Le rôle d'un IDE est de rassembler tous ces fichiers d'un projet au sein d'une même interface. Ainsi, vous avez accès à tous les éléments de votre programme à portée de clic.

Voilà pourquoi, quand vous voudrez créer un nouveau programme, il faudra demander à l'IDE de vous préparer un « nouveau projet ».

Choisissez votre IDE

Il m'a semblé intéressant de vous montrer quelques IDE parmi les plus connus. Tous sont disponibles gratuitement. Personnellement, je navigue un peu entre tous ceux-là et j'utilise l'IDE qui me plaît selon l'humeur du jour.

• Un des IDE que je préfère s'appelle Code::Blocks. Il est gratuit et disponible pour la plupart des systèmes d'exploitation. Je conseille d'utiliser celui-ci pour débuter (et même pour la suite s'il vous plaît bien !).
  Fonctionne sous Windows, Mac et Linux.

• Le plus célèbre IDE sous Windows, c'est celui de Microsoft : Visual C++. Il existe à la base en version payante (chère !) mais, heureusement, il en existe une version gratuite intitulée Visual C++ Express qui est vraiment très bien (il y a peu de différences avec la version payante). Il est très complet et possède un puissant module de correction des erreurs (débuggage).
  Fonctionne sous Windows uniquement.

• Sur Mac OS X, vous pouvez aussi utiliser XCode, généralement fourni sur le CD d'installation de Mac OS X. C'est un IDE très apprécié par tous ceux qui font de la programmation sur Mac.Fonctionne sous Mac OS X uniquement.

Tous ces IDE vous permettront de programmer et de suivre le reste de ce cours sans problème. Certains sont plus complets au niveau des options, d'autres un peu plus intuitifs à utiliser, mais dans tous les cas les programmes que vous créerez seront les mêmes quel que soit l'IDE que vous utilisez. Ce choix n'est donc pas si crucial qu'on pourrait le croire.

Durant tout ce cours, j'utiliserai Code::Blocks. Si vous voulez avoir exactement les mêmes écrans que moi, surtout au début pour ne pas être perdus, je vous recommande donc de commencer par installer Code::Blocks.

Code::Blocks est un IDE libre et gratuit, disponible pour Windows, Mac et Linux. Il n'est disponible pour le moment qu'en anglais. Cela ne devrait PAS vous décourager de l'utiliser. En fait, nous utiliserons très peu les menus.

Sachez toutefois que, quand vous programmerez, vous serez de toute façon confronté bien souvent à des documentations en anglais. Voilà donc une raison de plus pour s'entraîner à utiliser cette langue.

Télécharger Code::Blocks

Rendez-vous sur la page de téléchargements de Code::Blocks.

• Si vous êtes sous Windows, repérez la section « Windows » un peu plus bas sur cette page. Téléchargez le logiciel en choisissant le programme dont le nom contient mingw (ex. : codeblocks-10.05mingw-setup.exe). L'autre version étant sans compilateur, vous aurez du mal à compiler vos programmes.

• Si vous êtes sous Linux, le mieux est encore d'installer Code::Blocks via les dépôts (par exemple avec la commande apt-get sous Ubuntu). Il vous faudra aussi installer le compilateur à part : c'est le paquet build-essential. Pour installer le compilateur et l'IDE Code::Blocks, vous devriez donc taper la commande suivante :

  apt-get install build-essential codeblocks

• Enfin, sous Mac, choisissez le fichier le plus récent de la liste.

L'installation est très simple et rapide. Laissez toutes les options par défaut et lancez le programme.

On distingue dans la fenêtre 4 grandes sections (numérotées dans la figure suivante) :

1. La barre d'outils : elle comprend de nombreux boutons, mais seuls quelques-uns d'entre eux nous seront régulièrement utiles. J'y reviendrai plus loin.

2. La liste des fichiers du projet : c'est à gauche que s'affiche la liste de tous les fichiers source de votre programme. Notez que, sur cette capture, aucun projet n'a été créé : on ne voit donc pas encore de fichier à l'intérieur de la liste. Vous verrez cette section se remplir dans cinq minutes en lisant la suite du cours.

3. La zone principale : c'est là que vous pourrez écrire votre code en langage C++ !

4. La zone de notification : aussi appelée la « Zone de la mort », c'est ici que vous verrez les erreurs de compilation s'afficher si votre code comporte des erreurs. Cela arrive très régulièrement !

Intéressons-nous maintenant à une section particulière de la barre d'outils. Vous trouverez dans l'ordre les boutons suivants : Compiler, Exécuter, Compiler & Exécuter et Tout recompiler (figure suivante). Retenez-les, nous les utiliserons régulièrement.

• Compiler : tous les fichiers source de votre projet sont envoyés au compilateur qui se charge de créer un exécutable. S’il y a des erreurs (ce qui a de fortes chances d’arriver), l’exécutable n'est pas créé et on vous indique les erreurs en bas de Code::Blocks.

• Exécuter : cette icône lance juste le dernier exécutable que vous avez compilé. Cela vous permet donc de tester votre programme et voir ainsi ce qu’il donne. Dans l’ordre, si vous avez bien suivi, on doit d’abord compiler puis exécuter le binaire obtenu pour le tester. On peut aussi utiliser le 3ème bouton…

• Compiler & Exécuter : pas besoin d’être un génie pour comprendre que c’est la combinaison des 2 boutons précédents. C’est d’ailleurs ce bouton que vous utiliserez le plus souvent. Notez que s’il y a des erreurs pendant la compilation (pendant la génération de l’exécutable), le programme n'est pas exécuté. À la place, vous avez droit à une liste d’erreurs à corriger.

• Tout reconstruire : quand vous choisissez de Compiler, Code::Blocks ne recompile en fait que les fichiers modifiés depuis la dernière compilation et pas les autres. Parfois (je dis bien parfois) vous aurez besoin de demander à Code::Blocks de vous recompiler tous les fichiers. On verra plus tard quand on a besoin de ce bouton et vous verrez plus en détail le fonctionnement de la compilation dans un chapitre futur. Pour l’instant, on se contente d'apprendre le minimum nécessaire pour ne pas tout mélanger. Ce bouton ne nous sera donc pas utile de suite.

Créer un nouveau projet

Pour créer un nouveau projet, c'est très simple : allez dans le menu File > New > Project.

Dans la fenêtre qui s'ouvre, choisissez Console application (figure suivante).

Cliquez sur Go pour créer le projet. Un assistant s'ouvre.

La première page ne servant à rien, cliquez sur Next.

On vous demande ensuite si vous allez faire du C ou du C++ : répondez C++ (figure suivante).

On vous demande le nom de votre projet et dans quel dossier seront enregistrés les fichiers source (figure suivante).

Enfin, la dernière page vous permet de choisir de quelle façon le programme doit être compilé. Vous pouvez laisser les options par défaut, cela n'aura pas d'incidence pour ce que nous allons faire dans l'immédiat. (Veillez à ce qu'au moins Debug ou Release soit coché.)

Cliquez sur Finish, c'est bon !

Code::Blocks vous crée un premier projet contenant déjà un tout petit peu de code source.

Dans le panneau de gauche intitulé Projects, développez l'arborescence en cliquant sur le petit + pour afficher la liste des fichiers du projet. Vous devriez avoir au moins un fichier main.cpp que vous pouvez ouvrir en faisant un double-clic dessus.

Et voilà !

Quelques petits rappels sur Visual C++ :

• c'est l'IDE de Microsoft.

• il est à la base payant, mais Microsoft en a sorti une version gratuite intitulée Visual C++ Express.

Nous allons bien entendu voir ici la version gratuite, Visual C++ Express (figure suivante).

Il n'y a pas d'éditeur de ressources (vous permettant de dessiner des images, des icônes ou des fenêtres). Mais bon, entre nous, on s'en moque parce qu'on n'aura pas besoin de s'en servir dans ce livre. Ce ne sont pas des fonctionnalités indispensables, bien au contraire.

Vous trouverez les instructions pour télécharger Visual C++ Express à cette adresse :

Site de Visual C++ Express Edition

Sélectionnez Visual C++ Express Français un peu plus bas sur la page.

Visual C++ Express est en français et est totalement gratuit. Ce n'est donc pas une version d'essai limitée dans le temps.

Installation

L'installation devrait normalement se passer sans encombre. Le programme d'installation va télécharger la dernière version de Visual sur Internet.

Je vous conseille de laisser les options par défaut.

À la fin, on vous dit qu'il faut vous enregistrer dans les 30 jours. Pas de panique, c'est gratuit et rapide mais il faut le faire.

Cliquez sur le lien qui vous est donné : vous arrivez sur le site de Microsoft. Connectez-vous avec votre compte Windows Live ID (équivalent du compte Hotmail ou MSN) ou créez-en un si vous n'en avez pas, puis répondez au petit questionnaire.

À la fin du processus, on vous donne à la fin une clé d'enregistrement. Vous devez recopier cette clé dans le menu ? > Inscrire le produit.

Créer un nouveau projet

Pour créer un nouveau projet sous Visual, allez dans le menu Fichier > Nouveau > Projet.

Sélectionnez Win32 dans le panneau de gauche puis Application console Win32 à droite.

Entrez un nom pour votre projet, par exemple « test ».

Validez. Une nouvelle fenêtre s'ouvre.

Cette fenêtre ne sert à rien. Par contre, cliquez sur Paramètres de l'application dans le panneau de gauche.

Veillez à ce que l'option Projet vide soit cochée comme à la figure suivante.

Puis, cliquez sur Terminer.

Ajouter un nouveau fichier source

Votre projet est pour l'instant bien vide. Faites un clic droit sur le dossier Fichiers sources situé dans le panneau de gauche puis allez dans Ajouter > Nouvel élément.

Une fenêtre s'ouvre. Sélectionnez Fichier C++ (.cpp). Entrez le nom « main.cpp » pour votre fichier.

Cliquez sur Ajouter. C'est bon, vous allez pouvoir commencer à écrire du code !

La fenêtre principale de Visual

Voyons ensemble le contenu de la fenêtre principale de Visual C++ Express. On va rapidement se pencher sur ce que signifie chacune des parties :

1. La barre d'outils : tout ce qu'il y a de plus standard. Ouvrir, Enregistrer, Enregistrer tout, Couper, Copier, Coller etc. Par défaut, il semble qu'il n'y ait pas de bouton de barre d'outils pour compiler. Vous pouvez les rajouter en faisant un clic droit sur la barre d'outils puis en choisissant Déboguer et Générer dans la liste.
   
   Toutes ces icônes de compilation ont leur équivalent dans les menus Générer et Déboguer. Si vous choisissez Générer, cela crée l'exécutable (cela signifie « Compiler » pour Visual). Si vous sélectionnez Déboguer / Exécuter, on devrait vous proposer de compiler avant d'exécuter le programme. La touche F7 permet de générer le projet et F5 de l'exécuter.

2. La liste des fichiers du projet : dans cette zone très importante, vous voyez normalement la liste des fichiers de votre projet. Cliquez sur l'onglet Explorateur de solutions, en bas, si ce n'est déjà fait. Vous devriez voir que Visual crée déjà des dossiers pour séparer les différents types de fichiers de votre projet (« sources », « en-têtes » et « ressources »). Nous verrons un peu plus tard quels sont les différentes sortes de fichiers qui constituent un projet.

3. La zone principale : c'est là qu'on modifie les fichiers source.

4. La zone de notification : c'est là encore la « zone de la mort », celle où l'on voit apparaître toutes les erreurs de compilation. C'est également dans le bas de l'écran que Visual affiche les informations de débuggage quand vous essayez de corriger un programme buggé. Je vous ai d'ailleurs dit tout à l'heure que j'aimais beaucoup le débugger de Visual et je pense que je ne suis pas le seul.

Voilà, on a fait le tour de Visual C++.

Vous pouvez aller jeter un œil dans les options (Outils > Options) si cela vous chante, mais n'y passez pas 3 heures. Il faut dire qu'il y a tellement de cases à cocher partout qu'on ne sait plus trop où donner de la tête.

Il existe plusieurs IDE compatibles Mac. Il y a Code::Blocks{} bien sûr, mais ce n'est pas le seul.

Je vais vous présenter ici l'IDE le plus célèbre sous Mac : Xcode.

Xcode, où es-tu ?

Tous les utilisateurs de Mac OS ne sont pas des programmeurs. Apple l'a bien compris et, par défaut, n'installe pas d'IDE avec Mac OS.

Heureusement, pour ceux qui voudraient programmer, tout est prévu. En effet, Xcode est présent sur le CD d'installation de Mac OS.

Insérez donc le CD dans le lecteur. Pour installer Xcode, il faut ouvrir le paquet Xcode Tools dans le répertoire Installation facultative du disque d'installation. L'installeur démarre (figure suivante).

Par ailleurs, je vous conseille de mettre en favori la page dédiée aux développeurs sur le site d'Apple. Vous y trouverez une foule d'informations utiles pour le développement sous Mac. Vous pourrez notamment y télécharger plusieurs logiciels pour développer.

N'hésitez pas à vous inscrire à l'ADC (Apple Development Connection), c'est gratuit et vous serez ainsi tenus au courant des nouveautés.

Lancement

L'application Xcode se trouve dans le répertoire /Developer/Applications/ (figure suivante).

Nouveau projet

Pour créer un nouveau projet, on clique sur Create a new Xcode project, ou File > New Project. Il faut choisir le type Command Line Tool et sélectionner C++ sdtc++ dans le petit menu déroulant (figure suivante).

Une fois le projet créé, la fenêtre principale de Xcode apparaît (suivante).

Le fichier sdz-test (icône noire) est l'exécutable et le fichier sdz-test.1 est un fichier de documentation.

Le fichier main.cpp contient le code source du programme. Vous pouvez faire un double-clic dessus pour l'ouvrir.

Vous pouvez ajouter de nouveaux fichiers C++ au projet via le menu File > New File.

Compilation

Avant de compiler, il faut changer un réglage dans les préférences de Xcode. Pour ouvrir les préférences, cliquez sur Preferences dans le menu Xcode. Dans l'onglet debugging, sélectionnez Show console dans la liste déroulante intitulée On start. C'est une manipulation nécessaire pour voir la sortie d'un programme en console (figure suivante).

Pour compiler, on clique sur le bouton Build and Run (en forme de marteau avec une petite icône verte devant) dans la fenêtre du projet. La console s'affiche alors (figure suivante).

Voilà ! Vous connaissez désormais l'essentiel pour créer un nouveau projet C++ et le compiler avec Xcode.

En résumé

• Un IDE est un outil tout-en-un à destination des développeurs, qui permet de créer des programmes.

• Un IDE est composé d'un éditeur de texte, d'un compilateur et d'un debugger.

• Code::Blocks, Visual C++ et Xcode sont parmi les IDE les plus connus pour programmer en C++.

• Nous prendrons Code::Blocks comme base dans la suite de ce cours.

Quand je vous annonce que nous allons commencer à programmer, vous vous dites sûrement « Chouette, je vais pouvoir faire ça, ça et ça ; et j'ai toujours rêvé de faire ça aussi ! ». Il est de mon devoir de calmer un peu vos ardeurs et de vous expliquer comment cela va se passer.

Nous allons commencer doucement. Nous n'avons de toute façon pas le choix car les programmes complexes 3D en réseau que vous imaginez peut-être nécessitent de connaître les bases.

Il faut savoir qu'il existe 2 types de programmes : les programmes graphiques et les programmes console.

Les programmes graphiques

Il s'agit des programmes qui affichent des fenêtres. Ce sont ceux que vous connaissez sûrement le mieux. Ils génèrent à l'écran des fenêtres que l'on peut ouvrir, réduire, fermer, agrandir…

Les programmeurs parlent de GUI (Graphical User Interface</italique> - Interface Utilisateur Graphique).

Les programmes console

Les programmes en console sont plus fréquents sous Linux que sous Windows et Mac OS X. Ils sont constitués de simples textes qui s'affichent à l'écran, le plus souvent en blanc sur fond noir (figure suivante).

Ces programmes fonctionnent au clavier. La souris n'est pas utilisée.

Ils s'exécutent généralement linéairement : les messages s'affichent au fur et à mesure, de haut en bas.

Notre première cible : les programmes console

Eh oui, j'imagine que vous l'avez vue venir, celle-là !

Je vous annonce que nous allons commencer par réaliser des programmes console. En effet, bien qu'ils soient un peu austères a priori, ces programmes sont beaucoup plus simples à créer que les programmes graphiques. Pour les débutants que nous sommes, il faudra donc d'abord en passer par là !

Bien entendu, je sais que vous ne voudrez pas en rester là. Rassurez-vous sur ce point : je m'en voudrais de m'arrêter aux programmes console car je sais que beaucoup d'entre vous préféreraient créer des programmes graphiques. Cela tombe bien : une partie toute entière de ce cours sera dédiée à la création de GUI avec Qt, une sorte d'extension du C++ qui permet de réaliser ce type de programmes !

Mais avant cela, il va falloir retrousser ses manches et se mettre au travail. Alors au boulot !

Au chapitre précédent, vous avez installé un IDE, ce fameux logiciel qui contient tout ce qu'il faut pour programmer.

Nous avons découvert qu'il existait plusieurs IDE (Code::Blocks, Visual C++, Xcode…). Je ne vous en ai cité que quelques-uns parmi les plus connus mais il y en a bien d'autres !

Comme je vous l'avais annoncé, je travaille essentiellement avec Code::Blocks. Mes explications s'attarderont donc le plus souvent sur cet IDE mais je reviendrai sur ses concurrents si nécessaire. Heureusement, ces logiciels se ressemblent beaucoup et emploient le même vocabulaire, donc dans tous les cas vous ne serez pas perdus.

Création d'un projet

Pour commencer à programmer, la première étape consiste à demander à son IDE de créer un nouveau projet. C'est un peu comme si vous demandiez à Word de vous créer un nouveau document.

Pour cela, passez par la succession de menus File > New > Project (figure suivante).

Un assistant s'ouvre, nous l'avons vu au chapitre précédent. Créez un nouveau programme console C++ comme nous avons appris à le faire.

À la fin des étapes de l'assistant, le projet est créé et contient un premier fichier. Déployez l'arborescence à gauche pour voir apparaître le fichier main.cpp et faites un double-clic dessus pour l'ouvrir. Ce fichier est notre premier code source et il est déjà un peu rempli (figure suivante) !

Code::Blocks vous a créé un premier programme très simple qui affiche à l'écran le message « Hello world! » (cela signifie quelque chose comme « Bonjour tout le monde ! »).

Oui, cela peut paraître un peu difficile la première fois mais nous allons voir ensemble, un peu plus loin, ce que signifie ce code.

Lancement du programme

Pour le moment, j'aimerais que vous fassiez une chose simple : essayez de compiler et de lancer ce premier programme. Vous vous souvenez comment faire ? Il y a un bouton « Compiler et exécuter » (Build and run). Ce bouton se trouve dans la barre d'outils (figure suivante).

La compilation se lance alors. Vous allez voir quelques messages s'afficher en bas de l'IDE (dans la section Build log).

Si tout va bien, une console apparaît avec notre programme (figure suivante).

Vous voyez que le programme affiche bel et bien « Hello world! » dans la console !

N'est-ce pas beau !? Vous venez de compiler votre tout premier programme !

Ah, bonne question !

Ce message n'a pas été écrit par votre programme mais par votre IDE. En l’occurrence, c'est Code::Blocks qui affiche un message pour signaler que le programme s'est bien déroulé et le temps qu'a duré son exécution.

Le but de Code::Blocks est ici surtout de « maintenir » la console ouverte. En effet, sous Windows en particulier, dès qu'un programme console est terminé, la fenêtre de la console se ferme. Or, le programme s'étant exécuté ici en 0.004s, vous n'auriez pas eu le temps de voir le message s'afficher à l'écran !

Code::Blocks vous invite donc à « appuyer sur n'importe quelle touche pour continuer », ce qui aura pour effet de fermer la console.

Lorsque Code::Blocks crée un nouveau projet, il génère un fichier main.cpp contenant ce code :

#include <iostream>

using namespace std;

int main()
{
    cout << "Hello world!" << endl;
    return 0;
}

Sans trop entrer dans les détails (car cela pourrait devenir compliqué pour un début !), je vais vous présenter à quoi sert chacune de ces lignes.

include

La toute première ligne est :

#include <iostream>

C'est ce qu'on appelle une directive de préprocesseur. Son rôle est de « charger » des fonctionnalités du C++ pour que nous puissions effectuer certaines actions.

En effet, le C++ est un langage très modulaire. De base, il ne sait pas faire grand-chose (pas même afficher un message à l'écran !). On doit donc charger des extensions que l'on appelle bibliothèques et qui nous offrent de nouvelles possibilités.

Ici, on charge le fichier iostream, ce qui nous permet d'utiliser une bibliothèque… d'affichage de messages à l'écran dans une console ! Quelque chose de vraiment très basique, comme vous le voyez, mais qui nécessite quand même l'utilisation d'une bibliothèque.

Plus tard, nous découvrirons de nouvelles bibliothèques et il faudra effectuer des inclusions en haut des codes source comme ici. Par exemple, lorsque nous étudierons Qt, qui permet de réaliser des programmes graphiques (GUI), on insérera une ligne comme celle-ci :

#include <Qt>

Notez qu'on peut charger autant de bibliothèques que l'on veut à la fois.

using namespace

La ligne :

using namespace std;

… permet en quelque sorte d'indiquer dans quel lot de fonctionnalités notre fichier source va aller piocher.

Si vous chargez plusieurs bibliothèques, chacune va proposer de nombreuses fonctionnalités. Parfois, certaines fonctionnalités ont le même nom. Imaginez une commande « AfficherMessage » qui s'appellerait ainsi pour iostream mais aussi pour Qt ! Si vous chargez les deux bibliothèques en même temps et que vous appelez « AfficherMessage », l'ordinateur ne saura pas s'il doit afficher un message en console avec iostream ou dans une fenêtre avec Qt !

Pour éviter ce genre de problèmes, on a créé des namespaces (espaces de noms), qui sont des sortes de dossiers à noms. La ligne using namespace std; indique que vous allez utiliser l'espace de noms std dans la suite de votre fichier de code. Cet espace de noms est un des plus connus car il correspond à la bibliothèque standard (std), une bibliothèque livrée par défaut avec le langage C++ et dont iostream fait partie.

int main()

C'est ici que commence vraiment le cœur du programme. Les programmes, vous le verrez, sont essentiellement constitués de fonctions. Chaque fonction a un rôle et peut appeler d'autres fonctions pour effectuer certaines actions.

Tous les programmes possèdent une fonction dénommée « main » (Qui se prononce « mèïne » en anglais.), ce qui signifie « principale ». C'est donc la fonction principale.

Une fonction a la forme suivante :

int main()
{
    
}

Les accolades déterminent le début et la fin de la fonction. Comme vous le voyez dans le code source qui a été généré par Code::Blocks, il n'y a rien après la fonction main. C'est normal : à la fin de la fonction main le programme s'arrête ! Tout programme commence au début de la fonction main et se termine à la fin de celle-ci.

Non ! Bien que ce soit possible, ce serait très délicat à gérer, surtout pour de gros programmes. À la place, la fonction main appelle d'autres fonctions qui, à leur tour, appellent d'autres fonctions. Bref, elle délègue le travail.

Cependant, dans un premier temps, nous allons surtout travailler dans la fonction main car nos programmes resteront assez simples.

cout

Voici enfin la première ligne qui fait quelque chose de concret ! C'est la première ligne de main, donc la première action qui sera exécutée par l'ordinateur (les lignes que nous avons vues précédemment ne sont en fait que des préparatifs pour le programme).

cout << "Hello world!" << endl;

Le rôle de cout (à prononcer « ci aoute ») est d'afficher un message à l'écran. C'est ce qu'on appelle une instruction. Tous nos programmes seront constitués d'instructions comme celle-ci, qui donnent des ordres à l'ordinateur.

Notez que cout est fourni par iostream. Si vous n'incluez pas iostream au début de votre programme, le compilateur se plaindra de ne pas connaître cout et vous ne pourrez pas générer votre programme !

Il y a 3 éléments sur cette ligne :

• cout : commande l'affichage d'un message à l'écran ;

• "Hello world!" : indique le message à afficher ;

• endl : crée un retour à la ligne dans la console.

Il est possible de combiner plusieurs messages en une instruction. Par exemple :

cout << "Bonjour tout le monde !" << endl << "Comment allez-vous ?" << endl;

… affiche ces deux phrases sur deux lignes différentes. Essayez ce code, vous verrez !

return

La dernière ligne est :

return 0;

Ce type d'instruction clôt généralement les fonctions. En fait, la plupart des fonctions renvoient une valeur (un nombre par exemple). Ici, la fonction main renvoie 0 pour indiquer que tout s'est bien passé (toute valeur différente de 0 aurait indiqué un problème).

Vous n'avez pas besoin de modifier cette ligne, laissez-la telle quelle. Nous aurons d'autres occasions d'utiliser return pour d'autres fonctions, nous en reparlerons !

En plus du code qui donne des instructions à l'ordinateur, vous pouvez écrire des commentaires pour expliquer le fonctionnement de votre programme.

Les commentaires n'ont aucun impact sur le fonctionnement de votre logiciel : en fait, le compilateur ne les lit même pas et ils n'apparaissent pas dans le programme généré. Pourtant, ces commentaires sont indispensables pour les développeurs : ils leur permettent d'expliquer ce qu'ils font dans leur code !

Dès que vos programmes vont devenir un petit peu complexes (et croyez-moi, cela ne tardera pas), vous risquez d'avoir du mal à vous souvenir de leur fonctionnement quelque temps après avoir écrit le code source. De plus, si vous envoyez votre code à un ami, il aura des difficultés pour comprendre ce que vous avez essayé de faire juste en lisant le code source. C'est là que les commentaires entrent en jeu !

Les différents types de commentaires

Il y a deux façons d'écrire des commentaires selon leur longueur. Je vais vous les présenter toutes les deux.

Les commentaires courts

Pour écrire un commentaire court, sur une seule ligne, il suffit de commencer par // puis d'écrire votre commentaire. Cela donne :

// Ceci est un commentaire

Mieux, vous pouvez aussi ajouter le commentaire à la fin d'une ligne de code pour expliquer ce qu'elle fait :

cout << "Hello world!" << endl; // Affiche un message à l'écran

Les commentaires longs

Si votre commentaire tient sur plusieurs lignes, ouvrez la zone de commentaire avec /* et fermez-la avec */ :

/* Le code qui suit est un peu complexe
alors je prends mon temps pour l'expliquer
parce que je sais que sinon, dans quelques semaines,
j'aurai tout oublié et je serai perdu pour le modifier */

En général, on n'écrit pas un roman dans les commentaires non plus… sauf si la situation le justifie vraiment.

Commentons notre code source !

Reprenons le code source que nous avons étudié dans ce chapitre et complétons-le de quelques commentaires pour nous souvenir de ce qu'il fait.

#include <iostream> // Inclut la bibliothèque iostream (affichage de texte)

using namespace std; // Indique quel espace de noms on va utiliser

/*
Fonction principale "main"
Tous les programmes commencent par la fonction main
*/
int main()
{
    cout << "Hello world!" << endl; // Affiche un message
    return 0; // Termine la fonction main et donc le programme
}

Si vous lancez ce programme, vous ne verrez aucune nouveauté. Les commentaires sont, comme je vous le disais, purement ignorés par le compilateur.

En résumé

• On distingue deux types de programmes : les programmes graphiques (GUI) et les programmes console.

• Il est plus simple de réaliser des programmes console pour commencer, c'est donc ce type de programme que nous étudierons en premier.

• Un programme possède toujours une fonction main() : c'est son point de démarrage.

• La directive cout permet d'afficher du texte dans une console.

• On peut ajouter des commentaires dans son code source pour expliquer son fonctionnement. Ils prennent la forme // Commentaire ou /* Commentaire */.

Je vous ai donné l'exemple de la mémoire de la calculatrice parce que dans le monde de l'informatique, le principe de base est le même. Il y a quelque part dans votre ordinateur des composants électroniques qui sont capables de contenir une valeur et de la conserver pendant un certain temps. La manière dont tout cela fonctionne exactement est très complexe.

Je vous rassure tout de suite, nous n'avons absolument pas besoin de comprendre comment cela marche pour pouvoir, nous aussi, mettre des valeurs dans la mémoire de l'ordinateur. Toute la partie compliquée sera gérée par le compilateur et le système d'exploitation. Elle n'est pas belle la vie ?

La seule et unique chose que vous ayez besoin de savoir, c'est qu'une variable est une partie de la mémoire que l'ordinateur nous prête pour y mettre des valeurs. Imaginez que l'ordinateur possède dans ses entrailles une grande armoire (figure suivante). Cette dernière possède des milliers (des milliards !) de petits tiroirs ; ce sont des endroits que nous allons pouvoir utiliser pour mettre nos variables.

Dans le cas d'une calculatrice toute simple, on ne peut généralement stocker qu'un seul nombre à la fois. Vous vous doutez bien que, dans le cas d'un programme, il va falloir conserver plus d'une chose simultanément. Il faut donc un moyen de différencier les variables pour pouvoir y accéder par la suite. Chaque variable possède donc un nom. C'est en quelque sorte l'étiquette qui est collée sur le tiroir.

L'autre chose qui distingue la calculatrice de l'ordinateur, c'est que nous aimerions pouvoir stocker des tas de choses différentes, des nombres, des lettres, des phrases, des images, etc. C'est ce qu'on appelle le type d'une variable. Vous pouvez vous imaginez cela comme étant la forme du tiroir. En effet, on n'utilise pas les mêmes tiroirs pour stocker des bouteilles ou des livres.

Les noms de variables

Commençons par la question du nom des variables. En C++, il y a quelques règles qui régissent les différents noms autorisés ou interdits.

• les noms de variables sont constitués de lettres, de chiffres et du tiret-bas _ uniquement ;

• le premier caractère doit être une lettre (majuscule ou minuscule) ;

• on ne peut pas utiliser d'accents ;

• on ne peut pas utiliser d'espaces dans le nom.

Le mieux est encore de vous donner quelques exemples. Les noms ageZero, nom_du_zero ou encore NOMBRE_ZEROS sont tous des noms valides. AgeZéro et _nomzero, en revanche, ne le sont pas.

À cela s'ajoute une règle supplémentaire, valable pour tout ce que l'on écrit en C++ et pas seulement pour les variables. Le langage fait la différence entre les majuscules et les minuscules. En termes techniques, on dit que C++ est sensible à la casse. Donc, nomZero, nomzero, NOMZERO et NomZeRo sont tous des noms de variables différents.

Personnellement, j'utilise une « convention » partagée par beaucoup de programmeurs. Dans tous les gros projets regroupant des milliers de programmeurs, on trouve des règles très strictes et parfois difficiles à suivre. Celles que je vous propose ici permettent de garder une bonne lisibilité et surtout, elles vous permettront de bien comprendre tous les exemples dans la suite de ce cours.

• les noms de variables commencent par une minuscule ;

• si le nom se décompose en plusieurs mots, ceux-ci sont collés les uns aux autres ;

• chaque nouveau mot (excepté le premier) commence par une majuscule.

Voyons cela avec des exemples. Prenons le cas d'une variable censée contenir l'âge de l'utilisateur du programme.

• AgeUtilisateur: non, car la première lettre est une majuscule ;

• age_utilisateur: non, car les mots ne sont pas collés ;

• ageutilisateur: non, car le deuxième mot ne commence pas par une majuscule ;

• maVar: non, car le nom ne décrit pas ce que contient la variable ;

• ageUtilisateur: ok.

Je vous conseille fortement d'adopter la même convention. Rendre son code lisible et facilement compréhensible par d'autres programmeurs est très important.

Les types de variables

Reprenons. Nous avons appris qu'une variable a un nom et un type. Nous savons comment nommer nos variables, voyons maintenant leurs différents types. L'ordinateur aime savoir ce qu'il a dans sa mémoire, il faut donc indiquer quel type d'élément va contenir la variable que nous aimerions utiliser. Est-ce un nombre, un mot, une lettre ? Il faut le spécifier.

Voici donc la liste des types de variables que l'on peut utiliser en C++.

Si vous tapez un de ces noms de types dans votre IDE, vous devriez voir le mot se colorer. L'IDE l'a reconnu, c'est bien la preuve que je ne vous raconte pas des salades. Le cas de string est différent, nous verrons plus loin pourquoi. Je peux vous assurer qu'on va beaucoup en reparler.

Quand on a besoin d'une variable, il faut donc se poser la question du genre de choses qu'elle va contenir. Si vous avez besoin d'une variable pour stocker le nombre de personnes qui utilisent votre programme, alors utilisez un int ou unsigned int, ; pour stocker le poids d'un gigot, on utilisera un double et pour conserver en mémoire le nom de votre meilleur ami, on choisira une chaîne de caractères string.

C'est ce qu'on appelle un booléen, c'est-à-dire une variable qui ne peut prendre que deux valeurs, vrai (true en anglais) ou faux (false en anglais). On les utilise par exemple pour stocker des informations indiquant si la lumière est allumée, si l'utilisateur a le droit d'utiliser une fonctionnalité donnée, ou encore si le mot de passe est correct.

Si vous avez besoin de conserver le résultat d'une question de ce genre, alors pensez à ce type de variable.

Assez parlé, il est temps d'entrer dans le vif du sujet et de demander à l'ordinateur de nous prêter un de ses tiroirs. En termes techniques, on parle de déclaration de variable.

Il nous faut indiquer à l'ordinateur le type de la variable que nous voulons, son nom et enfin sa valeur. Pour ce faire, c'est très simple : on indique les choses exactement dans l'ordre présenté à la figure suivante.

On peut aussi utiliser la même syntaxe que dans le langage C (figure suivante).

Les deux versions sont strictement équivalentes. Je vous conseille cependant d'utiliser la première pour des raisons qui deviendront claires plus tard. La deuxième version ne sera pas utilisée dans la suite du cours, je vous l'ai présentée ici pour que vous puissiez comprendre les nombreux exemples que l'on peut trouver sur le web et qui utilisent cette version de la déclaration d'une variable.

Reprenons le morceau de code minimal et ajoutons-y une variable pour stocker l'âge de l'utilisateur.

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(16);
    return 0;
}

Que se passe-t-il à la ligne 6 de ce programme ?

L'ordinateur voit que l'on aimerait lui emprunter un tiroir dans sa mémoire avec les propriétés suivantes :

• il peut contenir des nombres entiers ;

• il a une étiquette indiquant qu'il s'appelle ageUtilisateur ;

• il contient la valeur 16.

À partir de cette ligne, vous êtes donc l'heureux possesseur d'un tiroir dans la mémoire de l'ordinateur (figure suivante).

Comme nous allons avoir besoin de beaucoup de tiroirs dans la suite du cours, je vous propose d'utiliser des schémas un peu plus simples (figure suivante). On va beaucoup les utiliser par la suite, il est donc bien de s'y habituer tôt.

Je vais vous décrire ce qu'on voit sur le schéma. Le gros rectangle bleu représente la mémoire de l'ordinateur. Pour l'instant, elle est presque vide. Le carré jaune est la zone de mémoire que l'ordinateur nous a prêtée. C'est l'équivalent de notre tiroir. Il contient, comme avant, le nombre 16 et on peut lire le nom ageUtilisateur sur l'étiquette qui y est accrochée.

Je ne suis pas bon en dessin, donc il faut un peu d'imagination, mais le principe est là.

Ne nous arrêtons pas en si bon chemin. Déclarons d'autres variables.

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(16);
    int nombreAmis(432);      //Le nombre d'amis de l'utilisateur

    double pi(3.14159);

    bool estMonAmi(true);    //Cet utilisateur est-il mon ami ?

    char lettre('a');

    return 0;
}

Il y a deux choses importantes à remarquer ici. La première est que les variables de type bool ne peuvent avoir pour valeur que true ou false, c'est donc une de ces deux valeurs qu'il faut mettre entre les parenthèses. Le deuxième point à souligner, c'est que, pour le type char, il faut mettre la lettre souhaitée entre apostrophes. Il faut écrire char lettre('a'); et pas char lettre(a);. C'est une erreur que tout le monde fait, moi le premier.

Je peux donc compléter mon schéma en lui ajoutant nos nouvelles variables (figure suivante).

Vous pouvez évidemment compiler et tester le programme ci-dessus. Vous constaterez qu'il ne fait strictement rien. J'espère que vous n'êtes pas trop déçus. Il se passe en réalité énormément de choses mais, comme je vous l'ai dit au début, ces opérations sont cachées et ne nous intéressent pas vraiment. En voici quand même un résumé chronologique.

1. votre programme demande au système d'exploitation de lui fournir un peu de mémoire ;

2. l'OS (Operating System ou, en français, système d'exploitation.) regarde s'il en a encore à disposition et indique au programme quel tiroir utiliser ;

3. le programme écrit la valeur 16 dans la case mémoire ;

4. il recommence ensuite pour les quatre autres variables ;

5. en arrivant à la dernière ligne, le programme vide ses tiroirs et les rend à l'ordinateur.

Et tout cela sans que rien ne se passe du tout à l'écran ! C'est normal, on n'a nulle part indiqué qu'on voulait afficher quelque chose.

Le cas des strings

Les chaînes de caractères sont un petit peu plus complexes à déclarer mais rien d'insurmontable, je vous rassure. La première chose à faire est d'ajouter une petite ligne au début de votre programme. Il faut, en effet, indiquer au compilateur que nous souhaitons utiliser des strings. Sans cela, il n'inclurait pas les outils nécessaires à leur gestion. La ligne à ajouter est #include <string>.

Voici ce que cela donne.

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string nomUtilisateur("Albert Einstein");
    return 0;
}

L'autre différence se situe au niveau de la déclaration elle-même. Comme vous l'avez certainement constaté, j'ai placé des guillemets autour de la valeur. Un peu comme pour les char mais, cette fois, ce sont des guillemets doubles (") et pas juste des apostrophes ('). D'ailleurs votre IDE devrait colorier les mots "Albert Einstein" d'une couleur différente du 'a' de l'exemple précédent. Confondre ' et " est une erreur, là encore, très courante qui fera hurler de douleur votre compilateur. Mais ne vous en faites pas pour lui, il en a vu d'autres.

Une astuce pour gagner de la place

Avant de passer à la suite, il faut que je vous présente une petite astuce utilisée par certains programmeurs.

Si vous avez plusieurs variables du même type à déclarer, vous pouvez le faire sur une seule ligne en les séparant par une virgule (,). Voici comment :

int a(2),b(4),c(-1);  //On déclare trois cases mémoires nommées a, b et c et  qui contiennent respectivement les valeurs 2, 4 et -1

string prenom("Albert"), nom("Einstein"); //On déclare deux cases pouvant contenir des chaînes de caractères

Ça peut être pratique quand on a besoin de beaucoup de variables d'un coup. On économise la répétition du type à chaque variable. Mais je vous déconseille quand même de trop abuser de cette astuce : le programme devient moins lisible et moins compréhensible.

Maintenant que nous avons vu le principe général, il est temps de plonger un petit peu plus dans les détails.

Lors de la déclaration d'une variable, votre programme effectue en réalité deux opérations successives.

1. Il demande à l'ordinateur de lui fournir une zone de stockage dans la mémoire. On parle alors d'allocation de la variable.

2. Il remplit cette case avec la valeur fournie. On parle alors d'initialisation de la variable.

Ces deux étapes s'effectuent automatiquement et sans que l'on ait besoin de rien faire. Voilà pour la partie vocabulaire de ce chapitre.

Il arrive parfois que l'on ne sache pas quelle valeur donner à une variable lors de sa déclaration. Il est alors possible d'effectuer uniquement l'allocation sans l'initialisation.

Il suffit d'indiquer le type et le nom de la variable sans spécifier de valeur (figure suivante).

Et sous forme de code C++ complet, voilà ce que cela donne :

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string nomJoueur;  
    int nombreJoueurs;
    bool aGagne;         //Le joueur a-t-il gagné ?

    return 0;
}

Simple non ? Je savais que cela allait vous plaire. Et je vous offre même un schéma en bonus (figure suivante) !

On a bien trois cases dans la mémoire et les trois étiquettes correspondantes. La chose nouvelle est que l'on ne sait pas ce que contiennent ces trois cases. Nous verrons dans le chapitre suivant comment modifier le contenu d'une variable et donc remplacer ces points d'interrogation par d'autres valeurs plus intéressantes.

Il est temps d'apprendre à effectuer quelques opérations avec nos variables parce que vous en conviendrez, pour l'instant, on n'a pas appris grand chose d'utile. Notre écran est resté désespérément vide.

Au chapitre précédent, vous avez appris à afficher du texte à l'écran. J'espère que vous vous souvenez encore de ce qu'il faut faire.

Oui, c'est bien cela. Il faut utiliser cout et les chevrons (<<). Parfait. En effet, pour afficher le contenu d'une variable, c'est la même chose. À la place du texte à afficher, on met simplement le nom de la variable.

cout << ageUtilisateur;

Facile non ?

Prenons un exemple complet pour essayer.

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(16);
    cout << "Votre age est : ";
    cout << ageUtilisateur;
    return 0;
}

Une fois compilé, ce code affiche ceci à l'écran:

Votre age est : 16

Exactement ce que l'on voulait ! On peut même faire encore plus simple : tout mettre sur une seule ligne ! Et on peut même ajouter un retour à la ligne à la fin.

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(16);
    cout << "Votre age est : " << ageUtilisateur << endl;
    return 0;
}

Et on peut même afficher le contenu de plusieurs variables à la fois.

#include <iostream>
#include <string>
using namespace std;

int main()
{
    int qiUtilisateur(150);
    string nomUtilisateur("Albert Einstein");
    
    cout << "Vous vous appelez " << nomUtilisateur << " et votre QI vaut " << qiUtilisateur << endl;
    return 0;
}

Ce qui affiche le résultat escompté.

Vous vous appelez Albert Einstein et votre QI vaut 150

Mais je pense que vous n'en doutiez pas vraiment. Nous verrons au prochain chapitre comment faire le contraire, c'est-à-dire récupérer la saisie d'un utilisateur et la stocker dans une variable.

Avant de terminer ce chapitre, il nous reste une notion importante à voir. Il s'agit des références. Je vous ai expliqué au tout début de ce chapitre qu'une variable pouvait être considérée comme une case mémoire avec une étiquette portant son nom. Dans la vraie vie, on peut très bien mettre plusieurs étiquettes sur un objet donné. En C++, c'est la même chose, on peut coller une deuxième (troisième, dixième, etc.) étiquette à une case mémoire.

On obtient alors un deuxième moyen d'accéder à la même case mémoire. Un petit peu comme si on donnait un surnom à une variable en plus de son nom normal. On parle parfois d'alias, mais le mot correct en C++ est référence.

Schématiquement, on peut se représenter une référence comme à la figure suivante.

On a une seule case mémoire mais deux étiquettes qui lui sont accrochées.

Au niveau du code, on utilise une esperluette (&) pour déclarer une référence sur une variable. Voyons cela avec un petit exemple.

int ageUtilisateur(16);  //Déclaration d'une variable.

int& maVariable(ageUtilisateur); //Déclaration d'une référence nommée maVariable qui est accrochée à la variable ageUtilisateur

À la ligne 1, on déclare une case mémoire nommée ageUtilisateur dans laquelle on met le nombre 16. Et à la ligne 3, on accroche une deuxième étiquette à cette case mémoire. On a donc dorénavant deux moyens d'accéder au même espace dans la mémoire de notre ordinateur.

On dit que maVariablefait référence à ageUtilisateur.

Essayons pour voir. On peut afficher l'âge de l'utilisateur comme d'habitude etvia une référence.

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(18); //Une variable pour contenir l'âge de l'utilisateur
    
    int& maReference(ageUtilisateur); //Et une référence sur la variable 'ageUtilisateur'

    //On peut utiliser à partir d'ici
    //'ageUtilisateur' ou 'maReference' indistinctement
    //Puisque ce sont deux étiquettes de la même case en mémoire

    cout << "Vous avez " << ageUtilisateur << "  ans. (via variable)" << endl;
    //On affiche, de la manière habituelle

    cout << "Vous avez " << maReference << " ans. (via reference)" << endl;
    //Et on affiche en utilisant la référence
    
    return 0;
}

Ce qui donne évidemment le résultat escompté.

Vous avez 18 ans. (via variable)
Vous avez 18 ans. (via reference)

Une fois qu'elle a été déclarée, on peut manipuler la référence comme si on manipulait la variable elle-même. Il n'y a aucune différence entre les deux.

Bonne question ! C'est vrai que, dans l'exemple que je vous ai donné, on peut très bien s'en passer. Mais imaginez que l'on ait besoin de cette variable dans deux parties très différentes du programme, des parties créées par différents programmeurs. Dans une des parties, un des programmeurs va s'occuper de la déclaration de la variable alors que l'autre programmeur va juste l'afficher. Ce deuxième programmeur aura juste besoin d'un accès à la variable et un alias sera donc suffisant.

Pour l'instant, cela vous paraît très abstrait et inutile ? Il faut juste savoir que c'est un des éléments importants du C++ qui apparaîtra à de très nombreuses reprises dans ce cours. Il est donc essentiel de se familiariser avec la notion avant de devoir l'utiliser dans des cas plus compliqués.

En résumé

• Une variable est une information stockée en mémoire.

• Il existe différents types de variables en fonction de la nature de l'information à stocker : int, char, bool…

• Une variable doit être déclarée avant utilisation. Exemple : int ageUtilisateur(16);

• La valeur d'une variable peut être affichée à tout moment avec cout.

• Les références sont des étiquettes qui permettent d'appeler une variable par un autre nom. Exemple : int& maReference(ageUtilisateur);

Au chapitre précédent, je vous ai expliqué comment afficher des variables dans la console. Voyons maintenant comment faire le contraire, c'est-à-dire demander des informations à l'utilisateur pour les stocker dans la mémoire.

Lecture depuis la console

Vous l'aurez remarqué, le C++ utilise beaucoup de mots tirés de l'anglais. C'est notamment le cas pour le flux sortant cout, qui doit se lire « c-out ». Ce qui est bien, c'est qu'on peut immédiatement en déduire le nom du flux entrant. Avec cout, les données sortent du programme, d'où l'élément out. Le contraire de out en anglais étant in, qui signifie « vers l'intérieur », on utilise cin pour faire entrer des informations dans le programme. cin se décompose aussi sous la forme « c-in » et se prononce « si-inne ». C'est important pour les soirées entre programmeurs.

Ce n'est pas tout ! Associés à cout, il y avait les chevrons (<<). Dans le cas de cin, il y en a aussi, mais dans l'autre sens (>>).

Voyons ce que cela donne avec un premier exemple.

#include <iostream>
using namespace std;

int main()
{
    cout << "Quel age avez-vous ?" << endl;

    int ageUtilisateur(0); //On prepare une case mémoire pour stocker un entier

    cin >> ageUtilisateur; //On fait entrer un nombre dans cette case

    cout << "Vous avez " << ageUtilisateur << " ans !" <<  endl; //Et on l'affiche

    return 0;
}

Je vous invite à tester ce programme. Voici ce que cela donne avec mon âge :

Quel age avez-vous ?
23
Vous avez 23 ans !

Le programme a affiché le texte Quel age avez-vous ?. Jusque-là, rien de bien sorcier. Puis, comme on l'a vu précédemment, à la ligne 8, le programme demande à l'ordinateur une case mémoire pour stocker un int et il baptise cette case ageUtilisateur.

Ensuite, cela devient vraiment intéressant. L'ordinateur affiche un curseur blanc clignotant et attend que l'utilisateur écrive quelque chose. Quand celui-ci a terminé et appuyé sur la touche Entrée de son clavier, le programme prend ce qui a été écrit et le place dans la case mémoire ageUtilisateurà la place du 0 qui s'y trouvait.

Finalement, on retombe sur quelque chose de connu, puisque le programme affiche une petite phrase et le contenu de la variable.

Une astuce pour les chevrons

Il arrive souvent que l'on se trompe dans le sens des chevrons. Vous ne seriez pas les premiers à écrire cout >> ou cin <<, ce qui est faux.

Pour se souvenir du sens correct, je vous conseille de considérer les chevrons comme si c'étaient des flèches indiquant la direction dans laquelle les données se déplacent. Depuis la variable vers cout ou depuis cin vers votre variable.

Le mieux est de prendre un petit schéma magique (figure suivante).

Quand on affiche la valeur d'une variable, les données sortent du programme, on utilise donc une flèche allant de la variable vers cout. Quand on demande une information à l'utilisateur, c'est le contraire, la valeur vient de cin et va dans la variable.

Avec cela, plus moyen de se tromper !

D'autres variables

Évidemment, ce que je vous ai présenté marche aussi avec d'autres types de variables. Voyons cela avec un petit exemple.

#include <iostream>
#include <string>
using namespace std;

int main()
{
    cout << "Quel est votre prenom ?" << endl;
    string nomUtilisateur("Sans nom"); //On crée une case mémoire pour contenirune chaine de caractères
    cin >> nomUtilisateur; //On remplit cette case avec ce qu'écrit l'utilisateur

    cout << "Combien vaut pi ?" << endl;
    double piUtilisateur(-1.); //On crée une case mémoire pour stocker un nombre réel
    cin >> piUtilisateur; //Et on remplit cette case avec ce qu'écritl'utilisateur
     
    cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que pivaut " << piUtilisateur << "." << endl;

    return 0;
}

Je crois que je n'ai même pas besoin de donner d'explications. Je vous invite néanmoins à tester pour bien comprendre en détail ce qui se passe.

Le problème des espaces

Avez-vous testé le code précédent en mettant vos nom et prénom ? Regardons ce que cela donne.

Quel est votre prenom ?
Albert Einstein
Combien vaut pi ?
Vous vous appelez Albert et vous pensez que pi vaut 0.

C'est un problème d'espaces. Quand on appuie sur la touche Entrée, l'ordinateur copie ce qui a été écrit par l'utilisateur dans la case mémoire. Mais il s'arrête au premier espace ou retour à la ligne. Quand il s'agit d'un nombre, cela ne pose pas de problème puisqu'il n'y a pas d'espace dans les nombres.

Pour les string, la question se pose. Il peut très bien y avoir un espace dans une chaîne de caractères. Et donc l'ordinateur va couper au mauvais endroit, c'est-à-dire après le premier mot. Et comme il n'est pas très malin, il va croire que le nom de famille correspond à la valeur de pi !

En fait, il faudrait pouvoir récupérer toute la ligne plutôt que seulement le premier mot. Et si je vous le propose, c'est qu'il y a une solution pour le faire !

Il faut utiliser la fonctiongetline(). Nous verrons plus loin ce que sont exactement les fonctions mais, pour l'instant, voyons comment faire dans ce cas particulier.

Il faut remplacer la ligne cin >> nomUtilisateur; par un getline().

#include <iostream>
#include <string>
using namespace std;

int main()
{
    cout << "Quel est votre nom ?" << endl;
    string nomUtilisateur("Sans nom"); //On crée une case mémoire pour contenir une chaine de caractères
    getline(cin, nomUtilisateur); //On remplit cette case avec toutela ligne que l'utilisateur a écrit

    cout << "Combien vaut pi ?" << endl;
    double piUtilisateur(-1.); //On crée une case mémoire pour stockerun nombre réel
    cin >> piUtilisateur; //Et on remplit cette case avec ce qu'écritl'utilisateur
     
    cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que pivaut " << piUtilisateur << "." << endl;

    return 0;
}

On retrouve les mêmes éléments qu'auparavant. Il y a cin et il y a le nom de la variable (nomUtilisateur) sauf que, cette fois, ces deux éléments se retrouvent encadrés par des parenthèses et séparés par une virgule au lieu des chevrons.

Cette fois le nom ne sera pas tronqué lors de la lecture et notre ami Albert pourra utiliser notre programme sans soucis.

Quel est votre nom ?
Albert Einstein
Combien vaut pi ?
3.14
Vous vous appelez Albert Einstein et vous pensez que pi vaut 3.14.

Demander d'abord la valeur de pi

Si l'on utilise d'abord cin >> puis getline(), par exemple pour demander la valeur de pi avant de demander le nom, le code ne fonctionne pas. L'ordinateur ne demande pas son nom à l'utilisateur et affiche n'importe quoi.

Pour pallier ce problème, il faut ajouter la ligne cin.ignore() après l'utilisation des chevrons.

#include <iostream>
#include <string>
using namespace std;

int main()
{
    cout << "Combien vaut pi ?" << endl;
    double piUtilisateur(-1.); //On crée une case mémoire pour stocker unnombre réel
    cin >> piUtilisateur; //Et on remplit cette case avec ce qu'écritl'utilisateur

    cin.ignore();

    cout << "Quel est votre nom ?" << endl;
    string nomUtilisateur("Sans nom"); //On crée une case mémoire pour contenir une chaine de caractères
    getline(cin, nomUtilisateur); //On remplit cette case avec toute la ligne que l'utilisateur a écrit
     
    cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que pivaut " << piUtilisateur << "." << endl;

    return 0;
}

Avec cela, plus de souci.

Quand on mélange l'utilisation des chevrons et de getline(), il faut toujours placer l'instruction cin.ignore() après la ligne cin>>a. C'est une règle à apprendre.

Voyons maintenant ce que l'on peut faire avec des variables, par exemple additionner deux nombres.

Changer le contenu d'une variable

Je vous ai expliqué dans l'introduction de ce chapitre que la mémoire de l'ordinateur ressemble, dans sa manière de fonctionner, à celle d'une calculatrice. Ce n'est pas la seule similitude. On peut évidemment effectuer des opérations de calcul sur un ordinateur. Et cela se fait en utilisant des variables.

Commençons par voir comment modifier le contenu d'une variable. On utilise le symbole = pour effectuer un changement de valeur. Si j'ai une variable de type int dont je veux modifier le contenu, j'écris le nom de ma variable suivi du symbole = et enfin de la nouvelle valeur. C'est ce qu'on appelle l'affectation d'une variable.

int unNombre(0); //Je crée une case mémoire nommée 'unNombre' et qui contientle nombre 0

unNombre = 5; //Je mets 5 dans la case mémoire 'unNombre'

On peut aussi directement affecter le contenu d'une variable à une autre

int a(4), b(5); //Déclaration de deux variables

a = b; //Affectation de la valeur de 'b' à 'a'.

Quand il arrive à la ligne 3 du code précédent, l'ordinateur lit le contenu de la case mémoire nommée b, soit le nombre 5. Il ouvre ensuite la case dont le nom est a et y écrit la valeur 5 en remplaçant le 4 qui s'y trouvait. Voyons cela avec un schéma (figure suivante).

On peut d'ailleurs afficher le contenu des deux variables pour vérifier.

#include <iostream>
using namespace std;

int main()
{
    int a(4), b(5); //Déclaration de deux variables

    cout << "a vaut : " << a << " et b vaut : " << b << endl;

    cout << "Affectation !" << endl;
    a = b; //Affectation de la valeur de 'b' à 'a'.

    cout << "a vaut : " << a << " et b vaut : " << b << endl;

    return 0;
}

Avez-vous testé ? Non ? N'oubliez pas qu'il est important de tester les codes proposés pour bien comprendre. Bon, comme je suis gentil, je vous donne le résultat.

a vaut : 4 et b vaut : 5 
Affectation !
a vaut : 5 et b vaut : 5

Exactement ce que je vous avais prédit.

C'est un bon début mais on est encore loin d'une calculatrice. Il nous manque… les opérations !

Une vraie calculatrice de base !

Commençons avec l'opération la plus simple : l'addition bien sûr. Et je pense que je ne vais pas trop vous surprendre en vous disant qu'on utilise le symbole +.

C'est vraiment très simple à faire :

int a(5), b(8), resultat(0);

resultat = a + b; //Et hop une addition pour la route!

Comme c'est votre première opération, je vous décris ce qui se passe précisément. À la ligne 1, le programme crée dans la mémoire trois cases, dénommées a, b et resultat. Il remplit également ces cases respectivement avec les valeurs 5, 8 et 0. Tout cela, on commence à connaître.

On arrive ensuite à la ligne 3. L'ordinateur voit qu'il doit modifier le contenu de la variable resultat. Il regarde alors ce qu'il y a de l'autre côté du symbole = et il remarque qu'il doit faire la somme des contenus des cases mémoire a et b. Il regarde alors le contenu de a et de bsans le modifier, effectue le calcul et écrit la somme dans la variable resultat. Tout cela en un éclair. Pour calculer, l'ordinateur est un vrai champion.

Si vous voulez, on peut même vérifier que cela fonctionne.

#include <iostream>
using namespace std;

int main()  
{
  int resultat(0), a(5), b(8);

  resultat = a + b;

  cout << "5 + 8 = " << resultat << endl;
  return 0;
}

Sur votre écran vous devriez voir :

5 + 8 = 13

Ce n'est pas tout, il existe encore quatre autres opérations. Je vous ai mis un résumé des possibilités dans un tableau récapitulatif.

Je suis sûr que si, mais pas forcément sous ce nom là. Il s'agit en fait du reste de la division entière. Par exemple, si vous ressortez vos cahiers d'école, vous devriez retrouver des calculs tels que 13 divisé par 3.

On obtient un nombre entier dénommé « quotient » (en l'occurrence, il vaut 4 mais, comme 13 n'est pas un multiple de 3, il faut compléter 3 imes 4 par quelque chose (ici, 1) pour obtenir exactement 13. C'est ce « quelque chose » qu'on appelle le reste de la division. Avec notre exemple, on peut donc écrire 13 = 4 imes 3 + 1, c'est-à-dire 13 = quotient imes 3 + reste. L'opérateur modulo calcule ce reste de la division. Peut-être en aurez-vous besoin un jour.

À partir des opérations de base, on peut tout à fait écrire des expressions mathématiques plus complexes qui nécessitent plusieurs variables. On peut également utiliser des parenthèses si nécessaire.

int a(2), b(4), c(5), d; //Quelques variables
d = ((a+b) * c ) - c; //Un calcul compliqué !

La seule limite est votre imagination. Toute expression valide en maths l'est aussi en C++.

Je vous ai présenté comment modifier des variables. J'espère que vous avez bien compris ! Parce qu'on va faire le contraire, en quelque sorte. Je vais vous montrer comment déclarer des variables non modifiables.

En termes techniques, on parle de constantes. Cela fait beaucoup de termes techniques pour un seul chapitre mais je vous promets que, dans la suite, cela va se calmer.

Ah, je savais que vous alliez poser cette question. Je vous ai donc préparé une réponse aux petits oignons.

Prenons le futur jeu vidéo révolutionnaire que vous allez créer. Comme vous êtes très forts, je pense qu'il y aura plusieurs niveaux, disons 10. Eh bien ce nombre de niveaux ne va jamais changer durant l'exécution du programme. Entre le moment où l'utilisateur lance le jeu et le moment où il le quitte, il y a en permanence 10 niveaux dans votre jeu. Ce nombre est constant. En C++, on pourrait donc créer une variable nombreNiveaux qui serait une constante.

Ce n'est, bien sûr, pas le seul exemple. Pensez à une calculatrice, qui aura besoin de la constante \pi, ou bien à un jeu dans lequel les personnages tombent et où il faudra utiliser la constante d'accélération de la pesanteur g=9.81, et ainsi de suite.

Ces valeurs ne vont jamais changer. \pi vaudra toujours 3.14 et l'accélération sur Terre est partout identique. Ce sont des constantes. On peut même ajouter que ce sont des constantes dont on connaît la valeur lors de la rédaction du code source.

Mais ce n'est pas tout. Il existe aussi des variables dont la valeur ne change jamais mais dont on ne connaît pas la valeur à l'avance. Prenons le résultat d'une opération dans une calculatrice. Une fois que le calcul est effectué, le résultat ne change plus. La variable qui contient le résultat est donc une constante.

Voyons donc comment déclarer une telle variable.

Déclarer une constante

C'est très simple. On déclare une variable normale et on ajoute le mot-clé const entre le type et le nom.

int const nombreNiveaux(10);

Cela marche bien sûr avec tous les types de variables.

string const motDePasse("wAsTZsaswQ"); //Le mot de passe secret
double const pi(3.14);
unsigned int const pointsDeVieMaximum(100); //Le nombre maximal de points de vie

Je pourrais continuer encore longtemps mais je pense que vous avez saisi le principe. Vous n'êtes pas des futurs génies de l'informatique pour rien.

Vous verrez, on reparlera des constantes dans les prochains chapitres. En attendant, préparez-vous pour votre premier exercice.