PROGRAMMATION C++

Le C++ est le descendant du langage C. Ces deux langages, bien que semblables au premier abord, sont néanmoins
différents. Le C++ propose de nouvelles fonctionnalités qui permettent de programmer avec une approche différente.

À la fin de ce cours, vous serez capable de :

 Faire vos premiers pas et mobiliser les notions de bases du C++ (variables, conditions, boucles),
 Manipuler des notions avancées du C++ (fonctions, tableaux, pointeurs).

Outil nécessaire :
 Un éditeur de code comme Code::Blocks (mac, Windows, Linux).

Débuter avec C++

1. Installer Visual Studio Code
2. Créez votre premier projet
Pour cela, passez par "File" > "New" > "Project".
La ligne #include
charge le fichier iostream , ce qui nous permet d'utiliser une bibliothèque… d'affichage de messages à l'écran dans une
console !

La ligne using namespace

Si vous chargez plusieurs bibliothèques, chacune va proposer de nombreuses fonctionnalités. Certaines fonctionnalités ont
le même nom.

using namespace std; indique que vous allez utiliser std (la libraire standard de iostream) dans la suite de votre fichier
de code.

La ligne int main()

Tous les programmes possèdent une fonction main (principale, en français).
La ligne cout
Le rôle de cout (à prononcer "c" "out") est d'afficher un message à l'écran.

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

1. cout commande l'affichage d'un message à l'écran.

2. "Hello world!" indique le message à afficher.
3. endl crée un retour à la ligne dans la console.
4. Il est possible de combiner plusieurs messages en une instruction :
5. cout << "Bonjour tout le monde !" << endl << "Comment allez-vous ?" << endl;

N'oubliez pas d’utiliser endl pour réaliser des retours à la ligne, et de séparer chaque morceau de texte par les
chevrons <<

La ligne return

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).

Commentez votre code

  Les commentaires courts, sur une seule ligne. Ils commencent par // et sont placés au-dessus d'une ligne
de code ou au bout :
 Les commentaires longs, sur plusieurs lignes, s'ouvrent avec /* et se ferment avec*/

Déclarez une variable et affichez sa valeur

Les règles en C++ pour nommer correctement une variable :

 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 ;
 utiliser des noms de variables qui décrivent bien ce qu'elles contiennent.

En plus de ces règles, il existe une convention partagée par beaucoup de programmeurs, pour harmoniser les
noms de variables et améliorer la lisibilité :

 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.

Attribuez un type à chaque variable

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

Nom du type Ce qu'il peut contenir

bool Une valeur parmi deux possibles, vrai (true) ou faux (false).
Nom du type Ce qu'il peut contenir

char Un caractère.

int Un nombre entier.

unsigned int Un nombre entier positif ou nul.

double Un nombre à virgule.

string Une chaîne de caractères, c'est-à-dire un mot ou une phrase.

Déclarez une variable
Pour déclarer une variable, il faut écrire un code qui indique, dans l'ordre :

1. Son type.
2. Son nom.
3. Et la valeur qu'elle contient :
TYPE NOM(VALEUR);

int ageUtilisateur(16);

L'ordinateur voit qu'on veut 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.
#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;

Dans ce programme, nous n'avons pas encore déclaré de variables de type string. Et en fait, la procédure est un
peu particulière. En plus de la déclaration classique, il faut :

 ajouter une ligne au début de votre programme, qui demande au compilateur d'inclure les outils
nécessaires à la gestion des strings, #include <string> :

 #include <iostream>
 #include <string>
 using namespace std;

 int main()
 {
 string nomUtilisateur("Albert Einstein");
 return 0;
 }
string prenom("Albert"), nom("Einstein");
D'ordinaire, lors de la déclaration d'une variable, votre programme effectue automatiquement 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.
Quand on ne sait pas quelle valeur donner à une variable lors de sa déclaration, il est possible d'effectuer une allocation sans
initialisation.

Il suffit d'indiquer le type et le nom de la variable, sans spécifier de valeur : TYPE NOM;

Affichez la valeur d'une variable

cout << ageUtilisateur;

int ageUtilisateur(16);
cout << "Votre age est : " << ageUtilisateur << endl;

On peut aussi 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;

Utilisez les références

Une variable peut ê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 fait, c'est la même chose en C++ : on peut coller une deuxième étiquette à une case mémoire (et même plus, si
on veut). On obtient alors un deuxième moyen d'accéder à la même case mémoire.

C'est un 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.

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 :

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 maVariable fait référence
à ageUtilisateur .

La référence doit impérativement être du même type que la variable à laquelle elle est accrochée ! Un int& ne peut faire
référence qu'à un int , de même qu'un string& ne peut être associé qu'à une variable de type string .

#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 :

Vous avez 18 ans. (via variable)

Vous avez 18 ans. (via reference)

En résumé
 Une variable est une information stockée en mémoire.
  Les noms de variables peuvent contenir des lettres, des chiffres et des tirets bas _ uniquement ; le
premier caractère doit être une lettre ; on ne peut pas utiliser d'accents ou d'espaces.
 C++ est sensible à la casse ; agemathieu est donc différent de ageMathieu .
 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); .

 Question 1

Vous souhaitez lancer le programme ci-dessous mais il ne compile pas !

int main()

std::cout<< "Le QUIZ est trop simple !" << std::endl;

return 0;

Quelle bibliothèque devez-vous absolument inclure dans le programme pour utiliser les fonctions d’affichage
et de saisie ?

o
 o #include <stdlib.h>

o #include <iostream>

o #include <stdio.h>

o #include <display>

 Question 2

Maintenant, vous allez simplifier le code en évitant de répéter l'espace de nommage std::.
Quelle instruction devez-vous ajouter après avoir inclues les bibliothèques pour pouvoir accéder à l’espace de
nommage de la bibliothèque standard ?

o using namespace std;

o namespace std;

o using std;

o using std namespace;

 Question 3

Quelles sont les bonnes méthodes pour ajouter des commentaires dans le code ?

Attention, plusieurs réponses sont possibles.

o #include <iostream> # Inclut la bibliothèque iostream

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

o # Fonction principale main

o # Tous les programmes commencent par la fonction main

o int main()

o {

o cout<< "J'adore ce QUIZ !" << endl; # Affiche un message

o return 0; # Termine la fonction main et donc le programme

o }
o

o #include <iostream> //Inclut la bibliothèque iostream

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

o /*

o Fonction principale main

o #Tous les programmes commencent par la fonction main

o */

o int main()

o {

o cout<< "J'adore ce QUIZ !" << endl; //Affiche un message

o return 0; //Termine la fonction main et donc le programme

o }

o
o #include <iostream> <!-- Inclut la bibliothèque iostream -->

o using namespace std; <!-- Indique quel espace de noms on va utiliser

o <!-- Fonction principale main

o #Tous les programmes commencent par la fonction main -->

o int main()

o {

o cout<< "J'adore ce QUIZ !" << endl; <!-- Affiche un message -->

o return 0; <!-- Termine la fonction main et donc le programme -->

o }

o #include <iostream> //Inclut la bibliothèque iostream

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

o

o //Fonction principale main

o //Tous les programmes commencent par la fonction main

o int main()

o {

o cout<< "J'adore ce QUIZ !" << endl; //Affiche un message

o return 0; //Termine la fonction main et donc le programme

o }

 Question 4

Vous souhaitez créer une variable qui contiendra un nombre décimal. Quel type est le plus adapté pour
stocker ce chiffre sans perdre d'information ?

bool

char

o
 int

double

 Question 5

Vous souhaitez créer une variable nommée booleen contenant un booléen initialisé à faux.
Quelle instruction choisissez-vous ?

o bool booleen(false);

o booleen bool = false;

o bool boolean = False;

o bool false = booleen;

 Question 6

Considérez le code suivant :

#include <iostream>
 using namespace std;

int main()

double pi(3.1415);

return 0;

}
Quelle instruction faut-il ajouter après la déclaration de la variable pi pour afficher la valeur contenue dans
cette variable ?

o cout >> pi;

o cout << pi

o cout < pi;

o cout << pi;

 Question 7
 Considérez le code suivant :

#include <iostream>

using namespace std;

int main()

int longueur(2);

}
Comment créer une référence de la variable longueur que vous nommerez largeur ?

o int largeur(longueur);

o int& largeur(longueur);

o int largeur&(longueur);

o int* largeur(longueur);
 Question 8

Dans le code ci-dessous, quelle est la valeur qui sera affichée dans la console à la fin du programme ?

#include <iostream>

using namespace std;

int main()

int variable(12);

int& reference(variable);

variable = 27;

reference++;

cout << reference;

27

o
 12

28

13

Manipulez les variables pour faire des calculs

Stockez les informations données par l'utilisateur

 cout (qui se prononce "c-out "), associé aux chevrons << , permet de faire sortir les données du
programme.
 cin ("c-in"), associé aux chevrons >> , permet de faire entrer des informations dans le programme.

#include <iostream>

using namespace std;

int main()

cout << "Quel age avez-vous ?" << endl;

 int ageUtilisateur(0); //On prépare 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;

Évidemment, ce que je vous ai présenté marche aussi avec d'autres types de variables :

nclude <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 contenir une 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'écrit l'utilisateur

cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que pi vaut " << piUtilisateur << "." << endl;

return 0;

L'ordinateur n'a rien demandé pour pi, et le nom de famille a disparu ! Que s'est-il passé ?
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.
Il faudrait récupérer toute la ligne, pas juste le premier mot. Et si je vous en parle, c'est qu'il y a une solution pour
le faire : la fonction getline() .
Il faut remplacer cin >> nomUtilisateur; par getline(cin, nomUtilisateur) :

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

Opération Symbole Exemple

Addition + resultat = a + b;

Soustraction - resultat = a - b;

Multiplication * resultat = a * b;

Division / resultat = a / b;

Modulo % resultat = a % b;

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 pi vaut " << 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.

Changez le contenu d'une variable

On utilise le symbole = pour effectuer un changement de valeur.

Pour modifier le contenu d'une variable de type int , on écrit le nom de la variable suivi du symbole = puis 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 contient le 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'.

Utilisez les variables pour faire des calculs
Commençons avec une addition. Je ne vais pas trop vous surprendre en vous disant qu'on utilise le symbole + :

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

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

Opération Symbole Exemple

Addition + resultat = a + b;

Soustraction - resultat = a - b;

Multiplication * resultat = a * b;

Division / resultat = a / b;

Modulo % resultat = a % b;

Déclarez une variable non modifiable (constante)

Pour déclarer une constante, on ajoute le mot-clé const entre le type et le nom :

int const nombreNiveaux(10);

Exercice
1. Demander deux nombres à l'utilisateur.
2. Calculer la somme de ces deux nombres.
3. Et afficher le résultat.

Utilisez les raccourcis

Ajoutez "1" à une variable avec l'incrémentation

Une des opérations les plus courantes en informatique consiste à ajouter "1" à une variable. Cette opération est très
courante ! On appelle ça une incrémentation.

nombreJoueur++

Retirez "1" à une variable avec la décrémentation

NombreJoueur--

Voici les raccourcis pour les 5 opérations de base : += , -= , *= , /= et %=

#include <iostream>

using namespace std;

int main()
{

double nombre(5.3);

nombre += 4.2; //'nombre' vaut maintenant 9.5

nombre *= 2.; //'nombre' vaut maintenant 19

nombre -= 1.; //'nombre' vaut maintenant 18

nombre /= 3.; //'nombre' vaut maintenant 6

return 0;

}
Ces opérations sont utiles quand il faut ajouter ou soustraire autre chose que 1.

Utilisez des fonctions mathématiques

La directive à insérer est :

#include <cmath>
La fonction racine carrée
Sqrt

Pour utiliser une fonction mathématique, on écrit le nom de la fonction suivi, entre parenthèses, de la valeur à
calculer. On utilise alors l'affectation pour stocker le résultat dans une variable :

resultat = fonction(valeur);
resultat = sqrt(valeur); .
Le cas particulier de la fonction puissance

Comme toujours, il y a un cas particulier : la fonction puissance. Comment calculer 4545 ?

Si je veux calculer 4545, je vais devoir faire comme ça :

double const a(4);

double const b(5);

double const resultat = pow(a,b);

Les structures conditionnelles
Les programmes doivent être capables de prendre des décisions. Pour y parvenir, on utilise deux sortes
de structures de contrôle :

1. Des conditions : elles permettent d'écrire dans le programme des règles du type : "Si ceci arrive, alors fais
cela".
2. Des boucles : elles permettent de répéter plusieurs fois une série d'instructions.

Utilisez les opérateurs de comparaison

Symbole Signification

== Est égal à

> Est supérieur à

< Est inférieur à

>= Est supérieur ou égal à

<= Est inférieur ou égal à

!= Est différent de

En C++, il y a bien 2 symboles == pour tester l'égalité. On a tendance à oublier cela quand on débute…
Un seul = n'a pas la même signification. C'est un opérateur d'affectation simple et il signifie "affecter à".
Testez des variables avec la condition de base : if else
#include <iostream>
using namespace std;
int main()
{
int nbAnimaux(2);
if (nbAnimaux > 0)
{
cout << "Super ! Les animaux de compagnie ca change la vie !" << endl;
}
cout << "Fin du programme" << endl;
return 0;
}

Écrivez ce qu'il faut faire si la condition n'est pas vérifiée avec else

#include <iostream>

using namespace std;

int main()

int nbAnimaux(0);

if (nbAnimaux > 0)

{
 cout << "Super ! Les animaux de compagnie ca change la vie !" << endl;

else

cout << "Vous n'avez pas d'animaux de compagnie" << endl;

cout << "Fin du programme" << endl;

return 0;

Effectuez un autre test avec else if

Les tests vont être lus dans l'ordre, jusqu'à ce que l'un d'entre eux soit vérifié.

#include <iostream>

using namespace std;

int main()
{

int nbAnimaux(2);

if (nbAnimaux == 0)

cout << "Vous n'avez pas d'animaux de compagnie" << endl;

else if (nbAnimaux == 1)

cout << "C'est super d'avoir un fidele compagnon !" << endl;

else if (nbAnimaux == 2)

cout << "Ca doit en faire du monde a la maison !" << endl;

else

{
 cout << "Votre budget croquettes doit etre important" << endl;

cout << "Fin du programme" << endl;

return 0;

Rendez votre code plus lisible avec des conditions switch

En théorie, la condition if permet de faire tous les tests que l'on veut.
En pratique, il existe d'autres façons de faire des tests… La condition switch , par exemple, permet de simplifier
l'écriture de conditions qui testent plusieurs valeurs possibles pour une même variable.

Voici ce que donnerait le code précédent avec switch :

#include <iostream>

using namespace std;

int main()

int nbAnimaux(2);
switch (nbAnimaux)

case 0:

cout << "Vous n'avez pas d'animaux de compagnie" << endl;

break;

case 1:

cout << "C'est super d'avoir un fidele compagnon !" << endl;

break;

case 2:

cout << "Ca doit en faire du monde a la maison !" << endl;

break;

default:

cout << "Votre budget croquettes doit etre important" << endl;
 break;

return 0;

La forme est un peu différente :

1. On indique d'abord qu'on va analyser la variable nbAnimaux (ligne 9).

2. On teste tous les cas ( case ) possibles : si la variable vaut 0, si elle vaut 1, si elle vaut 2...
3. Les break sont obligatoires si on veut que l'ordinateur arrête les tests une fois que l'un d'eux a réussi. Je
vous conseille d'en mettre comme moi à la fin de chaque case .
4. Enfin, le default correspond au else ("sinon"), et s'exécute si aucun des tests précédents n'est vérifié.

switch ne permet de tester que l'égalité. Vous ne pouvez pas tester "Si le nombre d'animaux est supérieur à 2"
avec switch : il faut dans ce cas utiliser if .
De plus, switch ne peut travailler qu'avec des nombres entiers ( int , unsigned int , char ). Il est impossible de
tester des nombres décimaux ( double ).
switch est donc limité en termes de possibilités, mais cette instruction propose une écriture alternative parfois
plus pratique dans des cas simples.

Vérifiez des valeurs true ou false avec des booléens

Le type bool peut stocker deux valeurs :
1. true (vrai).
2. false (faux).
Ce type est souvent utilisé avec les conditions. Quand on y pense, c'est logique : une condition est soit vraie, soit
fausse. Une variable booléenne aussi.
Si je vous parle du type bool , c'est parce qu'on peut l'utiliser d'une façon un peu particulière dans les conditions.
Pour commencer, regardez ce code :

bool adulte(true);

if (adulte == true)

cout << "Vous etes un adulte !" << endl;

il est possible d'omettre la partie == true dans la condition, cela revient au même ! Regardez ce code, qui est
équivalent :

bool adulte(true);

if (adulte)

cout << "Vous etes un adulte !" << endl;

}
Combinez des conditions
Pour les conditions les plus complexes, sachez que vous pouvez faire plusieurs tests au sein d'un seul et même if . Pour
cela, il va falloir utiliser de nouveaux mots-clés :

and ET

or OU

not NON
Vous pourriez aussi utiliser les symboles hérités du langage C, car ils sont équivalents :

&& ET

|| OU

! NON
… mais je vous incite quand même à utiliser la méthode avec les mots-clés.

Testez "ET" avec and

Disons qu'on veuille tester si la personne est adulte et si elle a au moins 1 enfant. On va donc écrire :

if (adulte and nbEnfants >= 1)

Le mot-clé and signifie "ET". Notre condition se dirait en français : « Si la personne est adulte ET si le nombre d'enfants est
supérieur ou égal à 1 ».

Notez que j'aurais également pu écrire cette condition ainsi :if (adulte == true and nbEnfants >= 1).
Cependant, comme je vous l'ai expliqué un peu plus tôt, il est facultatif de préciser « == true » sur les booléens,
et c'est une habitude que je vous invite à prendre.
Testez "OU" avec or
Pour faire un "OU", on utilise le mot-clé or .

On peut par exemple tester si le nombre d'enfants est égal à 1 OU 2 :

if (nbEnfants == 1 or nbEnfants == 2)
Testez "NON" avec not
Il faut maintenant que je vous présente un dernier mot-clé : not .
Vous devez mettre ce mot-clé avant votre condition pour pouvoir dire "Si cela n'est pas vrai" :

if (not adulte)
Cela pourrait se traduire par "Si la personne n'est pas adulte".

Les structures ittératives

Répétez des instructions grâce aux boucles
Les boucles vous permettent de répéter les mêmes instructions plusieurs fois dans votre programme :

1. L'ordinateur lit les instructions de haut en bas (comme d'habitude).

2. Puis, une fois arrivé à la fin de la boucle, il repart à la première instruction.
3. Il recommence alors à lire les instructions de haut en bas...
4. ... et il repart au début de la boucle :
Il existe 3 types de boucles à connaître :

1. while
2. do ... while
3. for

Faites une boucle while

Cette boucle s'utilise comme ceci :

while (condition)

/* Instructions à répéter */

}
Tout ce qui est entre accolades sera répété tant que la condition est vérifiée.

Exemple : on redemande le nombre d'enfants à l'utilisateur tant que celui-ci est inférieur à 0. Ce genre de boucle
permet de s'assurer que l'utilisateur rentre un nombre correct :

int main()

int nbEnfants(-1); // Nombre négatif pour pouvoir entrer dans la boucle

while (nbEnfants < 0)

 {

cout << "Combien d'enfants avez-vous ?" << endl;

cin >> nbEnfants;

cout << "Merci d'avoir indique un nombre d'enfants correct. Vous en avez " << nbEnfants << endl;

return 0;

int cpt=1;

while (cpt<=10){

cout << cpt<<endl;

cpt++;

Faites une boucle for

Ce type de boucle, que l'on retrouve fréquemment, permet de condenser :

 une initialisation ;
  une condition ;
 une incrémentation.
Voici sa forme :

for (initialisation ; condition ; incrementation)

}
Regardons un exemple concret qui affiche des nombres de 0 à 9 :

int main()

int compteur(0);

for (compteur = 0 ; compteur < 10 ; compteur++)

cout << compteur << endl;

return 0;
}

On retrouve sur la ligne du for les 3 instructions que je vous ai indiquées :

 Une initialisation ( compteur = 0 ) : la variable compteur est mise à 0 au tout début de la boucle. Notez que
cela avait été fait à la ligne immédiatement au-dessus, ce n'était donc pas vraiment nécessaire ici.
 Une condition ( compteur < 10 ) : on vérifie que la variable compteur est inférieure à 10 à chaque nouveau
tour de boucle.
 Une incrémentation ( compteur++ ) : à chaque tour de boucle, on ajoute 1 à la variable compteur ! Voilà
pourquoi on voit s'afficher à l'écran des nombres de 0 à 9.

Vous pouvez faire autre chose qu'une incrémentation si vous le désirez. La dernière section du for est réservée à la
modification de la variable, et vous pouvez donc y faire une décrémentation ( compteur-- ) ou avancer de 2 en 2
( compteur += 2 ), etc.

Notez qu'il est courant d'initialiser la variable directement à l'intérieur du for , comme ceci :

int main()

for (int compteur(0) ; compteur < 10 ; compteur++)

cout << compteur << endl;

}
 return 0;

En résumé
 Les boucles permettent de répéter les mêmes instructions plusieurs fois.
 On distingue trois types de boucles : while , do... while et for .
 La boucle for est généralement utilisée lorsqu'on sait combien de fois on souhaite répéter les instructions,
tandis que while et do... while sont plutôt utilisées lorsqu'on souhaite répéter des instructions jusqu'à ce
qu'une condition spécifique soit vérifiée.

Description

Dans ce quiz, vous allez construire au fur et à mesure des questions un convertisseur d’argent d’euros vers le
dollar américain, regroupant ce que vous avez pu apprendre lors de cette première partie.

Considérons dans ce programme que 1 euro équivaut à 1,20 dollar américain.

Dans la réponse à la dernière question de ce quiz, vous trouverez le corrigé du programme complet. Bonne
chance !
Voici le point de départ du code :

#include <iostream>

using namespace std;

 Question 1
 Vous devez tout d'abord créer la fonction main qui contiendra l’ensemble du programme. Quelle forme a la
fonction principale d’un programme C++ ?

o main()

o {

o }

o int start()

o {

o }

o int run

o {

o }

o
o int main()

o {

o }

 Question 2

Vous allez maintenant implémenter les instructions du programme. Commencez par déclarer une variable de
type double qui permettra d’enregistrer la saisie de l’utilisateur. Vous allez l’initialiser à 0 pour l’instant et la
nommer euroUtilisateur .
Quelle est la bonne méthode pour déclarer et initialiser cette variable euroUtilisateur ?

euroUtilisateur = 0;

int euroUtilisateur = 0;

double euroUtilisateur(0);

euroUtilisateur(0);

 Question 3

Ensuite, vous allez ajouter une variable constante qui contiendra le ratio qui permettra de convertir l’euro vers
le dollar. Ici, le ratio sera égal à 1,20 et la variable se nommera ratioDollar .
 Quelle instruction permet de déclarer la constante ratioDollar avec la valeur 1,20 ?

ratioDollar = 1.20;

double const ratioDollar(1,20);

double const ratioDollar(1.20);

const ratioDollar(1.20);

 Question 4

C'est le moment d'ajouter un petit message accueillant au démarrage du programme, car pour l’instant
l’utilisateur n’a pas beaucoup d’informations. Vous allez donc inclure le message suivant : "Convertisseur euro
-> dollar".

Quelle ligne devez-vous ajouter pour faire afficher ce message dans la console ?

cout << "Convertisseur euro -> dollar" << endl;

cout << Convertisseur euro -> dollar << endl;

print("Convertisseur euro -> dollar");

o

cout << Convertisseur euro -> dollar;

 Question 5

Passons aux choses sérieuses : vous allez demander à l’utilisateur de saisir le montant qu’il souhaite convertir
et récupérer cette saisie.

Quelles sont les deux lignes qui permettront d’indiquer à l’utilisateur d’écrire une valeur et de la récupérer afin
de l’enregistrer dans la variable euroUtilisateur ?

o cout >> "Entrez un montant a convertir en dollar : ";

o cin << euroUtilisateur;

o cout << "Entrez un montant a convertir en dollar : ";

o cin << euroUtilisateur;

o cout << "Entrez un montant a convertir en dollar : ";

o cin >> euroUtilisateur;

o cout >> "Entrez un montant a convertir en dollar : ";

o cin >> euroUtilisateur;

 Question 6

Il est temps d’effectuer le calcul qui permet de convertir le montant en euros vers le dollar. Pour cela, il faut
effectuer une multiplication avec la saisie de l’utilisateur et le ratio.

Il ne faut pas oublier de créer une variable pour stocker le résultat de ce calcul.
Vous allez donc déclarer une variable resultat de type double .
Quelle instruction permet d’effectuer le calcul de la conversion et de le stocker dans la variable resultat :

double resultat = euroUtilisateur * ratioDollar;

double resultat = euroUtilisateur x ratioDollar;

euroUtilisateur x ratioDollar;

int resultat = euroUtilisateur * ratioDollar;

 Question 7

Il y a un petit problème dans le code. Effectivement, il n'est pas nécessaire de faire la conversion si le
nombre saisi par l'utilisateur est négatif.

Quelles structures conditionnelles pouvez-vous ajouter pour gérer cette erreur ?

o Si le nombre est négatif : afficher que la saisie est incorrecte.

 o Sinon : afficher le résultat de la conversion

Attention, plusieurs réponses sont possibles.

if (euroUtilisateur < 0)

cout << "La saisie est incorrecte ! " << endl;

else

cout << euroUtilisateur << "€ equivaut a " << resultat << "$" << endl;

o if (euroUtilisateur < 0)

o {

o cout << euroUtilisateur << "€ equivaut a " << resultat << "$" << endl;

o }
o else

o {

o cout << "La saisie est incorrecte ! " << endl;

o }

o if (euroUtilisateur >= 0)

o {

o cout << euroUtilisateur << "€ equivaut a " << resultat << "$" << endl;

o }

o else

o {

o cout << "La saisie est incorrecte ! " << endl;

o }

o if (euroUtilisateur >= 0)

o {

o cout << "La saisie est incorrecte ! " << endl;

o }

o else

o {

o cout << euroUtilisateur << "€ equivaut a " << resultat << "$" << endl;

o }

 Question 8

Vous pouvez encore optimiser votre super convertisseur. Vous allez ajouter une instruction pour continuer à
demander à l'utilisateur d'entrer un nombre tant que la saisie n'est pas correcte (tant que la saisie n'est pas un
nombre positif). Vous n'avez pas le choix, vous devez ajouter une boucle.

Quelles boucles sont les plus adaptées pour répéter cette demande tant que la saisie est incorrecte ?

Attention, plusieurs réponses sont possibles.

do...while

while

loop

for
//

// main.cpp

// convertisseur

//

// Created by Ranga Gonnage on 14/12/2021.

//

#include <iostream>

using namespace std;

int main() {

double euroUtilisateur(0);

double const ratioDollar(1.20);

cout << "Convertisseur euro -> dollar" << endl;

cout << "Entrez un montant à convertir en dollar : ";

 cin >> euroUtilisateur;

double resultat = euroUtilisateur * ratioDollar;

if (euroUtilisateur < 0)

cout << "La saisie est incorrecte ! " << endl;

else

cout << euroUtilisateur << "€ équivaut à " << resultat << "$" << endl;

return 0;

// Solution avec la boucle pour la question 8

/*

int main() {

double euroUtilisateur(0);

double const ratioDollar(1.20);

cout << "Convertisseur euro -> dollar" << endl;

do

cout << "Entrez un montant à convertir en dollar : ";

cin >> euroUtilisateur;

double resultat = euroUtilisateur * ratioDollar;

if (euroUtilisateur < 0)

cout << "La saisie est incorrecte ! " << endl;

}
 else

cout << euroUtilisateur << "€ équivaut à " << resultat << "$" << endl;

} while (euroUtilisateur < 0);

return 0;

*/

Créez et appelez une fonction

Écrivez une fonction simple

Nous allons créer ensemble une fonction ajouteDeux et on va voir comment l'appeler dans le main :
Créez une fonction qui prend plusieurs paramètres

Il y a des fonctions qui prennent plusieurs paramètres, comme pow() et getline() , par exemple.
Pour passer plusieurs paramètres à une fonction, il faut les séparer par des virgules :

int addition(int a, int b)

return a+b;

double multiplication(double a, double b, double c)

{

return a*b*c;

}
La première de ces fonctions calcule la somme des deux nombres qui lui sont fournis, alors que la deuxième
calcule le produit des trois nombres reçus.

Créez une fonction sans arguments

À l'inverse, on peut aussi créer des fonctions sans arguments. Il suffit de ne rien écrire entre les parenthèses !

Pensez par exemple à une fonction qui demande à l'utilisateur d'entrer son nom ; elle n'a pas besoin de paramètre
:

string demanderNom()

cout << "Entrez votre nom : ";

string nom;

cin >> nom;

return nom;

Créez une fonction qui ne renvoie rien

Tous les exemples jusque-là prenaient des arguments et renvoyaient une valeur. Mais il est aussi possible d'écrire
des fonctions qui ne renvoient rien. Enfin presque : rien ne ressort de la fonction mais, quand on la déclare, il faut
quand même indiquer un type.
void direBonjour()
{
cout << "Bonjour !" << endl;
//Comme rien ne ressort, il n'y a pas de return !
}
int main()
{
direBonjour();
//Comme la fonction ne renvoie rien
//On l'appelle sans mettre la valeur de retour dans une variable
return 0;
}

Pratiquez avec ces exemples d'application

Exemple 1 : une fonction qui calcule le carré d'un nombre
#include <iostream>
using namespace std;
double carre(double x)
{
double resultat;
resultat = x*x;
return resultat;
}
int main()
{
double nombre, carreNombre;
cout << "Entrez un nombre : ";
cin >> nombre;
carreNombre = carre(nombre); //On utilise la fonction
cout << "Le carre de " << nombre << " est " << carreNombre << endl;
return 0;
}

Exemple 3 : une fonction à deux arguments

Je vous propose une fonction qui a besoin de deux arguments pour dessiner un rectangle d'étoiles * dans la console : la
largeur et la hauteur du rectangle.

#include <iostream>

using namespace std;

void dessineRectangle(int l, int h)

for(int ligne(0); ligne < h; ligne++)

for(int colonne(0); colonne < l; colonne++)

cout << "*";

cout << endl;

int main()

int largeur, hauteur;

cout << "Largeur du rectangle : ";

 cin >> largeur;

cout << "Hauteur du rectangle : ";

cin >> hauteur;

dessineRectangle(largeur, hauteur);

return 0;

}
Une fois compilé, ce programme s'exécute et donne par exemple :

Largeur du rectangle : 16
Hauteur du rectangle : 3
****************
****************
****************

Essayez de modifier cette fonction ! Voici deux idées :

1. Afficher un message d'erreur si la hauteur ou la largeur est négative.

2. Ajouter un argument pour le symbole à utiliser dans le dessin.

Allez plus loin avec ces notions avancées

La fin de ce chapitre est consacrée à trois notions un peu plus avancées :

1. Le passage par valeur.

2. Le passage par référence.
 3. Le passage par référence constante.

Notion avancée 1 : le passage par valeur

La première des notions avancées est la manière dont l'ordinateur gère la mémoire dans le cadre des fonctions.

Prenons une fonction simple qui ajoute simplement 2 à l'argument fourni.

int ajouteDeux(int a)

a+=2;

return a;

Testons donc cette fonction :

#include <iostream>

using namespace std;

int ajouteDeux(int a)

a+=2;

return a;
}

int main()

int nombre(4), resultat;

resultat = ajouteDeux(nombre);

cout << "Le nombre original vaut : " << nombre << endl;

cout << "Le resultat vaut : " << resultat << endl;

return 0;

}
Cela donne sans surprise :

Le nombre original vaut : 4

Le resultat vaut : 6

Qu'est-ce qu'il se passe à la ligne resultat = ajouteDeux(nombre); ?

Lors de l'appel à la fonction, il se passe énormément de choses :

1. Le programme évalue la valeur de nombre . Il trouve4 .

2. Le programme alloue un nouvel espace dans la mémoire et y écrit la valeur4 . Cet espace mémoire possède
l'étiquette a , le nom de la variable dans la fonction.
 3. Le programme entre dans la fonction.
4. Le programme ajoute 2 à la variable a .
5. La valeur de a est ensuite copiée et affectée à la variable resultat , qui vaut donc maintenant6 .
6. On sort alors de la fonction.
La variable nombre est copiée dans une nouvelle case mémoire.
On dit que l'argument a est passé par valeur.
Lorsque le programme se situe dans la fonction, la mémoire ressemble donc à ça :

État de la mémoire dans la fonction après un passage par valeur

On se retrouve donc avec trois cases dans la mémoire.

La variable nombre reste inchangée.

On peut faire autrement.

Notion avancée 2 : le passage par référence

Plutôt que de copier la valeur de nombre dans la variable a , il est possible d'ajouter une deuxième étiquette à la
variable nombre à l'intérieur de la fonction. Et c'est bien sûr une référence qu'il faut utiliser comme argument de la fonction :

int ajouteDeux(int& a) //Notez le petit & !!!

{
 a+=2;

return a;

}
Lorsque l'on appelle la fonction, il n'y a plus de copie. Le programme donne simplement un alias à la variable nombre

Jetons un coup d'œil à la mémoire dans ce cas :

État de la mémoire dans la fonction après un passage par référence

Cette fois, la variable a et la variable nombre sont confondues. On dit que l'argument a est passé par référence.
Le nombre original vaut : 6
Le resultat vaut : 6

Utiliser des références peut donc être très dangereux. C'est pour cela qu'on ne les utilise que lorsqu'on en a réellement
besoin.

Quel intérêt y a-t-il à faire un passage par référence ?

L'exemple classique, c'est la fonction echange() ; elle échange les valeurs des deux arguments qu'on lui fournit :

void echange(double& a, double& b)

{

double temporaire(a); //On sauvegarde la valeur de 'a'

a = b; //On remplace la valeur de 'a' par celle de 'b'

b = temporaire; //Et on utilise la valeur sauvegardée pour mettre l'ancienne valeur de 'a' dans 'b'

int main()

double a(1.2), b(4.5);

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

echange(a,b); //On utilise la fonction

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

return 0;

}
Ce code donne le résultat suivant :
a vaut 1.2 et b vaut 4.5
a vaut 4.5 et b vaut 1.2
Les valeurs des deux variables ont été échangées.

Si l'on n'utilisait pas un passage par référence, ce seraient alors des copies des arguments qui seraient échangées, et non les vrais
arguments. Cette fonction serait donc inutile.

Notion avancée 3 : le passage par référence constante

Imaginez une fonction recevant un argument de type string : si votre chaîne de caractères contient un très long texte (la
totalité d'un livre, par exemple), alors la copier va prendre du temps, même si tout cela se passe uniquement dans la
mémoire de l'ordinateur. Cette copie est totalement inutile, et il serait donc bien de pouvoir l'éliminer pour améliorer les
performances du programme.

En utilisant un passage par référence, aucune copie n'est effectuée. Seulement, cette manière de procéder a un petit défaut
: elle autorise la modification de l'argument (c'est justement dans ce but que les références existent.)

La solution est d'utiliser ce que l'on appelle un passage par référence constante. On évite la copie en utilisant
une référence, et l'on empêche la modification de l'argument en le déclarant constant.

void f1(string const& texte) //Pas de copie et pas de modification possible

Utilisez plusieurs fichiers

Le C++ permet de découper son programme en plusieurs fichiers source. Chaque fichier contient une ou plusieurs fonctions.
On peut alors inclure les fichiers (et donc les fonctions) dont on a besoin dans différents projets. On a ainsi réellement des
briques séparées utilisables pour construire différents programmes.
Créez un fichier source et un fichier d'en-tête
Pour faire les choses proprement, il ne faut pas un mais deux fichiers :

1. Un fichier source dont l'extension est .cpp : il contient le code source de la fonction.
2. Un fichier d'en-tête dont l'extension est .hpp : il contient uniquement la description de la fonction, ce qu'on
appelle le prototype de la fonction.
Créons donc ces deux fichiers pour notre fonction ajouteDeux() :

int ajouteDeux(int nombreRecu)

int valeur(nombreRecu + 2);

return valeur;

}
Manipulez des tableaux statiques
Les tableaux dont la taille est fixée à l'avance sont plus faciles à utiliser

Voyons cela avec un exemple : la liste des meilleurs scores d'un jeu.

Si vous voulez afficher la liste des 5 meilleurs scores des joueurs, il va vous falloir en réalité deux listes :

1. La liste des noms de joueurs.

2. Et la liste des scores qu'ils ont obtenus.
Nous allons donc devoir déclarer 10 variables pour mettre toutes ces informations dans la mémoire de l'ordinateur
:

string nomMeilleurJoueur1("Nanoc");

string nomMeilleurJoueur2("M@teo21");

string nomMeilleurJoueur3("Albert Einstein");

string nomMeilleurJoueur4("Isaac Newton");

string nomMeilleurJoueur5("Archimede");

int meilleurScore1(118218);

int meilleurScore2(100432);

int meilleurScore3(87347);

int meilleurScore4(64523);
int meilleurScore5(31415);
Et pour afficher tout cela, il va aussi falloir pas mal de travail :

cout << "1) " << nomMeilleurJoueur1 << " " << meilleurScore1 << endl;

cout << "2) " << nomMeilleurJoueur2 << " " << meilleurScore2 << endl;

cout << "3) " << nomMeilleurJoueur3 << " " << meilleurScore3 << endl;

cout << "4) " << nomMeilleurJoueur4 << " " << meilleurScore4 << endl;

cout << "5) " << nomMeilleurJoueur5 << " " << meilleurScore5 << endl;

C'est là qu'interviennent les tableaux : nous allons pouvoir déclarer les 100 meilleurs scores et les noms des 100 meilleurs
joueurs d'un seul coup.

Dans cet exemple, nous avons besoin de 100 variables, c'est-à-dire 100 places dans le tableau. C'est ce qu'on
appelle, en termes techniques, la taille du tableau.

Si la taille du tableau reste inchangée et est fixée dans le code source, alors on parle d'un tableau statique

Déclarez un tableau statique

Comme toujours en C++, une variable est composée d'un nom et d'un type. Comme les tableaux sont des variables, cette
règle reste valable. Il faut juste ajouter une propriété supplémentaire, la taille du tableau ; autrement dit, le nombre de
compartiments que notre case mémoire va pouvoir contenir.

On indique le type, puis le nom choisi et enfin, entre crochets, la taille du tableau :

TYPE NOM[TAILLE];
Voyons cela avec un exemple :
#include <iostream>

using namespace std;

int main()

int meilleurScore[5]; //Déclare un tableau de 5 int

double anglesTriangle[3]; //Déclare un tableau de 3 double

return 0;

}
On retrouve les deux zones mémoire avec leurs étiquettes mais, cette fois, chaque zone est découpée en cases : trois cases
pour le tableau anglesTriangle et cinq cases pour le tableau meilleurScore .

Pour l'instant, aucune de ces cases n'est initialisée. Leur contenu est donc quelconque.

Il est également possible de déclarer un tableau en utilisant comme taille une constante de type int ou unsigned
int. On indique simplement le nom de la constante entre les crochets, à la place du nombre :

int const tailleTableau(20); //La taille du tableau

double anglesIcosagone[tailleTableau];

Il faut impérativement utiliser une constante comme taille du tableau.

Nous avons de la place dans la mémoire. Il ne nous reste plus qu'à l'utiliser.

Accédez aux éléments d'un tableau statique

Chaque case d'un tableau peut être utilisée comme n'importe quelle autre variable, il n'y a aucune différence. Il faut juste y
accéder d'une manière un peu spéciale. On doit indiquer le nom du tableau et le numéro de la case. Dans le
tableau meilleurScore , on a accès à cinq variables : la première case de meilleurScore , la deuxième, etc., jusqu'à la
cinquième.

Pour accéder à une case, on utilise la syntaxe nomDuTableau[numeroDeLaCase] . Il y a simplement une petite subtilité : la
première case possède le numéro 0 et pas 1. Tout est en quelque sorte décalé de 1.

Pour accéder à la troisième case de meilleurScore et y stocker une valeur, il faudra donc écrire :

meilleurScore[2] = 5;
En effet, 3−1=2 ; la troisième case possède donc le numéro 2. Si je veux remplir mon tableau des meilleurs scores
comme dans l'exemple initial, je peux donc écrire :
int const nombreMeilleursScores(5); //La taille du tableau

int meilleursScores[nombreMeilleursScores]; //Déclaration du tableau

meilleursScores[0] = 118218; //Remplissage de la première case

meilleursScores[1] = 100432; //Remplissage de la deuxième case

meilleursScores[2] = 87347; //Remplissage de la troisième case

meilleursScores[3] = 64523; //Remplissage de la quatrième case

meilleursScores[4] = 31415; //Remplissage de la cinquième case

Comme tous les numéros de cases sont décalés, la dernière case a le numéro 4 et pas 5 !

Parcourez un tableau statique

On connaît à priori le nombre de cases du tableau, on peut donc utiliser une boucle for . Nous allons pouvoir utiliser la
variable i de la boucle pour accéder au ième élément du tableau.

int const nombreMeilleursScores(5); //La taille du tableau

int meilleursScores[nombreMeilleursScores]; //Déclaration du tableau

meilleursScores[0] = 118218; //Remplissage de la première case

meilleursScores[1] = 100432; //Remplissage de la deuxième case

meilleursScores[2] = 87347; //Remplissage de la troisième case

meilleursScores[3] = 64523; //Remplissage de la quatrième case

meilleursScores[4] = 31415; //Remplissage de la cinquième case

for(int i(0); i<nombreMeilleursScores; ++i)

cout << meilleursScores[i] << endl;

}
La variable i prend successivement les valeurs 0, 1, 2, 3 et 4, ce qui veut dire que les valeurs
de meilleursScores[0] , puis meilleursScores[1] , etc., sont envoyées dans cout .

Découvrez un exemple d'utilisation

Nous allons utiliser le C++ pour calculer la moyenne de vos notes de l'année. Je vous propose de mettre toutes vos notes
dans un tableau et d'utiliser une boucle for pour le calcul de la moyenne. Voyons donc tout cela étape par étape.

Étape 1 : déclarez un tableau pour stocker les notes

Comme ce sont des nombres à virgule, il nous faut des double .

int const nombreNotes(6);

double notes[nombreNotes];
Étape 2 : remplissez ce tableau avec vos notes
J'espère que vous savez encore comment faire :
int const nombreNotes(6);

double notes[nombreNotes];

notes[0] = 12.5;

notes[1] = 19.5; //Bieeeen !

notes[2] = 6.; //Pas bien !

notes[3] = 12;

notes[4] = 14.5;

notes[5] = 15;

#include <iostream>

using namespace std;

int main()

int const nombreNotes(6);

double notes[nombreNotes];
notes[0] = 12.5;

notes[1] = 19.5; //Bieeeen !

notes[2] = 6.; //Pas bien !

notes[3] = 12;

notes[4] = 14.5;

notes[5] = 15;

double moyenne(0);

for(int i(0); i<nombreNotes; ++i)

moyenne += notes[i]; //On additionne toutes les notes

//En arrivant ici, la variable moyenne contient la somme des notes (79.5)

//Il ne reste donc qu'à diviser par le nombre de notes

moyenne /= nombreNotes;

cout << "Votre moyenne est : " << moyenne << endl;
 return 0;

}
Voyons ce que cela donne quand on l'exécute :

Votre moyenne est : 13.25

On récupere les notes de l’utilisateur et on lui affiche la moyenne

L’utilisateur remplit les cases du tableau et on les affiche

int main()

{
 int const taille = 3;

double tableau[taille];

double moyenne = 0;

for (int i=1; i<=taille; i++){

cout << i <<"e element" <<endl;

cin >> tableau[i-1];

moyenne += tableau[i-1];

cout << moyenne/taille <<endl;

return 0;

Les tableaux statiques et les fonctions

Les tableaux statiques et les fonctions ne sont pas les meilleurs amis du monde :

1. On ne peut pas écrire une fonction qui renvoie un tableau statique. C'est impossible.
2. Un tableau statique est toujours passé par référence. Et il n'y a pas besoin d'utiliser l'esperluette ( & ) : c'est
fait automatiquement. Cela veut dire que, lorsqu'on passe un tableau à une fonction, cette dernière peut le
modifier.
Voici donc une fonction qui reçoit un tableau en argument :

void fonction(double tableau[])

{

//…

}
Il ne faut rien mettre entre les crochets.
Mais ce n'est pas tout ! Très souvent, on veut parcourir le tableau, avec une boucle for par exemple. Il nous
manque une information cruciale la taille du tableau ! Il faut donc impérativement ajouter un deuxième argument
contenant la taille :

void fonction(double tableau[], int tailleTableau)

//…

Pour vous entraîner, je vous propose d'écrire une fonction moyenne() qui calcule la moyenne des valeurs d'un
tableau. Voici ma version :

/*

* Fonction qui calcule la moyenne des éléments d'un tableau

* - tableau : Le tableau dont on veut la moyenne

* - tailleTableau : La taille du tableau

*/

double moyenne(double tableau[], int tailleTableau)

{

double moyenne(0);

for(int i(0); i<tailleTableau; ++i)

moyenne += tableau[i]; //On additionne toutes les valeurs

moyenne /= tailleTableau;

return moyenne;

Déclarez un tableau multidimensionnel

Pour déclarer un tableau multidimensionnel, il faut indiquer les dimensions les unes après les autres entre crochets :

type nomTableau[tailleX][tailleY]
Pour reproduire le tableau du schéma, on doit déclarer le tableau suivant :

int tableau[5][4];
Ou encore mieux, en déclarant des constantes :
int const tailleX(5);

int const tailleY(4);

int tableau[tailleX][tailleY];

Accédez aux éléments de la grille

Pour accéder à une case de notre grille, il faut indiquer la position en X et en Y de la case voulue.

Par exemple tableau[0][0], tableau[0][1]

LA POO EN C++
Une classe représente le modèle structurel d’un objet. Elle est composée :

 d’un ensemble d’attributs (ou champs, ou données membres) décrivant sa structure.

 d’un ensemble d’opérations (ou méthodes, ou fonctions membres) qui lui sont applicables.

L'encapsulation consiste à masquer l'accès à certains attributs et méthodes d'une classe. Elle est réalisée à l'aide des mots
clés :

 private : les membres privés ne sont accessibles que par les fonctions membres de la classe. La partie privée est aussi
appelée réalisation.
 protected : les membres protégés sont comme les membres privés. Mais ils sont aussi accessibles par les fonctions
membres des classes dérivées (voir l'héritage).
 public : les membres publics sont accessibles par tous. La partie publique est appelée interface.

Les mots réservés private, protected et public peuvent figurer plusieurs fois dans la déclaration de la classe.
1. ENTÊTE DANS LE .HPP

Tout comme il est préconisé de le faire en C pour une fonction, l’entête d’une classe est généralement placé dans un fichier
avec l’extension .hpp (.h pour le C). Voici la déclaration type d’une classe :
class maClasse {
private :
// on place ici les données et méthodes inaccessibles de l’extérieur
// (cette partie ne sera pas non plus accessible par héritage - nous verrons cela plus loin)
int a ; // déclaration d’une variable privée

protected :
// partie visible uniquement par les classes dérivées

public :
// partie visible de l’extérieur, c’est ici qu’on place généralement les méthodes
// permettant d’accéder aux élément de la section private.
int b ;
int valeurA(void) ; // méthode pour accéder à la variable a - principe d’encapsulation.
void modifierA(int) ; // idem
int additionnerA(int) ; // idem
int init( ) ;
} ;
2. DÉFINITION DANS LE .CPP

C’est dans le fichier comportant l'extention .cpp que l’on écrit le corps de la classe décrite dans le fichier .hpp.
Afin d’éviter toute ambiguïté, on prendra soin de préciser pour chaque implémentation le nom de la classe s’y rapportant.
#include "maClasse.hpp"

void maClasse : : modifierA(int valeur) {

// corps de la méthode
}

int maClasse : : additionnerA(int valeur) {

//…
}

//…

3. INSTANCIATION ET UTILISATION

Il existe deux manières d’instancier des classes selon que l’on passe par des pointeurs ou non.
#include " maClasse.hpp "
int main(void) {
maClasse c1;
c1.modifierA(10) ; // on fixe la valeur de a à 10.
c1.b = 15 ;
c1.a = 12 ; // NON, attribut privé
}

Exercice pratique
Ecrire une classe Compte qui permet de créditer un compte bancaire et d’afficher ses informations

 Compte.cpp

#include "Compte.hpp"

using namespace std;

Compte::Compte()

//ctor
}

Compte::~Compte()

//dtor

// Surcharge du constructeur

Compte::Compte(string nnom, double nsolde){

nom = nnom;

solde = nsolde;

double Compte::getSolde(){

return solde;

void Compte::addMontant(double montant){

solde += montant;

}
void Compte::afficherInfos(){

cout <<nom <<solde <<endl;

Main.cpp
#include <iostream>

#include "Compte.hpp"

using namespace std;

int main()

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

Compte c1("Frieden", 200);

c1.addMontant(100.0);

c1.afficherInfos();
 return 0;

 Compte.hpp
#ifndef COMPTE_H

#define COMPTE_H

#include <string>

#include <iostream>

class Compte

public:

Compte();
 Compte(std::string nom, double solde);

virtual ~Compte();

void afficherInfos();

double getSolde();

void addMontant(double montant);

protected:

private:

double solde;

std::string nom;

};

#endif // COMPTE_H