INF182 - INTRODUCTION A LA
PROGRAMMATION C++
STRUCTURES CONDITIONNELLES ET
BOUCLES
o Une structure de contrôle ou instruction de contrôle sert à contrôler le déroulement
d’un traitement.
Un traitement peut s’exécuter de différentes manières :
- Séquentiellement (l’un à la suite de l’autre).
- Alternativement (soit l’un soit l’autre ou les autres selon une condition fixée).
- Alternative simple (if),
- Alternative composée (if else),
- Alternative imbriquée(if…if else else),
- Alternative multiple (switch)
- Répétitivement (en répétant le traitement un nombre fini de fois).
La boucle while, la boucle do while, la boucle for
STRUCTURES CONDITIONNELLES ET
BOUCLES
o Le terme instruction désignera indifféremment une instruction simple (terminée
par un point-virgule), une instruction structurée (choix, boucle) ou un bloc
(instructions entre { }).
o Structures de contrôle. Elle est constituée de deux éléments: que nous verrons
dans ce chapitre :
- Les conditions : elles permettent d'écrire dans le programme des règles
comme « Si ceci arrive, alors fais cela".
- Les boucles : elles permettent de répéter une série d'instructions plusieurs
fois.
LES CONDITIONS
Pour qu'un programme soit capable de prendre des décisions, on utilise des
conditions dans le code source (on parle aussi de "structures conditionnelles").
Pour effectuer ces tests, nous utilisons des symboles. Ci-dessous, le tableau des :
LES CONDITIONS
La condition if
Les conditions permettent
de tester des variables pour
qu'un programme soit
capable de prendre des
décisions. Syntaxe:
LES CONDITIONS
EXEMPLE de l’alternative simple
Résultat Vous avez des enfants, bravo !
Fin du programme
EXEMPLE de l’alternative
composée
LES CONDITIONS
EXEMPLE de l’alternative
imbriquée
LES CONDITIONS
traitements alternatifs multiples switch … case
C’est une instruction multidirectionnelle
pour gérer les décisions. Son fonctionnement est
similaire à celui de if else.
La différence avec If else est que le code
de switch...case est plus lisible que celui de if else
et qu’il s’exécute aussi plus vite.
Syntaxe ci-contre :
LES CONDITIONS
En principe, la condition if permet de faire tous les tests que l'on
veut. Mais, 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 différentes pour une même variable.
Exemple le test qu'on vient de faire sur le nombre d'enfants avec if else ;
on peut faire la même chose avec une condition switch qui a tendance à
rendre le code plus lisible dans ce genre de cas. Voici ce que donnerait la
condition précédente avec un switch :
LES CONDITIONS
On indique d'abord qu'on va
analyser la variable nbEnfants(ligne 9).
Ensuite, on teste tous les cas (case)
possibles : si ça vaut 0, si ça vaut 1, si
ça vaut 2... Les break sont obligatoires
si on veut que l'ordinateur ne continue
pas d'autres tests une fois qu'il en a
vérifié un.
Enfin, le default à la fin
correspond au else ("sinon") et s'exécute
si aucun test précédent n'est vérifié.
LES BOUCLES
Les boucles permettent de répéter les mêmes instructions plusieurs fois dans
le programme. Le principe est le suivant :
L'ordinateur lit les instructions de haut en bas (comme d'habitude)
Puis, une fois arrivé à la fin de la boucle, il repart à la première instruction
Il recommence alors à lire les instructions de haut en bas...
... Et il repart au début de la boucle.
Les boucles sont répétées tant qu'une condition est vraie
Il existe 3 types de boucles à connaître :
• for
• while
• do ... while
La boucle FOR
Ce type de boucle, que l'on retrouve fréquemment, permet de condenser :
• Une initialisation
• Une condition
• Une incrémentation
Syntaxe : for (compteur initial ;borne max compteur ;pas) instruction
LES BOUCLES
La boucle FOR
On retrouve sur la ligne du for les
3 instructions indiquées dans la syntaxe :
Exemple qui affiche le nombre de 0 à 3 Une initialisation (compteur = 0) : la
variable compteur est mise à 0 au tout
début de la boucle.
Une condition (compteur < 4) : on vérifie
que la variable compteur est inférieure à 4
à chaque nouveau tour de boucle.
Une incrémentation (compteur++) : à
chaque tour de boucle, on ajoute 1 à la
variable compteur !
LES BOUCLES
La boucle while
Syntaxe :
while (condition)
{
/* Instructions à répéter */
}
Tout ce qui est entre accolades sera répété tant que la condition est vérifiée.
LES BOUCLES
La boucle while
Exemple:
Tant que vous mettrez un nombre
négatif, la boucle recommencera. En
effet, elle teste while (nbEnfants < 0)
c'est-à-dire "Tant que le nombre
d'enfants est inférieur à 0". Dès que le
nombre devient supérieur ou égal à 0, la
boucle s'arrête et le programme
continue après l'accolade fermante.
LES BOUCLES
La boucle do while Syntaxe
do
{
/* Instructions */
}
while (condition);
Cette boucle est très similaire à la boucle while si ce n'est que la condition n'est analysée
qu'à la fin. Cela signifie que le contenu de la boucle sera toujours lu au moins une
première fois.
LES BOUCLES
La boucle do while
Exemple:
Le gros intérêt du do ... while est qu'on
s'assure que la boucle sera lue au moins une
fois. D'ailleurs, du coup, il n'est pas nécessaire
d'initialiser nbEnfants à -1 (c'est le principal
avantage que procure cette solution). En effet,
ici le nombre d'enfants est initialisé à 0 (comme
on a l'habitude de faire), et comme la condition
n'est testée qu'après le premier passage de la
boucle, les instructions sont bien lues au moins
une fois.
POINTEURS ET TABLEAUX
LES TABLEAUX
Un tableau est une zone continue en mémoire, constituée de cellules contenant des
données toutes de même type.
C’est un ensemble ordonné d’une taille fixe de plusieurs variables du même type.
Syntaxe :
<type> <nom> [<taille>];
où :
<type> est le type des ´éléments du tableau,
<nom> est le nom du tableau,
<taille> est une constante entière égale au nombre d’éléments du tableau.
POINTEURS ET TABLEAUX
LES TABLEAUX
Exemple
POINTEURS ET TABLEAUX
LES TABLEAUX
Exemple
POINTEURS ET TABLEAUX
LES TABLEAUX
Exemple
On retrouve nos deux zones mémoires 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
toutes ces cases ne sont pas initialisées. Leur contenu
est donc quelconque.
POINTEURS ET TABLEAUX
LES TABLEAUX
Accéder aux éléments d'un tableau
Pour accéder à une case on utilise la syntaxe
nomDuTableau[numeroDeLaCase]. Il y a juste 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 3e case de meilleurScore et y écrire une valeur, il
faudra donc écrire : meilleurScore[2] = 5;
Ci-dessous, on remplit le des meilleurs scores avec les valeurs initiales
POINTEURS ET TABLEAUX
LES TABLEAUX
Accéder aux éléments d'un tableau
Ci-dessous, on remplit le des meilleurs scores avec les valeurs initiales
int const nombreMeilleursScores(5); //La taille du tableau int
meilleursScores[nombreMeilleursScores]; //Declaration du tableau
meilleursScores[0]=118218; //Remplissage de la premiere case
meilleursScores[1]=100432; //Remplissage de la deuxiemecase
meilleursScores[2]=87347; //Remplissage de la troisieme case
meilleursScores[3]=64523; //Remplissage de la quatrieme case
meilleursScores[4] = 31415; //Remplissage de la cinquieme case
POINTEURS ET TABLEAUX
LES TABLEAUX
Parcourir un tableau
Le gros point fort des tableaux, c'est qu'on peut les parcourir en utilisant
une boucle.
On peut ainsi effectuer une action sur chacune des cases d'un tableau l'une
après l'autre. Par exemple afficher le contenu des cases.
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.
POINTEURS ET TABLEAUX
LES TABLEAUX
Parcourir un tableau
Exemple
POINTEURS ET TABLEAUX
Les pointeurs
Lorsque l'on déclare une variable, l'ordinateur nous prête une place dans sa
mémoire et y accroche une étiquette portant le nom de la variable.
int main()
{
int ageUtilisateur(16);
return 0;
}
On pouvait donc représenter la mémoire utilisée dans ce programme sur le
schéma ci-dessus:
POINTEURS ET TABLEAUX
Les pointeurs
La mémoire d'un ordinateur est
réellement constituée de "cases". Il y
en a même énormément. Plusieurs
milliards sur un ordinateur récent !
Il faut donc un système pour que
l'ordinateur puisse retrouver les
cases dont il a besoin. Chaque
"case" possède un numéro unique,
son adresse.
POINTEURS ET TABLEAUX
Les pointeurs
L'important est que chaque variable possède une
seule adresse. Et chaque adresse correspond à
une seule variable. L'adresse est donc un
deuxième moyen d'accéder à une variable. On
peut accéder à la case jaune du schéma par deux
chemins différents :
• On peut passer par son nom (l'étiquette)
comme on sait déjà le faire...
• Mais on peut aussi accéder à la variable grâce
à son adresse (son numéro de case).. On pourrait
alors dire à l'ordinateur "Affiche moi le contenu
de l'adresse 53768"
POINTEURS ET TABLEAUX
Les pointeurs
Un pointeur donc est une variable qui contient l'adresse d'une autre variable.
Une variable pointeur est destinée à manipuler des adresses d’informations d’un
type donné.
Pour déclarer un pointeur, il faut, comme pour les variables, deux choses : Un type
Un nom.
Pour le nom, il n'y a rien de particulier à signaler. Les mêmes règles que pour les
variables s'appliquent.
Le type d'un pointeur a une petite subtilité. Il faut indiquer que le type de variable
dont on veut stocker est l'adresse en ajoutant une étoile (*).
Syntaxe: int *pointeur;
Ce code déclare un pointeur qui peut contenir l'adresse d'une variable de type int.
POINTEURS ET TABLEAUX
Les pointeurs
Exemple
Afficher l'adresse
En C++, le symbole pour obtenir l'adresse d'une variable est l'esperluette (&).
Si on veux afficher l'adresse de la variable ageUtilisateur, on dois donc écrire
&ageUtilisateur.
Stocker une adresse
Maintenant qu'on a la variable, il n'y a plus qu'à mettre une valeur dedans.
POINTEURS ET TABLEAUX
Les pointeurs
Exemple
La ligne 6 est celle qui nous intéresse. Elle écrit l'adresse de la variable
ageUtilisateur dans le pointeur ptr. On dit alors que le pointeur ptr pointe sur
ageUtilisateur.
POINTEURS ET TABLEAUX
Les pointeurs
Exemple
LES FONCTIONS
Lorsqu'on a un ensemble de lignes de code qui doivent être exécutées à différents
endroits dans un programme, au lieu de réécrire les mêmes lignes de code, il est
intéressant de créer des fonctions. Au lieu d'écrire une fonction main() de 500
lignes, il est préférable de créer 25 fonctions de 20 lignes
• on structure le programme.
• il est plus facile de tester chaque fonction.
Une fonction est un sous programme qui permet d’effectuer un ensemble
d’instruction par le simple appel de la fonction dans le corps du programme
principal.
Syntaxe :
type nomFonction(arguments)
{
//Instructions effectuées par la fonction
}
LES FONCTIONS
type nomFonction(arguments)
{
//Instructions effectuées par la fonction
}
On retrouve les trois éléments de la fonction :
• Le premier élément est le type de retour. Il permet d'indiquer le type de variable
renvoyé par la fonction.
Si votre fonction doit renvoyer du texte, alors ce sera string,
si votre fonction effectue un calcul, alors ce sera int ou double.
• Le deuxième élément est le nom de la fonction, exemple la fonction main.
• Entre les parenthèses, on trouve la liste des arguments de la fonction. Ce sont les
données avec lesquelles la fonction va travailler
Si la fonction n’a rien à renvoyer, le type retour est void
LES FONCTIONS
Exemple1
Dans ce programme, on a créé une fonction
b qui se contente d'afficher "Bonjour" à
l'écran. La fonction b est précédée du type
void : cela signifie que la fonction ne
renvoie aucune valeur au programme
appelant.
Le programme principal (la fonction main())
affiche "COUCOU1" à l'écran, ensuite
appelle la fonction b, affiche le message
"COUCOU2" à l'écran
LES FONCTIONS
Exemple 2 :
Une fonction qui reçoit un nombre entier, ajoute 2 à ce nombre et le renvoie.
int ajouteDeux(int nombreRecu)
{
int valeur(nombreRecu + 2)
return valeur;
}
Appel à une fonction
Lors de l'appel de la fonction, le programme exécute la totalité des instructions du corps
de la fonction, puis reprend le programme juste après l'appel de la fonction.
LES FONCTIONS
#include <iostream>
using namespace std;
Exemple appel
int ajouteDeux(int nombreRecu)
{
int valeur(nombreRecu + 2);
return valeur;
}
//Fonction Main
int main()
{
int a(2),b(2);
cout << "Valeur de a : " << a << endl;
cout << "Valeur de b : " << b << endl;
b = ajouteDeux(a); //Appel de la fonction
cout << "Valeur de a : " << a << endl;
cout << "Valeur de b : " << b << endl;
return 0;
}
LES FONCTIONS
Exemple plusieurs paramètres
