Poo Cplus1

Programmation Avancée
En
Programmation avancée c/C++ 1

Rappel de programmation
• Définition
– Programme informatique
• Rappel des concepts de programmation en C
– Exercice d’activité
– Variables et expressions
– Structures de contrôle en C
– Les entrées/Sorties

MISE EN ROUTE – PROG EN C
Ecrire un programme en C qui calcule le PGCD
de deux nombres entier A et B suivant
l’algorithme d'Euclide.
Algorithme d’EUCLIDE :
PGCD(A,B) = PGCD(B,A mod B) si A>=B

PGCD(A,B) = PGCD(A,B mod A) si A<=B
PGCD(A,0) = A
A mod B désigne le reste de la division entière entre A et B.
Objectif du cours d’aujourd’hui
1. Présenter le cours
• Objectif
• Organisation
2. Presenter la matière :
• Qu’est ce que le C++
• Qu’est ce que la programmation Orientée Objet
3. Outils de base de la programmation
• Variables et expressions
• Structures de contrôle

Objectif du cours
1. Etre capable de lire et comprendre du code C++
2. Apprendre à Programmer de façon plus concise et modulaire
mais aussi plus fiable et élégante en exploitant les concepts
Orientés-objets
▪ Au moyen du langage C++
3. Comprendre les concepts de programmation orientée objet
4. Mettre en oeuvre ces concepts dans le langage C++
Connaissance
Programmation avancée c/C++

Temps 5
Organisation du cours
 CT : 15 heures
 TD : 5 heures
 TP : 20 heures
 Coefficient : 3

Documentation
Marylène Micheloud & Medard Rieder

Programmation orientée objets en
C++ – une approche évolutive, PPUR,
1997
J.-C. Chappelier & F. Seydoux C++ par la pratique

– recueil d’exercices corrigés et aide-mémoire,
PPUR, nouvelle edition corrigée, 2012

Le langage C++

Langage C++ (1)
 Extension objet du langage C

 Elaboré par Alan Kay, dans les années 70
 Développement par Bjam Stroustrup (1983 – 1985)
Bjarne Stroustrup
30 December
1950 (age 68)
DANOIS

Alan Curtis Kay, né le 17 Mai 1940 (age 79), USA
Langage C++ (2)
 Extension objet du langage C
 Elaboré par Alan Kay, dans les années 70
 Développement par Bjam Stroustrup (1983 –

1985)
10
Langage C++ (2)
Normalisé ISO en 1998 puis 2002
Version la norme Date de sortie
C ++ 98 ISO / IEC 14882: 1998 Sept. 1998
C ++ 03 ISO / IEC 14882: 2003 Oct. 2003
C ++ 11 ISO / IEC 14882: 2011 Sept. 2011
C ++ 14 ISO / IEC 14882: 2014 Dec. 2014
C ++ 17 ISO / IEC 14882: 2017 Dec. 2017
C ++ 20 À déterminer 2020
Le C date de 1969 – 1973 (Dennis Ritchie)

11
Langage C++ (3)
Plus précisément, le langage C++ est un langage

o Orienté objet
o Compilé
o Fortement typé
C++ = C + Typage fort + objets

Langage C++ (1)
❑ Avantages
Parmi les avantages du C++, on peut citer:
o Un des langages Objets les plus utilisés
o Un langage compilé, ce qui permet la réalisation
d’applications efficaces (disponibilité d’excellents
compilateurs open source (GNU))
o Un typage fort, ce qui permet au compilateur d’effectuer de
nombreuses vérifications lors de la compilation – moins de
« bugs » …
o Un langage disponible sur pratiquement toutes les
plateformes ;
o Similarité syntaxique et facilité d’interfaçage avec le C
Langage C++ (2)
❑ Inconvénients
o Similarité syntaxique avec le C!
o Pas de gestion automatique de la mémoire
o Pas de protection de la mémoire
o Syntaxe parfois lourde et peu intuitive
o Gestion facultative des exceptions
o Effets parfois indésirables et peu intuitifs dus
à la production automatique de code.
Qu’est ce que la programmation
Orientée Objet ?

La programmation orientée objets
Dans les grandes lignes :
o C’est une manière de structurer les données et
les traitements interagissant dans un programme
o En POO, un objet regroupe les données et les

traitements relatifs à un concept particulier.
o Les objets interagissent entre eux.

La programmation orientée objets
Un objet peut être vu comme une struct:
o Dotée de fonctions qui lui sont spécifiques

(méthodes) et qui permettent de manipuler les
données qu’elle contient;
o Dans laquelle l’accès direct aux données peut être

interdit pour définir un cadre d’utilisation
précis.

Exemples de langages orientés Objets
▪ Smalltalk (Xerox PARC, 1980);
▪ Objective-C (Apple, Brad Cox, 1986);
▪ Python (Open source, Guido van Rossum, 1990);
▪ Java (Sun Microsystem, 1995)
▪ C# (Microsoft, 2001)
Par ailleurs, la plupart des langages non-objets admettent une

extension objets :
▪ Caml
▪ PERL
▪ PHP
▪ etc
C++ comme sur-ensemble de C
Tout ce qui est syntaxiquement valide en C l’est aussi en C++,

mais :
▪ C++ a apporté quelques changements plus élégants

▪ la couche objet peut aussi avoir une incidence sur les choix
syntaxiques à effectuer
Dans ce cours nous adhérerons le plus possible à une syntaxe

purement "C++ ienne"

Les bases du C++

Structure générale d’un programme C++
La structure générale d’un programme C++ est la suivante :
#include <des_librairies_utiles>
...
using namespace std;
(déclaration d’objets globaux) [à éviter]
(déclarations des fonctions utiles) [recommandé]
int main() //ou int main(int argc, char **argv)

{
corps du
programme principal [si possible assez court]
}
Compilation et nommage de fichier
Compilateur
Fichier source Fichier exécutable
Commande : g++ hello.cc –o hello

Hello.cc
#include <iostream>
main() { Hello
010100001010101
cout << "Hello World!" << endl; 001010101001110
} 101111001010001
...
En C++ les fichiers sources se terminent par l’extension .cc ou .cpp

(au lieu de .c en C).
Pour des systèmes de type Unix, le compilateur C++ sera invoqué au
moyen de la commande g++Programmation
(ou parfoisavancée c/C++
c++) au lieu de gcc pour C. 25
Premier programme en C++
Retourner la somme de deux nombre a et b
#include <iostream>
double somme(double n1, double n2 );
int main() {
double a(0.0);
double b(0.0);
cout << "Entrez les nombres a et b " ;
cin >> a >> b;
cout << a << " + " << b << " = " << somme(a, b) <<endln() ;
double somme(double n1, double n2)

{
return n1+n2;
} Programmation avancée c/C++ 26
Premier programme en C++
Retourner la somme de deux nombre a et b
#include <iostream>
//using namespace std;
double somme(double n1, double n2 );
int main() {
double a(0.0);
double b(0.0);
std::cout << "Entrez les nombres a et b " ;
std::cin >> a >> b;
std::cout << a << " + " << b << " = " << somme(a, b) <<std::endln() ;
double somme(double n1, double n2)

{
return n1+n2;
Données et traitements
Comme en C, un programme C++ est donc à la base un ensemble
de traitements s’effectuant sur des données.
Algorithme structures de données

Traitements Données
Variables
Expressions & Opérateurs
Structures de contrôle Portée
Fonctions Chaînes de caractères
Tableaux statiques
Tableaux dynamiques
Structures
Pointeurs
Entrées/sorties

Variables
Pour être utilisée dans un programme C++, une donnée doit être
stockée quelque part en mémoire. C’est un objet informatique qui
pourra être manipulé par le programme
Ces données peuvent être :

▪ temporaire/transitoires, et anonymes;
▪ identifiées/nommées pour être réutilisées :
la zone mémoire utilisée est alors décrite au niveau du
langage de programmation par une variable.

Déclaration de variables
En C++, une variable doit être déclarée avant d’être utilisée.
Comme en C, la syntaxe de la déclaration d’une variable est la
suivante :
type identificateur_de_variable;
où type est l’identificateur de type de la variable déclarée et
identificateur est une chaîne de caractères permettant de référer la
variable créée et donc de l’utiliser dans un programme
Examples : int valeur;
double delta;
Un identificateur de variable peut être n’importe quelle séquence

composée de lettres, de chiffres ou du caractère ’_’ et commençant
par une lettre ou par ’_’. Il ne doit pas correspondre à un mot
réservé du langage (if, else, while, ...)
Conseil : Pour vos variables, utilisez des noms aussi explicites
que possible.
Affectation
L’opération d’affectation affecte (!) une valeur à une variable.
Comme en C, la syntaxe d’une affection est :
Identificateur = valeur ;
où valeur est une constante ou une expression (voir plus loin)

du même type que la variable référencée par identificateur.
Exemple : i = 3;
Solde = 2500000 ;

Initialisation
En même temps qu’elle est déclarée, une variable peut être
initialisée, c’est-à-dire qu’on lui donne une première valeur avant
même toute utilisation.
Note : il est possible d’utiliser une variable non initialisée. Ceci
doit au maximum être évité ! Initialisez toujours vos variables...
...cela vous évitera bien des soucis par la suite.
La syntaxe de la déclaration/initialisation d’une variable est :
type identificateur( valeur_d’initialisation) ;

où valeur_d’initialisation est n’importe quelle constante
(i.e. valeur littérale) ou expression du type indiqué.
Exemple : int valeur(2) ;
double pi(3.1415) ;
char c(’a’) ;
int j(2*i+5) ; 32
Initialisation
Exemple :
type identificateur_de_variable( valeur_d’initialisation) ;
int val(2) ;
double pi(3.1415) ;
char c(’a’) ;
int j(2*i+5) ;

Valeurs Littérales
▪ valeurs littérales de type entier : 1, 12, ...
▪ valeurs littérales de type réel : 1.23, ...
Remarque :
12.3e4 correspond à 12.3 · 104 (soit 123000)
12.3e-4 correspond à 12.3 · 10−4 (soit 0.00123)
▪ valeurs littérales de type caractère : ’a’, ’!’, ...
Remarque :
le caractère ’ se représente par \’
le caractère \ se représente par \\
▪ valeurs littérales de type booléen : true, false
Remarque : la valeur littérale 0 est une valeur d’initialisation qui
peut être affectée à une variable de n’importe quel type
Mot clé Auto
On peut laisser le compilateur deviner le type d’une variable
grâce au mot clé auto
Le type de la variable est déduit du contexte. Il faut donc
qu’il y ait un contexte, c’est-à-dire une initialisation
Par exemple: auto val(2) ;
auto pi(3.1415) ;
auto c(’a’) ;
auto j(2*i+5) ;
Conseil : N’abuser pas de cette possibilité et explicitez vos types

autant que possibles.

Données modifiables/non modifiables
Par défaut les variables sont modifiables.
Comme en C, si on ne veut pas qu’une variable soit

modifiable : la définir comme constante par l’indication du
mot réservé const lors de la déclaration
int const couple(2);

double const g(9.81);
Une fois déclarée, une constante ne pourra donc plus être modifiée
par le programme (toute tentative de modification produira un
message d’erreur lors de la compilation).

Variables
En C++, une valeur à conserver est stockée dans une variable
caractérisée par :
o son type
o et son identificateur ;
o (définis lors de la déclaration)
La valeur peut être définie une première fois lors de
l’initialisation, puis éventuellement modifiée par la suite.
Rappels de syntaxe : Types élémentaires
type nom ; (déclaration) int
type nom(valeur); (initialisation) double
char
nom = expression ; (affectation) bool
int val(2) ;
const double z(x+2.0*y);
constexpr double pi(3.141592653);
37
Programmation avancée c/C++ i = j + 3;
Opérateurs et expressions (1)
Les opérateurs arithmétiques sont
* multiplication
/ division
(Remarque : le modulo est le reste de la
% modulo division entière)
+ addition
- soustraction
L’évaluation d’une expression conduit (naturellement) à sa valeur. Exemple :

l’évaluation de l’expression (2*(13-3)/(1+4)) correspond à la valeur 4
Note : nous avons déjà précédemment rencontré l’opérateur =, dit d’affection, qui
est universel : il s’applique à tout type.
38
Opérateurs et expressions (2)
Autres exemples d’expressions, utilisées ici pour des
affectations :
z = (x + 3) % y;
z = (3 * x + y) / 10;
C++ fournit un certain nombre de notations abrégées pour
des affectations particulières.
x = x + y peut aussi s’écrire x += y
(idem pour -, *, / et %)
x = x + 1 peut aussi s’écrire ++x
(idem pour - : --x)
En C, choisir l’instruction x++; plutôt que ++x; pour l’incrémentation d’une
x variable de type élémentaire n’a quasiment aucune incidence sur l’efficacité du programme.
En C++, nous verrons que x peut être un objet quelconque.
Or, l’opérateur postfixé copie la valeur originale de x, incrémente x, puis retourne sa valeur
originale
Pour éviter une copie inutile et qui peut-être coûteuse, on utilisera systématiquement la
notation préfixée,++x (sauf en cas de réelle nécessité).
Quelques pièges à éviter!
Remarque sur l’opérateur de division en C++:
▪ si a et b sont des entiers, a/b est le quotient de la division
entière de a par b
Exemple : 5/2 = 2
(et a%b est le reste de la division entière de a par b
Exemple : 5%2 = 1)
▪ si a ou b sont des réels, a/b est le résultat de la division
réelle de a par b
Exemple : 5.0/2.0 = 2.5
Note : dans une expression constante, on distingue un réel
d’un entier en lui ajoutant . à la fin. En général pour la lisibilité
on préfère ajouter .0 :
5.0 (réel) ←→ 5 (entier)
40
Priorité entre opérateurs
Il est largement préférable de parenthèser ses expressions (ne
serait-ce que pour la lisibilité !).
Par exemple écrire (a * b) % c plutôt que a*b%c
En l’absence de parenthèsage, l’ordre de priorité des
opérateurs sera :
* ou / ou %
puis + ou -
Tous ces opérateurs sont associatifs à gauche :
a+b+c=(a+b)+c En cas d’ambiguité entre opérateurs du même
ordre de priorité c’est la règle d’associativité qui s’applique
Exemples : a * b % c = (a * b) % c
a % b * c = (a % b) * c
Programmation avancée c/C++ a + b * c % d = a + ((b * c) % d) 41
Les opérateurs de comparaison
Les opérateurs de comparaison sont :
== égalité logique
!= non égalité
< inférieur
> supérieur
<= inférieur ou égal
>= supérieur ou égal
Leur résultat est booléen.

Exemples : a >= y
x+y == 4
42
Attention !
Ne pas confondre l’opérateur de test d’égalité == et
l’opérateur d’affectation =
x = 3 : affecte la valeur 3 à la variable x

(et donc modifie cette dernière)
x == 3 : teste la valeur de la variable x, renvoie true si elle vaut

3 et false sinon
(et donc ne modifie pas la valeur de x)
Leur résultat est booléen.
Exemples : a >= y
x+y == 4
43
Les opérateurs logiques (1)
Les opérateurs logiques sont :
&& « et »
|| « ou »
∧ « ou exclusif »
Rémarque :
! négation
l’ opérateur ! n’a qu’un seul opérande
Exemples : ((z != 0) && (2*(x-y)/z < 3))
bool un_test(true);
...
((x >= 0) || ((x*y > 0) && !un_test))
44
Les opérateurs logiques (2)
Les opérateurs logiques &&, || et ! Sont définis par les tables
de vérité usuelles :
x y !x x && y x || y x∧ y
true true false true true false
true false false false true true
false true true false true true
false false true false false false

Evaluation « paresseuse »
Les opérateurs logiques && - || effectuent
une évaluation paresseuse (« lazy
évaluation ») de leurs arguments:
l’évaluation des arguments se fait de la

gauche vers la droite et seuls les
arguments strictement nécessaires à la
détermination de la valeur logique sont
évalués
dans X1 && X2 && ... && Xn,
les arguments Xi ne sont évalués que jusqu’au 1er
argument faux (s’il existe, auquel cas l’expression
est fausse, sinon l’expression est vraie);
Exemple : (x != 0.0) && (3.0/x > 12.0)
le second terme ne sera effectivement évalué

uniquement si x est non nul. La division par x ne
sera donc jamais erronée.
Et dans X1 || X2 || ... || Xn,
les arguments ne sont évalués que jusqu’au 1er
argument vrai (s’il existe, auquel cas l’expression
est vraie, sinon l’expression est fausse).
Exemple : (x == 0.0) || (3.0/x < 12.0)

le second terme ne sera effectivement évalué
uniquement si x est non nul.

Expression logique
Une expression logique est une expression de type booléen, dont
fles valeurs possibles sont donc true et false
Cependant, en C++, n’importe quelle expression de n’importe quel

type peut être considérée comme une expression logique. Ceci est
fait via la convention suivante :
Si l’évaluation de l’expression conditionnelle est une valeur nulle,
alors la condition sera dite fausse, sinon elle sera dite vraie
Exemple d’expressions vraies Exemple d’expressions fausse

True || false True && false
2 0
O.5 + 0.33 16 % 2
Conseil : évitez d’utiliser cette possibilité du langage et préférez écrire

explicitement vos expressions logiques.
Par exemple, écrivez if (x != 0) plutôt que if (x).
Opérateurs
Opérateurs Arithmétique Opérateurs de comparaison
* multiplication == égalité logique
/ division != non égalité
% modulo < inférieur
+ addition > supérieur
- Soustraction <= inférieur ou égal
++ increment
>= supérieur ou égal
-- decrement
Opérateurs logiques
&& « et »
|| « ou »
∧ « ou exclusif »
! négation
Priorités (par ordre décroissant, tous les opérateurs d’un même
groupe sont de priorité égale) :
! ++ --, * / %, + -, < <= > >=, == !=, ∧ &&, || 50
Entrée-Sorties de base
En C++ les entrées-sorties se font par le biais de flots ():
▪ Flot = objet dans lequel on peut lire (entrée) ou

écrire(sortie) des données
▪ cout est le symbole associé au flot de sortie standard
(terminal)
▪ cin est le symbole associé au flot d’entrée standard
(clavier)
▪ la lecture dans un flot se fait au moyen de l’opérateur >>
▪ l’écriture dans un flot se fait au moyen de l’opérateur <<
▪ Pour utiliser cout et cin, il faut inclure la librairie
iostream Programmation avancée c/C++ 51
Entrée-Sorties de base : lecture
#include<iostream>
int main()
{
int x;
double y;
// Lecture:
cin >> x >> y;
return 0;
}
▪ l’opérateur >> lit des valeurs dans un flot d’entrée et les

affecte (dans l’ordre de lecture) aux variables se trouvant
sur sa droite.
▪ les différentes valeurs à lire seront séparées par un espace
52
ou un retour à la ligne Programmation avancée c/C++
Entrée-Sorties de base : écriture
#include<iostream>
int main()
{
int n(10);
// Ecriture:
cout << "un entier :" << n << "un double :";
cout << (n+12.5 + 3.0) << endl;
return 0;
}
▪ l’opérateur << prend un flot de sortie à gauche, un ty

quelconque à droite. Il réalise l’écriture sur le support assoc
au flot et retourne le flot.
▪ endl provoque un saut de ligne
53
Instructions composées : les blocs
En C++, les instructions peuvent être regroupées en blocs.
Les blocs sont identifiés par des délimiteurs explicites de

début et de fin de bloc : { }
Exemple de bloc
{
int i ;
double x ;
cout << "Valeurs pour i et x : " << endl ;
cin >> i >> x ;
cout << "Vous avez saisi : i=" << i
<< ", x=" << x << endl ;
}
54
Branchement conditionnel
La syntaxe générale d’un branchement conditionnel est :
if (condition)
Instructions 1
else Instructions 2
La condition, qui s’exprime au moyen d’une expression, est

tout d’abord évaluée puis, si le résultat de l’évaluation est vrai
alors la séquence d’instructions 1 est exécutée, sinon la
séquence d’instructions 2 est exécutée.
Le else est optionnel
Instructions 1 et Instructions 2 sont soit une

instruction élémentaire, soit un bloc d’instructions.
Note : Il est conseillé de toujours utiliser la syntaxe par bloc
55
Choix multiples
On peut écrire de façon plus synthétique l’enchainement de
plusieurs conditions dans le cas où l’on teste différentes
valeurs (entières) d’une expression
if (i == 1)
Instructions 1
else if (i == 12)
Instructions 2
...
else if (i == 36)
Instructions N
else
Instructions N+1
switch (i) {
case 1:
Instructions 1
break;
case 12:
Instructions 2
break;
...
case 36:
Instructions N 56
break;
Exemple complexe
On peut écrire de façon plus synthétique l’enchainement de
plusieurs conditions dans le cas où l’on teste différentes valeurs
(entières) d’une expression
if (i == 1)
Instructions 1
else if (i == 12)
Instructions 2
...
else if (i == 36)
Instructions N
else
Instructions N+1
switch (i) {
case 1:
Instructions 1
break;
case 12:
Instructions 2
break;
...
case 36:
Instructions N
break; 57
Exemple plus complexe
Si on ne mets pas de break, l’exécution
ne passe pas à la fin du switch, mais
continue l’exécution des instructions du
case suivant :
switch(a+b) {
case2:
case8: instruction2; // lorsque (a+b) vaut 2 ou 8
case4:
case3: instruction3; // lorsque (a+b) vaut 2, 3, 4 ou 8
break;
case 0: instruction1; // execution uniquement lorsque
break; // (a+b) vaut 0
default: instruction4; // dans tous les autres cas
break;
}
Boucles
La syntaxe Générale d’une boucle avec condition de continuation
à priori (on veut tester la condition avant d’executer les instratuctions)
est :
while (condition)
Instructions
Tant que la condition de continuation est vérifiée, les instructions sont
exécutées.
a posteriori (on veut exécuter les instructions au moins une fois avant
de tester la condition) est :
do
Instructions
while (condition);
Les instructions sont exécutées jusqu’à ce que la condition de
continuation soit fausse (et au moins une fois au départ,
indépendemment de la valeur de la condition).
Boucles : Exercice
int i(0); int i(0);

while (i > 1) { do {
cout << i << endl; cout << i << endl;
i = i / 2 ; i = i / 2 ;
} } while (i > 1);
Quel sera l’affichage à l’écran 1 ? Quel sera l’affichage à l’écran 2?

Boucles : Exercice
int i(2); int i(2);

while (i > 1) { do {
i = i / 2 ; i = i / 2 ;
} } while (i > 1);

Boucles : Exercice
int i(2); int i(2);

while (i >= 1) { do {
i = i / 2 ; i = i / 2 ;
} } while (i >= 1);

L’itération for « classique »
Les iterations permettent l’application iterative d’un traitement
contrôlée par une initialisation, une condition de continuation, et un
operation de mise à jour de certaines variables.
Syntaxe : for (initialisation; condition; mise_a_jour)
Instructions
remarque ici que pour if et while :
Instructions est soit une instruction élémentaire (suivie de;), soit un
bloc d’instructions.
Il est plutôt conseillé de toujours utiliser la syntaxe par bloc
Note : Une boucle for (sans continue !) est équivalente à la
boucle while suivante :
initialisation;
while(condition) {
Instructions;
mise_a_jour;
}
63
Exercice ; itération for
Remarque : si plusieurs instructions d’initialisation ou de mise à

jour sont necessaires, elles sont séparées par des virgules.
Elles sont executées de la gauche vers la droite.
Qu’affiche l’instruction suivante ?
for (int i(0), s(0); i < 5; s += i, ++i) {

cout << i << ", " << s << endl ;
}

Les itérations for du C++11
En C++11, il y’a deux sortes d’itérations :
▪ Les iterations “classiques”, très générales
▪ Les nouvelles itérations, spéciquement pour parcourir des
ensembles de valeurs
les deux utilisent le mot clé for, mais se distinguent par leur
syntaxe :
for (initialisation; condition; mise_à_jour)

for (déclaration : collection)
Exemple d’itération sur un ensemble

for (int i : { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }){
cout << i*i << endl ;
Sauts : break et continue
Le C++ fournit deux instructions prédéfinies, break et continue,
permettant de contrôler de façon plus fine le dérulement d’une boucle.
▪ Si l’instruction break est exécutée au sein du bloc intérieur de la
boucle, l’exécution de la boucle est interrompue (quelque soit l’état
de la condition de contrôle);
▪ Si l’instruction continue est exécutée au sein du bloc intérieur de
la boucle, l’exécution du bloc est interrompue et la condition de
continuation est évaluée pour déterminer si l’exécution de la boucle
doit être poursuivie
Conseil : En toute rigueur on n’aurait pas besoin de ces

instructions, et tout bon programmeur évite de les utiliser.
Pour la petite histoire, un bug lié à une mauvaise utilisation de break; a conduit à l’effondrement du réseau
téléphonique longue distance d’AT&T, le 15 janvier 1990. Plus de 16’000 usagers ont perdu l’usage de leur
télé- phone pendant près de 9 heures. 70’000’000 d’appels ont été perdus
Instruction break : exemple
Exemple d’utilisation de break :
une mauvaise (!) façon de simuler une boucle avec condition
d’arrêt
while (true) {
Instruction 1;
...
If (condition_d_arret)
break;
}
autres instructions
Question : quelle est la bonne façon d’écrire le code ci-dessus ?

Instruction continue : exemple
Exemple d’utilisation de continue :
int i;
...
i = 0;
while (i < 100) {
++i;
if ((i % 2) == 0) continue;
// L’execution de la suite des instructions
// ne se fait pour les entiers impairs
Instructions;
...
}
Question : quelle est une meilleure façon d’écrire le code ci-dessus ?
(on suppose que Instructions; ... ne modifie pas la valeur de i)
Les structures de contrôle
Les branchements conditionnels si … alors …
if (condition) switch (expression) {
instructions case valeur:
........................ instructions;
if (condition 1) break;
instructions 1 ...
... default:
else if (condition N) instructions;
instructions N }
else
instructions N+1
Les boucles conditionnelles tant que …

while (condition) do
Instructions Instruction
while (condition);
Les iterations pour…allant de … à …

for (initialisation ; condition ; increment)
instructions
les sauts : break; et continue;

Note : instructions représente une instruction élémentaire ou un bloc.
instructions; représente une suite d’instructions élémentaires.
Retenir
▪ que les concepts fondamentaux de la POO permettent de
produire des programmes plus élégants, concis, fiables et
maintenables
▪ que la POO n’est pas spécifique au C++ mais que ce langage
met en oeuvre la plupart de ses concepts fondamentaux;
▪ que ce cours va aussi me permettre d’aborder des thèmes liés à
l’algorithmique;
▪ et . . . qu’il faut bien se replonger dans le B.A-BA pour
commencer :
o variables et expressions, structures de contrôles (if,
while,for, break, continue) et entrées-sorties de
base. Mais aussi pointeurs et SDD pour aller plus loin!
‼ je peux dès maintenant écrire des programmes non orientés-

objet simples, en faisant attention à bien adhérer désormais à
l’« esprit » C++ (plutôt que C).
PGCD EN C++
Ecrire un programme en C++ qui calcule le
PGCD de deux nombres entier A et B suivant
l’algorithme d'Euclide.
Algorithme d’EUCLIDE :
PGCD(A,B) = PGCD(B,A mod B) si A>=B

PGCD(A,B) = PGCD(A,B mod A) si A<=B
PGCD(A,0) = A
A mod B désigne le reste de la division entière entre A et B.

Poo Cplus1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Poo Cplus1

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Avancée

Programmation avancée c/C++ 1

Programmation avancée c/C++ 2

PGCD(A,B) = PGCD(B,A mod B) si A>=B

Programmation avancée c/C++ 4

Programmation avancée c/C++

Programmation avancée c/C++ 6

Marylène Micheloud & Medard Rieder

J.-C. Chappelier & F. Seydoux C++ par la pratique

Programmation avancée c/C++ 7

Programmation avancée c/C++ 8

 Extension objet du langage C

Programmation avancée c/C++ 9

 Extension objet du langage C

 Elaboré par Alan Kay, dans les années 70

 Développement par Bjam Stroustrup (1983 –

C ++ 98 ISO / IEC 14882: 1998 Sept. 1998

C ++ 03 ISO / IEC 14882: 2003 Oct. 2003

C ++ 11 ISO / IEC 14882: 2011 Sept. 2011

C ++ 14 ISO / IEC 14882: 2014 Dec. 2014

C ++ 17 ISO / IEC 14882: 2017 Dec. 2017

Le C date de 1969 – 1973 (Dennis Ritchie)

Plus précisément, le langage C++ est un langage

C++ = C + Typage fort + objets

Programmation avancée c/C++ 12

Programmation avancée c/C++ 15

o En POO, un objet regroupe les données et les

o Les objets interagissent entre eux.

Programmation avancée c/C++ 16

Un objet peut être vu comme une struct:

o Dotée de fonctions qui lui sont spécifiques

o Dans laquelle l’accès direct aux données peut être

Programmation avancée c/C++ 17

Par ailleurs, la plupart des langages non-objets admettent une

Tout ce qui est syntaxiquement valide en C l’est aussi en C++,

▪ C++ a apporté quelques changements plus élégants

Dans ce cours nous adhérerons le plus possible à une syntaxe

Programmation avancée c/C++ 22

Programmation avancée c/C++ 23

(déclarations des fonctions utiles) [recommandé]

int main() //ou int main(int argc, char **argv)

Commande : g++ hello.cc –o hello

En C++ les fichiers sources se terminent par l’extension .cc ou .cpp

double somme(double n1, double n2 );

double somme(double n1, double n2)

double somme(double n1, double n2 );

double somme(double n1, double n2)

Algorithme structures de données

Programmation avancée c/C++ 28

Ces données peuvent être :

Programmation avancée c/C++ 29

Un identificateur de variable peut être n’importe quelle séquence

où valeur est une constante ou une expression (voir plus loin)

Programmation avancée c/C++ 31

type identificateur( valeur_d’initialisation) ;

type identificateur_de_variable( valeur_d’initialisation) ;

Programmation avancée c/C++ 33

Conseil : N’abuser pas de cette possibilité et explicitez vos types

Programmation avancée c/C++ 35

Comme en C, si on ne veut pas qu’une variable soit

int const couple(2);

Programmation avancée c/C++ 36

L’évaluation d’une expression conduit (naturellement) à sa valeur. Exemple :