Programmation C++

Ahmed ZELLOU

UM6P, Licence OID2, 2022-2023.

 Plan du cours (1)

1. Introduction

2. Types, opérateurs et expressions

3. Les entrées-sorties (cout, cin, …)

4. Les structures de contrôle

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Plan du cours (2)

5. Les tableaux

6. Les fonctions

7. Les Structures

8. Programmation Orientée Objet

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Partie 1

Introduction

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Langages informatiques
l Un langage informatique est un outil permettant de
donner des ordres (instructions) à la machine
• A chaque instruction correspond une action du processeur

l Intérêt : écrire des programmes (suite consécutive

d’instructions) déstinés à effectuer une tâche donnée
• Exemple: un programme de gestion de role dans une entreprise

l Contrainte: être compréhensible par la machine

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Langage machine
l Langage binaire: l’information est exprimée et manipulée sous
forme d’une suite de bits

l Un bit (binary digit) = 0 ou 1 (2 états électriques)

l Une combinaison de 8 bits= 1 Octet è 28=256 possibilités qui permettent

de coder tous les caractères alphabétiques, numériques, et symboles tels
que ?,*,&, …
•
Le code ASCII (American Standard Code for Information Interchange)
donne les correspondances entre les caractères alphanumériques et
leurs représentation binaire, Ex. A= 01000001, ?=00111111
l Les opérations logiques et arithmétiques de base (addition,
multiplication, … ) sont effectuées en binaire

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Langages haut niveau
l Intérêts multiples pour le haut niveau:
• proche du langage humain «anglais» (compréhensible)
• permet une plus grande portabilité (indépendant du matériel)
• Manipulation de données et d’expressions complexes (réels,
objets, a*b/c, …)
l Nécessité d’un traducteur (compilateur/interpréteur),
exécution plus ou moins lente selon le traducteur

Code source Compilateur ou

Langage machine
en langage évolué interpréteur

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Compilateur/interpréteur
l Compilateur: traduire le programme entier une fois pour toutes
Compilateur
exemple.cpp Exemple.exe exécution
fichier source fichier exécutable
• + plus rapide à l’exécution
• + sécurité du code source
• - il faut recompiler à chaque modification

l Interpréteur: traduire au fur et à mesure les instructions du

programme à chaque exécution
Interprétation+exécution
exemple.php
fichier source
• + exécution instantanée appréciable pour les débutants
• - exécution lente par rapport à la compilation
8

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Langages de programmation:

l Plusieurs types de langages:

• Langages procéduraux
• Langages orientés objets
• frameworks

l Exemples de langages:
• Fortran, Cobol, Pascal, C, …
• C++, Java, …

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Historique de C++
l Le langage C a été conçu en 1972 dans «Bell Laboratories » par
Dennis Ritchie avec l’objectif d’écrire un système d'exploitation
(UNIX).

l En 1978, une première définition du langage C (standard

K&R-C) a été réalisée par Kernighan et Ritchie en publiant le livre
«The C Programming Language ».

l Le succès du C et l’apparition de compilateurs avec des extensions

particulières ont conduit à sa normalisation.

l Langage de base pour la prorammation structurée

10

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Historique de C++
l 1983 : Proposition du langage C++ par le
danois Bjarne Stroustrup

l Plusieurs langages de programmation se sont

inspirés du C++ : Java, PHP, C#, …

l Appelé à l’origine C with classes.

l
1985 : passage à C++

l 2020 : version 20

10

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 C++ : haut ou bas niveau ?
l C++, langage de haut niveau ?

l Un langage très puissant et particulièrement rapide.

l L'immense majorité des jeux sont développés en C++ : puissance et rapidité.

12

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Forces de C++
l Répandu

l Rapide

l Portable

l Multi-paradigmes : procédurale, objet et générique

l Plusieurs bibliothèques : 3D, réseaux, audio, fenêtrés, etc.

Sa complexité

12

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Les outils nécessaires
Un éditeur de texte

Un compilateur
Plutôt un IDE

La bibliothèque

13

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Choisissez votre IDE
Code::Blocks. Gratuit, multiplatforme

Visual C++. (windows, payant)

XCode(Mac OS X)

Dev C++ (gratuit)

Eclipse (professionnel)

https://www.onlinegdb.com/online_c++_compiler

A la main (Linux)

13

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Exemple d’une fenêtre Code Block

14

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Composantes d’un programme C++

Exemple : #include <iostream>

using namespace std;

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

15

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Remarques sur ce premier programme
l #include<iostream> informe le compilateur d’inclure les appels
d’entrées-sorties dont la fonction cout

l La fonction main est la fonction principale, obligatoire.

l L’appel cout permet d’afficher : Hello world et endl ordonne le

passage à la ligne suivante

l En C++, toute instruction simple est terminée par un point-virgule ;

l Un commentaire en C++ est compris entre // et la fin de la ligne ou bien

entre /* et */

16

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Partie 2

Variables, types, opérateurs et

expressions

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Les variables
l Les variables servent à stocker les valeurs des données
utilisées pendant l’exécution d’un programme

l Les variables doivent être déclarées avant d’être utilisées, elles

doivent être caractérisées par :
• un nom (Identificateur)
• un type (entier, réel, …)

l Doivent être différents des mots réservés du langage : auto

break case char …..

18

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Types Entier
4 variantes d’entiers :
l char : caractères (entier sur 1 octet : - 128 à 127)
l short ou short int : entier court (entier sur 2 octets : - 32768 à 32767)
l int : entier standard (entier sur 2 ou 4 octets )
l long ou long int : entier long (4 octets : - 2147483648 à 2147483648)

Si on ajoute le préfixe unsigned à la définition d'un type de variables

entières, alors la plage des valeurs change:
l unsigned char : 0 à 255
l unsigned short : 0 à 65535
l unsigned int : dépend du codage (sur 2 ou 4 octets)
l unsigned long : 0 à 4294967295

Remarque : Une variable du type char peut subir les mêmes opérations que les
variables du type short, int ou long

21

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Types Réel
Trois variantes de réels :
l float : réel simple précision codé sur 4 octets de
-3.4*1038 à 3.4*1038
l double : réel double précision codé sur 8 octets de
-1.7*10308 à 1.7*10308
l long double : réel très grande précision codé sur 10
octets de -3.4*104932 à 3.4*104932
l String : chaine ou mot ou phrase

Une variante de type chaine de caractères (#include <string>)

22

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Déclaration des variables
l

Exemples:

float x = 3.14 ;
String nom;
int i (3);

23

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Déclaration des constantes
l
Une constante const conserve sa valeur pendant toute l’exécution d’un
programme

l Une Variable non modifiable

float const pi(3.14);

24

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Opérateurs en C++
l Le langage C++ est riche en opérateurs. Outre les opérateurs
standards, il comporte des opérateurs originaux d’affectation,
d’incrémentation et de manipulation de bits

l On distingue les opérateurs suivants :

• les opérateurs arithmétiques : *, /, +, -, %

• les opérateurs d’affectation : =, +=, -=, *=, /=, %=
• les opérateurs logiques : &&, ||, !
• les opérateurs de comparaison : ==, !=, <, >, <=, >=
• les opérateurs d’incrémentation et de décrémentation : + +, - -

Attention à la priorité des opérateurs.

30

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Priorités des opérateurs

Catégorie Opérateurs Associativité

référence () [] -> . ®
unaire + - ++ -- ! ~ * & (cast) sizeof ¬
arithmétique * / % ®
arithmétique + - ®
décalage << >> ®
relationnel < <= > >= ®
relationnel == != ®
manip. de bits & ®
manip. de bits ^ ®
manip. de bits ú ®
logique && ®
logique úú ®
conditionnel ?: ®
affectation = += -= *= /= %= ¬
&= ^= ú = <<= >>= ¬
séquentiel , ®
48

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Les instructions de lecture et d’écriture
l
Affichage : cout
int i (3);
cout << "La valeur de i est " << i << endl;

l Lecture : cin
int i(0);
cout << "Donnez une valeur pour i :";
cin >> i;
cout << "La valeur de i est " << i << endl;

l Retour à la ligne : endl

50

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Les instructions de lecture et d’écriture
l
Pour les chaines
#include <string>
string nomUser("Anonyme");
cout << "Quel est votre nom ? :";
Cin >> nomUser;
cout << "Le nom est :" << nomUser << endl;

l Les chaines traitent mal les espaces : remplacer cin par getline()
getline(cin, nomUser);
cin.ignore()//il faut toujours la mettre

50

POO, Partie 1 : Programmation C++ @ A.ZELLOU, Licence OID, UM6P

 Chapitre 4

Structures de contrôle

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Structures de contrôle
l Les structures de contrôle définissent la façon avec laquelle les
instructions sont effectuées. Elles conditionnent l'exécution
d'instructions à la valeur d'une expression

l On distingue :
• Les structures alternatives (tests) : permettent d’effectuer des choix
càd de se comporter différemment suivant les circonstances (valeur
d'une expression). En C++, on dispose des instructions : if…if/else et
switch.

• Les structures répétitives (boucles) : permettent de répéter

plusieurs fois un ensemble donné d’instructions. En C++, on dispose des
instructions : while, do{…}while et for.

62

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 L’instruction if…else
l Syntaxe : If (expression)
bloc-instruction1
else
bloc-instruction2

• bloc-instruction peut être une seule instruction terminée par un point-

virgule ou une suite d’instructions délimitées par des accolades { }

• expression est évaluée, si elle est vraie (valeur différente de 0), alors
bloc-instruction1 est exécuté. Si elle est fausse (valeur 0) alors bloc-
instruction2 est exécuté

l La partie else est facultative. S’il n’y a pas de traitement à réaliser

quand la condition est fausse, on utilisera simplement la forme :
If (expression) bloc-instruction1

63

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 if…else : exemples

• float a, b, max;
if (a > b)
max = a;
else
max = b;

• int a;
if ((a%2)==0)
cout <<a << "est paire";
else
cout << a <<" est impaire ";

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 if…else : Exercice
Lisez un entire et affichez sa valeur absolue.

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Imbrication des instructions if
l On peut imbriquer plusieurs instructions if…else

l Ceci peut conduire à des confusions, par exemple :

• if (N>0)
if (A>B)
MAX=A;
else MAX=B; (interprétation 1 : si N=0 alors MAX prend la valeur B)

• if (N>0)
if (A>B)
MAX=A;
else MAX=B; (interprétation 2 : si N=0 MAX ne change pas)

l En C++ un else est toujours associé au dernier if qui ne possède pas

une partie else (c’est l’interprétation 2 qui est juste)

65

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Imbrication des instructions if
l Conseil : pour éviter toute ambiguïté ou pour forcer une certaine
interprétation dans l’imbrication des if, il vaut mieux utiliser les
accolades
l if(a<=0)
{if(a==0)
cout <<"a est nul ";
else
cout << " a est strictement négatif ";
}
else
cout <<" a est strictement positif " ;

l Pour forcer l’interprétation 1: if (N>0)

{ if (A>B)
MAX=A;
}
else MAX=B;
66

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Imbrication if : Exercice

Ecrivez un programme qui calcule les

solutions réelles d'une équation du second
degré ax 2+bx+c = 0 en discutant sa formule.

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 L’instruction d’aiguillage switch :
l Permet de choisir des instructions à exécuter selon la valeur d’une
expression qui doit être de type entier

l La syntaxe est :
switch (expression) {
case expression_constante1 : instructions_1; break;
case expression_constante2 : instructions_2; break;
…
case expression_constante n : instructions_n; break;
default : instructions;
}
l
expression_constante doit être une expression constante entière
l
Instructions i peut être une instruction simple ou composée
l break et default sont optionnels mais recommandés

67

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Fonctionnement de switch
l expression est évaluée

l si sa valeur est égale à une expression_constante i, on se branche à

ce cas et on exécute les instructions_i qui lui correspondent

• On exécute aussi les instructions des cas suivants jusqu’à la fin du bloc
ou jusqu’à une instruction break (qui fait sortir de la structure switch)

l si la valeur de l'expression n'est égale à aucune des expressions

constantes
• Si default existe, alors on exécute les instructions qui le suivent
• Sinon aucune instruction n’est exécutée

68

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Switch : exemple
main( )
{ char var;
switch (var) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y’: cout << "voyelle"; break ;
default : cout << "consonne";
}
}

69

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Switch : Exercice

Lisez un caractère, puis vérifier si c’est une

voyelle ou une consonne.

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Les boucles while et do .. while
while (condition) do
{ {
instructions instructions

} } while (condition);

l la condition est évaluée à chaque itération. Les instructions (corps de la boucle)

sont exécutés tant que la condition est vraie, on sort de la boucle dès que la
condition devient fausse

l dans la boucle while le test de continuation s'effectue avant d'entamer le corps

de boucle qui, de ce fait, peut ne jamais s'exécuter

l par contre, dans la boucle do-while ce test est effectué après le corps de
boucle, lequel sera alors exécuté au moins une fois

70

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Boucle while : exemple
Un programme qui détermine le premier nombre entier N
tel que la somme de 1 à N dépasse strictement 100

main( )
{ int i, som;
i =0; som= 0;
while (som <=100)
{ i++;
som+=i;
}
cout <<" La valeur cherchée est N = ”<< i;
}

71

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Boucle do .. while : exemple
Contrôle de saisie d'une note saisie au clavier jusqu’à ce
que la valeur entrée soit valable

main()
{ int N;
do {
cout << " Entrez une note comprise entre 0 et 20 :";
cin >> N;
} while (N < 0 || N > 20);
}

72

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 while : Exercice

Ecrivez un programme qui lit N nombres

entiers au clavier et qui affiche leur somme,
leur produit et leur moyenne.

Choisissez un type approprié pour les valeurs à

afficher. Le nombre N est à entrer au clavier.

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 La boucle for
for (expr1 ; expr2 ; expr3)
{
instructions
}
l L'expression expr1 est évaluée une seule fois au début de l'exécution de la
boucle. Elle effectue l’initialisation des données de la boucle

l L'expression expr2 est évaluée et testée avant chaque passage dans la

boucle. Elle constitue le test de continuation de la boucle.

l L'expression expr3 est évaluée après chaque passage. Elle est utilisée
pour réinitialiser les données de la boucle.

73

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Boucle for : remarques
for (expr1 ; expr2 ; expr3) équivaut à :
{ expr1;
instructions while(expr2)
} { instructions
expr3;
}

l En pratique, expr1 et expr3 contiennent souvent plusieurs

initialisations ou réinitialisations, séparées par des virgules

74

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Boucle for : exemple
Calcul de x à la puissance n où x est un réel non nul et n
un entier positif ou nul
main ( )
{ float x, puiss=1;
int n, i;
{ cout << " Entrez respectivement les valeurs de x et n :";
cin >> x >> n;
for ( i=1; i<=n; i++)
puiss*=x;
cout << x << " à la puissance " << n << " est égal à : " << puiss;
}
}

75

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 L’instruction break
l L’instruction break peut être utilisée dans une boucle (for, while, ou do .. while).
Elle permet d’arrêter le déroulement de la boucle et le passage à la première
instruction qui la suit

l En cas de boucles imbriquées, break ne met fin qu’ à la boucle la plus interne
l {int i,j;
for(i=0;i<4;i++)
for (j=0;j<4;j++)
{ if(j==1) break;
cout << i ","j << j << endl;
}
} résultat: i=0,j=0
i=1,j=0
i=2,j=0
i=3,j=0

76

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 for : Exercice

Calculez la factorielle N! = 1*2*3*...*(N-1)*N

d'un entier naturel N en respectant que 0!=1.

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Chapitre 5

Les tableaux

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Tableaux
l Un tableau est une variable structurée composée d’un nombre de
variables simples de même type désignées par un seul identificateur

l Ces variables simples sont appelées éléments ou composantes du

tableau, elles sont stockées en mémoire à des emplacements
contigus (l’un après l’autre)

l Le type des éléments du tableau peut être :

• simple : char, int, float, double, …
• pointeur ou structure

l On peut définir des tableaux :

• à une dimension (tableau unidimensionnel ou vecteur)
• à plusieurs dimensions (tableau multidimensionnel )

79

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Déclaration des tableaux
l La déclaration d'un tableau à une dimension s'effectue en précisant le
type de ses éléments et sa dimension (le nombre de ses éléments) :

• Syntaxe : Type identificateur[dimension];

• Exemple : float notes[30];

l La déclaration d’un tableau permet de lui réserver un espace mémoire

dont la taille (en octets) est égal à : dimension * taille du type

l ainsi pour :
• short A[100]; // on réserve 200 octets (100* 2octets)
• char mot[10]; // on réserve 10 octets (10* 1octet)

80

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Initialisation à la déclaration
l On peut initialiser les éléments d’un tableau lors de la déclaration, en
indiquant la liste des valeurs respectives entre accolades. Ex:
• int A[5] = {1, 2, 3, 4, 5};
l Si la liste ne contient pas assez de valeurs pour toutes les
composantes, les composantes restantes sont initialisées par zéro
• Ex: short T[10] = {1, 2, 3, 4, 5};
l La liste ne doit pas contenir plus de valeurs que la dimension du
tableau. Ex: short T[3] = {1, 2, 3, 4, 5};è Erreur

l Il est possible de ne pas indiquer la dimension explicitement lors de

l'initialisation. Dans ce cas elle est égale au nombre de valeurs de la
liste. Ex: short T[ ] = {1, 2, 3, 4, 5};è tableau de 5 éléments

81

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Accès aux composantes d’un tableau
l L'accès à un élément du tableau se fait au moyen de l'indice. Par
exemple, T[i] donne la valeur de l'élément i du tableau T

l L’indice du premier élément du tableau est 0. L’indice

du dernier élément est égal à la dimension-1

Ex: int T[ 5] = {9, 8, 7, 6, 5};è

T[0]=9, T[1]=8, T[2]=7, T[3]=6, T[4]=5
Remarques:
l On ne peut pas saisir, afficher ou traiter un tableau en entier, ainsi on ne peut
pas écrire cin >> T ou cout << T

l On traite les tableaux élément par élément de façon répétitive en utilisant

des boucles

82

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Tableaux : saisie et affichage
l Saisie des éléments d’un tableau T d’entiers de taille n :

for(i=0;i<n;i++)
{ cout << "Entrez l'élément ",<< i + 1;
cin >> T[i];
}

l Affichage des éléments d’un tableau T de taille n :

for(i=0;i<n;i++)
cout << T[i] << endl;

83

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Tableaux : exemple
l Calcul du nombre d'étudiants ayant une note supérieure à 10 :

main ( )
{ float notes[30];
int nbre,i;
for(i=0;i<30;i++)
{ cout << "Entrez la note de l’élément” << i;
cin >> notes[i];
}
nbre=0;
for (i=0; i<30; i++)
if (notes[i]>10) nbre+=1;
cout << " le nombre de notes > à 10 est égal à : <<", nbre;

}
84

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Tableaux : Exercice

Lisez un tableau de réels.

• Calculez la somme, le produit et la moyenne
des éléments.
• Cherchez la valeur maximale.
• Cherchez la position (indice) de la valeur
maximale.

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Tableaux à plusieurs dimensions
On peut définir un tableau à n dimensions de la façon suivante:

l Type Nom_du_Tableau[D1][D2]…[Dn]; où Di est le nombre

d’éléments dans la dimension i

l Exemple : pour stocker les notes de 20 étudiants en 5 modules

dans deux examens, on peut déclarer un tableau :

float notes[20][5][2];

(notes[i][j][k] est la note de l’examen k dans le module j pour

l’étudiant i)

85

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Tableaux à deux dimensions (Matrices)
l Syntaxe : Type nom_du_Tableau[nombre_ligne][nombre_colonne];
l Ex: short A[2][3]; On peut représenter le tableau A de la manière
suivante :
A[0][0] A[0][1] A[0][2]
A[1][0] A[1][1] A[1][2]

l Un tableau à deux dimensions A[n][m] est à interpréter comme un

tableau unidimensionnel de dimension n dont chaque composante
A[i] est un tableau unidimensionnel de dimension m.

l Un tableau à deux dimensions A[n][m] contient n* m composantes.

Ainsi lors de la déclaration, on lui réserve un espace mémoire dont la
taille (en octets) est égal à : n*m* taille du type

86

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Initialisation à la déclaration d’une Matrice
l L’initialisation lors de la déclaration se fait en indiquant la liste des
valeurs respectives entre accolades ligne par ligne

l Exemple :
• float A[3][4] = {{-1.5, 2.1, 3.4, 0}, {8e-3, 7e-5,1, 2.7 }, {3.1, 0, 2.5E4, -1.3E2}};

A[0][0]=-1.5 , A[0][1]=2.1, A[0][2]=3.4, A[0][3]=0

A[1][0]=8e-3 , A[1][1]=7e-5, A[1][2]=1, A[1][3]=2.7
A[2][0]=3.1 , A[2][1]=0, A[2][2]=2.5E4, A[2][3]=-1.3E2

l On peut ne pas indiquer toutes les valeurs: Les composantes

manquantes seront initialisées par zéro

l Comme pour les tableaux unidimensionnels, il est défendu d'indiquer

trop de valeurs pour une matrice

87

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Matrices : saisie et affichage
l Saisie des éléments d’une matrice d’entiers A[n][m] :

for(i=0;i<n;i++)
for(j=0;j<m;j++)
{ cout << "Entrez la valeur de A[<<"<<i<<"]["<<j<<"] :";
cin >> A[i][j];
}

l Affichage des éléments d’une matrice d’entiers A[n][m] :

for(i=0;i<n;i++)
{ for(j=0;j<m;j++)
cout << A[i][j];
cout << endl;
}

88

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Matrices : Exercice

Lisez deux matrices carrées.

• Calculez leurs sommes et leurs produits.
• Devoir : calculez le déterminant d’une
matrice.

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Chapitre 6

Les fonctions

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 La programmation modulaire
l Certains problèmes conduisent à des programmes longs, difficiles à écrire et à
comprendre. On les découpe en des parties appelées sous- -programmes ou
modules
l Les modules sont des groupes d'instructions qui fournissent une solution à des
parties bien définies d'un problème plus complexe. Ils ont plusieurs intérêts :

• permettent de "factoriser" les programmes, càd de mettre en commun

les parties qui se répètent
• permettent une structuration et une meilleure lisibilité des programmes
• facilitent la maintenance du code (il suffit de modifier une seule fois)
• peuvent éventuellement être réutilisées dans d'autres programmes

l La structuration de programmes en sous-programmes se fait en C++ à l'aide des

fonctions

113

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Fonctions
l On définit une fonction en dehors de la fonction principale main ( ) par :
type nom_fonction (type1 arg1,…, typeN argN)
{
instructions constituant le corps de la fonction
return (expression)
}
l Dans la première ligne (appelée en-tête de la fonction) :
• type est le type du résultat retourné. Si la fonction n’a pas de résultat à
retourner, elle est de type void.
• le choix d'un nom de fonction doit respecter les mêmes règles que celles
adoptées pour les noms de variables.
• entre parenthèses, on spécifie les arguments de la fonction et leurs
types. Si une fonction n'a pas de paramètres, on peut déclarer la liste
des paramètres comme (void) ou simplement comme ()
l Pour fournir un résultat en quittant une fonction, on dispose de la commande
return.
114

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Fonctions : exemples
l Une fonction qui calcule la somme l Une fonction qui renvoie un
de deux réels x et y : entier saisi au clavier
double Som(double x, double y ) int RenvoieEntier( void )
{
{
int n;
return (x+y); cout << " Entrez n :";
} cin >> n;
return n;
l Une fonction qui affiche la somme de }
l Une fonction qui affiche les
deux réels x et y : éléments d’un tableau d’entiers
void AfficheSom(double x, double y) void AfficheTab(int T[ ], int n)
{ { int i;
cout << x+y ; for(i=0;i<n;i++)
cout << T[i];
}
}

115

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Appel d’une fonction
l L‘appel d'une fonction se fait par simple écriture de son nom avec la liste
des paramètres : nom_fonction (para1,…, paraN)
l Lors de l'appel d'une fonction, les paramètres sont appelés paramètres
effectifs : ils contiennent les valeurs pour effectuer le traitement. Lors de la
définition, les paramètres sont appelés paramètres formels.
l L'ordre et les types des paramètres effectifs doivent correspondre à ceux
des paramètres formels
l Exemple d’appels:
main( )
{ double z;
int A[5] = {1, 2, 3, 4, 5};
z=Som(2.5, 7.3);
AfficheTab(A,5);
}

116

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Déclaration des fonctions
l Il est nécessaire pour le compilateur de connaître la définition d'une
fonction au moment où elle est appelée. Si une fonction est définie
après son premier appel (en particulier si elle définie après main ),
elle doit être déclarée auparavant.

l La déclaration d'une fonction se fait par son prototype qui indique

les types de ses paramètres et celui de la fonction :
type nom_fonction (type1,…, typeN)

l Il est interdit en C++ de définir des fonctions à l'intérieur d'autres

fonctions. En particulier, on doit définir les fonctions soit avant, soit
après la fonction principale main.

117

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Déclaration des fonctions : exemple
#include<stdio.h>
float ValeurAbsolue(float); //prototype de la fonction ValeurAbsolue
main( )
{ float x=-5.7,y;
y= ValeurAbsolue(x);
cout << "La valeur absolue de" << x << "est : " << y;
}
//Définition de la fonction ValeurAbsolue
float ValeurAbsolue(float a)
{
if (a<0) a=-a;
return a;
}

118

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Récursivité
l Une fonction qui fait appel à elle-même est une fonction récursive

l Toute fonction récursive doit posséder un cas limite (cas trivial) qui
arrête la récursivité

l Exemple : Calcul du factorielle

int fact (int n )
{ if (n==0) /*cas trivial*/
return (1);
else
return (n* fact(n-1) );
}
Remarque : l’ordre de calcul est l’ordre inverse de l’appel de la fonction
126

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Fonctions récursives : exercice
l Ecrivez une fonction récursive (puis itérative) qui calcule le terme n
de la suite de Fibonacci définie par : U(0)=U(1)=1
U(n)=U(n-1)+U(n-2)

int Fib (int n)

{
if (n==0 || n==1)
return (1);
else
return ( Fib(n-1)+Fib(n-2));

127

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Fonctions récursives : exercice (suite)
l Une fonction itérative pour le calcul de la suite de Fibonacci :

int Fib (int n)

{ int i, AvantDernier, Dernier, Nouveau;
if (n==0 || n==1) return (1);
AvantDernier=1; Dernier =1;
for (i=2; i<=n; i++)
{ Nouveau= Dernier+ AvantDernier;
AvantDernier = Dernier;
Dernier = Nouveau;
}
return (Nouveau);
}
Remarque: la solution récursive est plus facile à écrire

128

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Chapitre 7

Les Structures

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Définition d’une Structure
Permet d’utiliser des types combinés dans un programme.
Une collection de variables de types différents avec un même nom.

Exemple : une date est struct ADate {

int month int month;
int day int day;
int year int year;
};
L’accès aux composants de la structure est réalisé via le (.)
struct ADate date;
struct Person
{ date.month = 2;
char name[50]; date.day = 4;
date.year = 2021;
int age;
float salary;
};
138

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Structure : Exercice 1
Créer une structure NombreRationnel à deux
composants : un numérateur et un dénominateur.

écrivez une fonction qui prends en paramètres deux

nombres rationnels et qui retourne leurs produits sous
forme d'un nombre rationnel.

Améliorer le programme en déclaration deux fonctions

: lire et afficher

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Tableau de Structures
Déclaration du tableau Constant

#define NFRIENDS 50

Date birthdays[NFRIENDS];

bool check_birthday(Date today)

L’indice du tableau
{
int i;
L’élément de la structure
for (i = 0; i < NFRIENDS; i++) {
if ((today.month == birthdays[i].month) &&
(today.day == birthdays[i].day))
return (true);

return (false); Que fait le programme ?

}

138

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Structure : Devoir
1.Créer une structure Matière avec numéro, coefficient et désignation.
2.Créer une structure Date avec jour, mois et année.
3.Créer une structure Etudiant avec numéro, nom, prénom, date de naissance un
tableau à deux colonnes (matières et notes) et une moyenne.
4.Ecrivez une fonction read qui permet de lire un étudiant.
5.Ecrivez une fonction write qui permet d'afficher un étudiant.
6.Mettez dans la fonction main
1. La déclaration d'un tableau de plusieurs étudiants.
2. La lecture d'un nombre d'étudiants fournit par l'utilisateur (appelez la
fonction read).
3. Calculez la moyenne de chaque étudiant.
4. Affichez le majorant dans chaque matière.
5. Affichez le majorant de la classe.
6. Affichez la relevé liste des relevés des notes des étudiants.

64

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P

 Fin

POO, Partie 1 : Programmation Structurée @ A.ZELLOU, Licence OID, UM6P