Programmation en C++

Licence 3 Automatique

R. Bouchebbat
Année universitaire 2018-2019
 OBJECTIFS

• L’objectif est de faire découvrir le langage, d’être

capable d’écrire et de concevoir un programme
C++ simple de bout en bout.
 BIBLIOGRAPHIE

• Apprendre le C++ de Claude Delannoy (sur lequel

s’appuie en partie ce cours)
• Pour les puristes : Le langage C++ de Bjarne
Stroustrup
• Pour les curieux : LE LANGAGE C de
Brian-W Kernighan, Denis-M Ritchie
• Le site de référence : http://www.cplusplus.com/
Intérêt des systèmes informatiques

Homme Machine
Lenteur Rapidité extrême
Oubli Mémorisation très
efficace

Incertitude Précision sans

inévitable égale
 Pourquoi le logiciel est-il important?

• Presque tous les appareils électroniques utilisent des

logiciels
• système de commande de moteur d'automobile,
dispositifs médicaux, télécommandes, machines de
bureau (p. ex. photocopieurs), appareils (p. ex.
téléviseurs, réfrigérateurs, laveuses / sécheuses, lave-
vaisselle, climatiseurs), outils électriques, jouets,
téléphones portables, lecteurs multimédias,
ordinateurs , imprimantes….
 Pourquoi des solutions logicielles?

• plus rentable pour implémenter la fonctionnalité

dans le logiciel que le matériel
• bugs logiciels faciles à corriger, donnant au client une
nouvelle mise à niveau logicielle
• bugs matériels extrêmement coûteux à réparer, le
client envoie son ancien appareil et le fabricant
envoie le remplacement
• permet d'ajouter de nouvelles fonctionnalités plus
tard
 Langages informatiques

• Un langage informatique est un outil permettant de

donner des ordres (instructions) à la machine

• A chaque instruction correspond une action du processeur

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

d’instructions) déstinés à effectuer une tache donnée

• Exemple: un programme de gestion de comptes bancaires

• Contrainte: être compréhensible par la machine

 Langage machine

• Langage binaire: l’information est exprimée et manipulée sous

forme d’une suite de bits

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

• 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

• Les opérations logiques et arithmétiques de base (addition,

multiplication, … ) sont effectuées en binaire

2007/2008 Module I2, 1ère année SMP/SMC 8

 L'assembleur
• Problème: le langage machine est difficile à comprendre par l'humain

• Idée: trouver un langage compréhensible par l'homme qui sera

ensuite converti en langage machine
• Assembleur (1er langage): exprimer les instructions élémentaires de
façon symbolique

ADD A, 4
traducteur langage machine
LOAD B
MOV A, OUT
… que le langage machine
• +: déjà plus accessible
• -: dépend du type de la machine (n’est pas portable)
• -: pas assez efficace pour développer des applications complexes

 Apparition des langages évolués

2007/2008 Module I2, 1ère année SMP/SMC 9

Langages haut niveau
• 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, …)
• 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
Compilateur/interpréteur

• Compilateur: traduire le programme entier une fois pour toutes

Compilateur exécution
exemple.c exemple
fichier source fichier exécutable
• + plus rapide à l’exécution
• + sécurité du code source
• - il faut recompiler à chaque modification

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

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

• Deux types de langages:

• Langages procéduraux
• Langages orientés objets

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

• Choix d’un langage?

Etapes de réalisation d’un programme

Enoncé du problème
Spécification
Cahier des charges
Analyse
Algorithme
Traduction en langage
Programme source
Compilation
Programme exécutable
Tests et modifications
Version finale et résultats

La réalisation de programmes passe par l’écriture d’algorithmes

 D’où l’intérêt de l’Algorithmique
 Algorithmique

• Un algorithme est un ensemble de règles opératoires dont

l’application permet de résoudre un problème donné au
moyen d'un nombre fini d'opérations.
• Un algorithme est la spécification précise et non ambiguë
d’une séquence d’étapes, chacune formée d'un nombre fini
d'opérations, pouvant être exécutée de façon automatique
par un ordinateur.
• Il est exprimé de manière formelle dans un langage
informatique (de spécification, de programmation, etc …)
ou dans un style informel en langage naturel.

Y.ZENNIR
 Propriétés d’un algorithme

Un algorithme doit:
– avoir un nombre fini d’étapes,
– avoir un nombre fini d’opérations par étape,
– se terminer après un nombre fini d’opérations,
– fournir un résultat.

Chaque opération doit être:

– définie rigoureusement et sans ambiguïté
– effective, c-à-d réalisable par une machine

Le comportement d'un algorithme est déterministe.

Y.ZENNIR
 Structure d’un algorithme

Algorithme le nom de l’algorithme

1:début
2:action 1
3:instruction 2
4:opération3
5: règle opératoire 4
6 :………….
7 :………….
8 :………….
. :………….
N :fin

Y.ZENNIR
 Langage de programmation ?

•Langage intermédiaire entre l’Humain et le processeur

•Permet d’exprimer les instructions algorithmique dans

langage rigoureux

Programme Programme
Programme en langage
Algorithme en langage en Code
machine binaire
de assembleur
programmation
ajouter 32 à s ADD s,32 10001110000 Processeur

s=s+32;
Y.ZENNIR
 Interprétation vs. Compilation

Il y a deux types de traducteurs de programmes:

interpréteurs
Transforment les programmes directement en séquences
de commandes ("comportements") exécutables sur une
machine virtuelle,
+ adaptés pour l'expérimentation de logiciels et le
prototypage rapide
+ effectuent la détection d'erreurs à l'exécution

Y.ZENNIR
 Interprétation vs. Compilation

Il y a deux types de traducteurs de programmes:

compilateurs
Traduisent les programmes en code machine exécutable
sur une machine réelle donnée
+ le code machine compilé est habituellement plus rapide
d'exécution
-la compilation elle-même prend du temps
-pour permettre la détection d'erreur avant l'exécution il
faut fournir plus d'information dans les programmes (ex.
types de données)

Y.ZENNIR
 Arbre
Programmatique

20
Y.ZENNIR
 Définition : Arbre Programmatique (AP)

La structuration d'un problème peut être réalisée à partir

d'un arbre programmatique.

Un arbre programmatique est un graphe qui est mieux adapté

à la représentation des algorithmes que l'organigramme ou
le structogramme parce qu'il en donne une vision spatio-
temporelle.

L'inconvénient du structogramme par exemple est qu'il est

préférable que l'on connaît la structuration du problème
avant de réaliser le structogramme.

Y.ZENNIR
 Définition : Arbre Programmatique (AP)

Les exemples vus jusqu'alors comportent des lignes

exécutées séquentiellement.

Ce traitement séquentiel peut être représenté à l'aide d'un

arbre programmatique :

Titre

Action i
Action1
Action2
Y.ZENNIR
 Définition : Arbre Programmatique (AP)

Ces graphes arborescents sont très utilisés dans la vie

courante. L'arbre programmatique correspondant au
programme Blocks.
Cet arbre ne faisant pas apparaître le type et la signification
des variables, un tableau est tenu à jour pendant la
construction de l'arbre. Lors du codage en Langage C d'un
arbre programmatique, la lecture s'effectue toujours de
gauche à droite.
Deux autres type de traitement peuvent être
envisagés dans un programme :
 le traitement conditionnel
 le traitement répétitif
Y.ZENNIR
 Principe :Arbre Programmatique (AP)

Un programme étant complètement réalisable à l’aide des trois

structures de contrôle. Séquence, alternative, répétition, une
représentation graphique de ces trois éléments est
suffisante pour décrire graphiquement tout programme c’est
à dire pour réaliser l’arbre programmatique :
Titre Titre

si
Action i
Action i P
Action1 Action1
Action2

La séquence L’alternative
 Principe :Arbre Programmatique (AP)

Titre

TQ
P : Proposition
La répétition P Action i TQ : Tant que
Action1

L'arbre programmatique, évidemment non nécessaire pour ce

programme, est dessiné à titre d'exemple. Il met en
évidence que le développement d'un arbre s'arrête au
niveau du détail dès que le programmeur estime qu'il sait
coder l'action exprimée.
Y.ZENNIR
 Structures dérivées

Titre
Titre

Pour i
JSQ
i(initiale)i(finale)
Action i P
Action1 Action i
Pour
Titre Jusqu’à

selon Autres cas

expression B
Valeur i
Valeur 1
selon
Action i
Action1
Y.ZENNIR
 Aspect Impératif Du C++

• Le C++ est une surcouche de C, avec quelques

incompatibilités de syntaxe
• Un programme C est la plupart du temps un
programme C++. Donc on peut faire du « C+ »
c’est-à-dire du C++ sans objet.
• Impératifs : les instructions se suivent dans un
ordre précis et transmis au processeur de la
machine dans cet ordre.
 Petite Histoire Du C/C++
Ken Thompson (à gauche) et Dennis Ritchie
(à droite). (source Wikipédia)
Le C a été inventé au
cours de l’année 1972
dans les laboratoires Bell
par Dennis Ritchie et Ken
Thompson.
En 1978, Brian Kernighan,
qui aida à populariser le
C, publia le livre « The C
programming Language »,
le K&R, qui décrit le C «
traditionnel » ou C ANSI.
 Petite Histoire Du C/C++

• Dans les années 80, Bjarne

Stroustrup développa le C++
afin d’améliorer le C, en lui
ajoutant des « classes ». Le
premier nom de ce langage
fut d’ailleurs « C with classes ».
• Ce fut en 1998 que le C++ fut
normalisé pour la première
fois. Une autre norme corrigée
fut adoptée en 2003.
• Une mise à jour importante
fut C++11, suivie de C++14,
Bjarne Stroustrup (source Wikipédia)
ajoutant de nombreuses
fonctionnalités au ,langage.
 Pourquoi apprendre le C ++?

• standard international
• puissant et efficace
• inclut le C en tant que sous-ensemble; donc peut
apprendre deux langues (C ++ et C) pour le prix d'un
• facile à déplacer de C ++ à d'autres langages mais
souvent pas dans une autre direction
• beaucoup d'autres langages populaires inspirés par C
++
 Caractéristiques du C ++

• flexibilité (peut être utilisé pour la plupart des

domaines d'application)
• Efficacité
• disponibilité (compilateurs C disponibles pour la
plupart des plateformes)
• portabilité (code source relativement portable d'une
plate-forme à une autre)
Population d'utilisateurs C ++

• croissance stable par la suite

 Domaines d'application

• bancaire et financier (virement de fonds, …..)

• édition assistée par ordinateur (éditeurs de
documents, édition d'images)
• systèmes embarqués (caméras, systèmes médicaux,
appareils)
• divertissement (jeux)
• calcul scientifique et numérique (physique,
ingénierie,…)
• systèmes de télécommunication (téléphones,
réseaux,…)
 Comment programmer?

Une fois trouvé l’algorithme, programmer en C++ comporte

3 phases:
1. Editer le programme – avec votre éditeur de texte favori. . .
2. Compiler le programme (avec g++)
3. Exécuter le programme
...
4. TESTER et DEBUGGER : retour au point 1 !

C¸a peut durer assez longtemps...

 Editeurs C++

• Visual C++ - com. License (http://msdn.microsoft.com/visualc)

• C++ Builder - com. license
(http://www.borland.com/us/products/cbuilder/index.html)
• Eclipse(CDT)/EasyEclipse
(http://www.easyeclipse.org/site/home/)
• Quincy (http://www.codecutter.net/tools/quincy/)
• Anjuta (http://anjuta.sourceforge.net/)
• KDevelop (http://www.kdevelop.org/)
• Code::Block (http://www.codeblocks.org/)
• BVRDE (http://bvrde.sourceforge.net/)
• RHIDE (http://www.rhide.com/)
Editeurs C++
Compilateurs C++
 Debugging C++

• Le débogage (Debugging) est un processus

méthodique pour éliminer les erreurs dans un
programme;
• Un bug est une erreur faite par les programmeurs.
• Appelé autrement:
• erreurs
• fautes
• Défauts
 Sources de bugs
• Mauvaise conception
• Mauvaise / mauvaise solution au problème
• Isolement insuffisant
• Les changements dans un domaine en affectent un autre
• Les typos
• Saisie de texte incorrect, choix d'une mauvaise variable
• Modifications / corrections ultérieures non terminées
• Un changement dans un domaine en affecte un autre
 HELLOWORLD.CPP

Comme dans la plupart des cours de programmation,

on commence par un HelloWorld : Programme le plus
simple qui affiche un message à l’écran.
Dans un éditeur de texte quelconque. (notez ici la
coloration syntaxique)
#include <iostream>
int main()
{
Std:: cout << "Hello World" << std::endl;
}
Compilation Et Exécution Du Helloworld
 Le HELLOWORLD Ligne À Ligne

#include <iostream>
En C++ comme en C, les lignes commençant par #
sont des « directives préprocesseurs ». Elles
s’adressent à un programme appelé préprocesseur,
cpp (pour « c preprocessor ») qui prépare le code
source en traitant ces directives.
Ici, en appelant #include, on dit au préprocesseur
d’inclure le fichier iostream, de la bibliothèque
standard C++ et qui contient les définitions pour
afficher quelque chose à l’écran.
 Le HELLOWORLD Ligne À Ligne

int main()
Il s’agit de l’entête de la fonction main. En C++,
une fonction se divise en deux parties principales.
L’entête et le corps de la fonction.
On peut voir ici trois éléments fondamentaux dans
l’écriture d’une fonction.
main est le nom de la fonction. En C++, c’est aussi le
point d’entrée du programme. Nous verrons plus tard
ce que cela signifie. Il faut juste retenir que main est
la seule fonction qui doit absolument apparaitre dans
un programme. C’est une convention.
 Le HELLOWORLD Ligne À Ligne

int main()
int est le type de retour de la fonction main. int pour
integer, c’est-à-dire que la fonction main, une fois
terminée, doit retourner une valeur entière. Pour
information, cette valeur peut servir dans
l’environnement appelant notre programme une
valeur de bonne exécution ou un code erreur.
() ici vide, il s’agit de la liste des arguments fournis lors
de l’appel de notre fonction.
 Le HELLOWORLD Ligne À Ligne

Std::cout << "Hello World" << Std ::endl;

• cout est la sortie standard iostream,

• Pour une entrée standard, utilisez cin
• Pour l'erreur standard, utilisez cerr
• << est un opérateur à insérer dans le stream
• Un opérateur membre de la classe iostream
• endl est un manipulateur iostream
• Termine la ligne en insérant un ou plusieurs caractères de
fin de ligne
 Notes

• ce qui suit après // sur la même ligne est considéré comme

un commentaire.
• l'indentation est pour la commodité du lecteur; le
compilateur ignore tous les espaces et les nouvelles lignes;
le délimiteur du compilateur est le point-virgule
• toutes les déclarations se terminent par un point-virgule

• Les minuscules par rapport aux majuscules comptent !!

• Main est différent de main
 Déclarations des variables
• En C++, avant d’utiliser une variable, une constante ou
une fonction, on doit la déclarer, ainsi que son type.
Ainsi, le compilateur pourra faire les vérifications
nécessaires lorsque celle-ci sera utilisée dans les
instructions.
• Une variable est définie jusqu’à la fin de la première
instruction composée (marquée par }) qui contient sa
définition.
 Déclarations des variables
#include <iostream>

/*Déclaration de la fonction somme */

double somme(double a, double b);
// point d'entrée de notre programme
int main()
{
int a, b;
std::cout << "Donnez deux entiers" << std::endl;
std::cin >> a >> b;
std::cout << a << " + " << b << "=" << somme(a, b);
}
 Déclarations des variables

Les types fondamentaux : voici les différents types

fondamentaux du C++ :
• Les entiers
• Les réels
• Les caractères
 Déclarations des variables

Les entiers, par taille-mémoire croissante :

• short, stocké sur 2 octets ; valeurs : de −215 à 215 − 1
(−32768 à 32767),
• long, stocké sur 4 octets ; valeurs : de −231 à 231 − 1,
• int, coincide avec short ou long, selon l’installation.
On trouve parfois le mot unsigned précédant le nom d’un type
entier (on parle alors d’entier non signé ;un tel entier est
toujours positif).
• unsigned short, stocké sur 2 octets ; valeurs :0 à 65535
• unsigned int,stocké sur 4 octets ; valeurs :0 à
429467295
 Déclarations des variables

Les reels, par taille-mémoire croissante :

• float, stocké sur 4 octets ; précision : environ 7 chiffres,
valeurs : -3.4E-38 à 3.4E+38
• double, stocké sur 8 octets ; précision : environ 15
chiffres, valeurs : -1.7E-308 à 1.7E+308
• long double, stocké sur 10 octets ; précision : environ
18 chiffres, valeurs : -1.2E-4932 à 1.2E+4932
 Déclarations des variables

Les caracteres: servent à représenter des caractères.,

• char , codés sur 1 octet, valeurs : -128 à 127
• unsigned char , codés sur 1 octet, valeurs : 0 à 255 ;
 Déclarations des variables
Une variable, comme son nom l’indique, est un espace mémoire
dont le contenu peut varier au cours de l’exécution.
#include <iostream>
Représentation en mémoire de a = 0
using namespace std;
a
int main() 000000 000000 000000 000000
{ 00 00 00 00
Inta; … 101 102 103 104 105 106 107 108 …

a = 0; Puis on lui donne la valeur 5, son

cout << "a vaut : " << a << endl;
a = 5; emplacement en mémoire n’a pas
cout << "a vaut à present : " << a << endl;
changé, mais le contenu si.
} a
000000 000000 000000 000001
00 00 00 01
… 101 102 103 104 105 106 107 108 …
 Déclarations des constantes

Syntaxe : c o n s t type nom = val;

Par exemple: c o n s t i n t Ta i l l e = 100 ;

Il ne sera pas possible de modifier Ta i l l e dans le reste du

programme (erreur `àla compilation). . .
 Les opérateurs

Il y a des nombreux opérateurs en C++

Classiques :
• Arithmétiques, relationnels, logiques
Moins classiques :
• Manipulation de bits
Et des opérateurs originaux, d’affectation, d’incrémentation
 Les opérateurs

Affectation:
En C/C++, l’affectation est une expression:
Soient v une variable et expr une expression.
v = expr affecte la valeur de expr à la variable v et
retourne la valeur affectée à v comme résultat.

Par exemple, i = ( j = 0) affecte 0 à j puis `à i et retourne 0

!!
 Les opérateurs

Pré et post incrément:

• ++var incrémente la variable var et retourne la nouvelle valeur.

(++i équivaut à i=i+1)

• var ++ incrémente la variable var et retourne l’ancienne valeur.

(i++ équivaut à (i=i+1)-1)

En dehors d’une expression, i++ et ++i sont donc équivalentes.

 Les opérateurs

Pré et post décrément:

• L’expression --var décrémente la variable var et retourne la
nouvelle valeur.

• L’expression var -- décrémente la variable var et retourne

l’ancienne valeur.
 Les opérateurs

Opérateurs arithmétiques:
C++ dispose d’opérateurs classiques binaires (deux
opérandes)
• Addition +, Soustraction -, multiplication * et
division /
Il y a aussi un opérateur unaire : - pour les nombres
négatifs. ( -x + y)
 Les opérateurs

Opérateurs arithmétiques:
Ces opérateurs binaires ne sont à priori définis que
pour des opérandes de même type parmi
Int, long int, float, double, et long double
Alors comment faire pour ajouter 1 (entier int ) et 2.5
(flottant simple précision) ? ce qui semble assez
naturel ? par le jeu des conversions implicites de
type. Le compilateur se chargera de convertir un
opérande ou les deux dans un type rendant
l’opération possible.
 Les opérateurs
#include
<iostream>
int main()
{ int a = 1;
double b = 3.14;
double c = a +b;
std::cout << sizeof(a) << ": " << a << std::endl;
std::cout << sizeof(b) << ": " << b << std::endl;
std::cout << sizeof(c) << ": " << c << std::endl;

Aura comme sorti :

$ ./a.exe 4: 1
8: 3.14
8: 4.14
 Les opérateurs

Opérateurs arithmétiques (opérateur %):

Reste de la division entière : n’est défini que sur les
entiers en C++.
Par ailleurs, il est à noter que la division / est différente
suivant le type des opérandes :
S’ils sont entiers alors la division est entière, sinon s’il
s’agit de flottants, la division sera réelle.
 Les opérateurs

Opérateurs arithmétiques:
• Il n’y a pas d’opérateur pour la puissance : il faudra
alors faire appel aux fonctions de la bibliothèques
standard du C++.
• En termes de priorité, elles sont les mêmes que
dans l’algèbre traditionnel. Et en cas de priorité
égale, les calculs s’effectuent de gauche à droite.
• On peut également se servir de parenthèses pour
lever les ambiguïtés, et rendre son code plus
lisible !!
 Les opérateurs

Opérateurs relationnels et de comparaisons:

Il s’agit des opérateurs classiques, vous les connaissez déjà.
Ils ont deux opérandes et renvoient une valeur booléenne
<, > , <=, >= , == , !=
Les deux derniers sont l’égalité et la différence.
En effet = est déjà utilisé pour l’affectation !
 Les opérateurs
Exemple des opérateurs d’égalité sur les doubles:
 Les opérateurs

Opérateurs logiques:
En C++ il y a trois opérateurs logiques : et (noté && )
ou noté (||) et non (noté !)
Ces opérateurs travaillent sur des valeurs numériques
de tout type avec la simple convention
Nulle  faux
Autre que nulle  vrai
 Les opérateurs

Opérateur conditionnel:
Il s’agit d’un opérateur ternaire.
Il permet des affectations du type :
Si condition est vraie alors variable vaut valeur,
sinon variable vaut autre valeur.
On l’écrit de la manière suivante :
x = (cond) ? a : b;
Par exemple :
int x = (y > 0) ? 2 :3;
 Les opérateurs

Autres opérateurs:
sizeof : Son usage ressemble à celui d’une fonction, il
permet de connaitre la taille en mémoire de l’objet
passé en paramétre.
Opérateurs de manipulation
de bit : &  ET bit à bit
|  OU bit à bit
^  OU Exclusif bit à bit
<<  Décalage à gauche
>>  Décalage à droite
~  Complément à un (bit à bit)
 Les structures de contrôle

• A priori, dans un programme, les instructions sont

exécutées séquentiellement, c’est-à-dire dans l’ordre
où elles apparaissent. Cependant, il est nécessaire
que certaines parties du code ne s'exécutent que
sous certaines conditions, ou s'exécutent plusieurs
fois.
• Le langage C++ dispose d’instructions, nommées
instructions de contrôle, permettant de réaliser ces
choix ou ces boucles.
 Les structures de contrôle

Les structures de contrôle se composent en deux parties

élémentaires:
• Les structures conditionnelles
• Les boucles
 Les structures conditionnelles

Définition:
On appelle structure conditionnelle les instructions qui
permettent de tester si une condition est vraie ou non,
avant d’exécuter le code spécifique à la condition.
1. L’instruction if / else:
La structure de contrôle if permet d'exécuter une
instruction ou une suite d'instructions seulement si une
condition est vraie.
 Les structures conditionnelles

La syntaxe d’une condition if est la suivante:

if (condition)

{ bloc d’instructions 1 }

Si la condition est vraie alors le bloc d’instructions 1 sera

exécuté.
 Les structures conditionnelles

La structure if peut être complétée d’un else permettant de

traiter les cas ou la condition sera Fausse, la syntaxe est :
if (condition)
{ bloc d’instructions 1}
else
{ bloc d’instructions 2}

Si la condition est vraie alors le bloc d’instructions 1 sera

exécuté. Sinon, le bloc d’instructions 2 sera exécuté.
 Les structures conditionnelles

if (condition) vrai faux

condition
{
S1;
}
S1 S2
else
{
S2;
}
S3; S3
 Les structures conditionnelles

Exemple :

#include <iostream>
using namespace std;
int main()
{ int a;
cout << "Tapez la valeur de a : "; cin >> a;
if (a >= 0)
{ cout << "a est positif" << endl;] }
else
{ cout << "a est négatif" << endl; }
}
 Les structures conditionnelles

2. L’instruction switch/case
L’imbrication de if = else peut avantageusement être
remplacée par une structure switch case. L'instruction
switch permet de tester plusieurs valeurs pour une
expression.
 Les structures conditionnelles
Syntaxe de switch/case
switch(expression)
{
case constante1:
instruction1_1// instructions exécutées si variable == constante1
instruction1_2...
break ;
case constante2:
instruction2_1 // instructions exécutées si variable == constante1
instruction2_2...
...
default:
instruction_1// instruction executés si variable
instruction_2...
}
 Les structures conditionnelles

• Les blocs d’instructions n’ont pas besoin d’accolades.

• Généralement chaque bloc se termine par l’instruction

break; qui saute à la fin de la structure switch
(l’accolade fermante).
• Si un bloc case ne se termine pas par une instruction
break;, à l’exécution le programme passera au bloc
case suivant.
 Les structures conditionnelles

Exemple:
#include <iostream> case 2 :
using namespace std; cout << "a vaut 2" << endl;
int main() break;
{ case 3 :
int a; cout << "a vaut 3" << endl;
cout << "Tapez la valeur de a : "; break;
cin >> a; default :
switch(a) cout << "a ne vaut ni 1, ni 2, ni
{ 3" << endl;
case 1 : break ;
cout << "a vaut 1" << endl; }
break; }
 Les Boucles

Définition:
Les boucles sont des structures qui permettent
d'exécuter plusieurs fois la même série d'instructions
jusqu'à ce qu'une condition ne soit plus réalisée...
1. La boucle For:
Le for est une structure de contrôle qui permet de
répéter un certain nombre de fois une partie d'un
programme.
 Les Boucles

La syntaxe d’une boucle for est la suivante:

for (instruction_init; condition; instruction_suivant)
{
Instruction_repetée ;
}

• instruction_init est une instruction (ou un bloc

d'instructions) exécutée avant le premier parcours de la
boucle du for, en général utilisée pour initialiser le
compteur de contrôle, ,.
 Les Boucles

• Condition est la condition à réaliser pour que la

boucle for continue d'itérer les instructions répétées
• Instruction_suivant, Une instruction (ou une série
d'instruction séparées par une virgule) pour passer à
l'itération suivante
• Instruction_répétée Une instruction ou un bloc
d'instruction répété à chaque itération de la boucle.
Les Boucles
 Les Boucles

Exemple d’une boucle For:

#include <iostream>
using namespace std;
int main()
{
int somme=0;
for (i=0; i<=10; i=i+1)
{
somme = somme + i;
cout<<la somme est =: <<somme<<endl;
}
 Les Boucles

2. La boucle While:
Le while permet d'exécuter des instructions en boucle tant
qu'une condition est vraie. Sa syntaxe est la suivante :
while (condition réalisée)
{
liste d'instructions
}
Cette instruction exécute la liste d'instructions tantque la
condition est réalisée.
Les Boucles
 Les Boucles

Exemple d’une boucle While:

#include <iostream>
using namespace std;
int main()
{
int somme 0,i=0;
while ( i<=10)
{
somme = somme + i;
cout<<la somme est =: <<somme<<endl;
i=i+1 ;
}
 Les Boucles

2. La boucle do…while:
Contrairement aux boucles for et while, la boucle do while
effectue les instructions de boucle avant d’évaluer l’expression
d’arrêt (le bloc [condition]). La syntaxe d’une boucle do while est la
suivante:
do
{
// Instructions de boucle répétées tant que la condition est vrai
}
while ( [condition] )
Les Boucles
 Les Boucles

Exemple d’une boucle do…while:

#include <iostream>
using namespace std;
int main()
{
Int somme 0,i=0;
do {
somme = somme + i;
cout<<la somme est =: <<somme<<endl;
i=i+1 ;
}
while ( i<=10)
}
 L’instruction break

il peut être voulu d'arrêter prématurément la boucle, pour

une autre condition que celle précisée dans l'en-tête de la
boucle. L'instruction break permet d'arrêter une boucle (for
ou bien while).L'instruction break sert à "casser" ou
interrompre une boucle (for, while et do), ou un switch.
int x;
while (std::cin >> x) {
if (x < 0) {
break;
}
std:: cout << x << ’\n’;
}
 L’instruction continue

L'instruction continue provoque le démarrage immédiat de

la prochaine itération de la boucle englobante.
int values [10];
...
// Affiche les éléments non nuls du tableau.
for (int i = 0; i < 10; ++i) {
if (values[i] == 0) {
// Sauter les éléments zéro.
continue;
}
// Affiche l'élément (différent de zéro).
std:: cout << values[i] << ’\n’;
}
 L’instruction goto

L’instruction goto transfère le contrôle sur une autre

instruction spécifiée par label.
int i = 0;
loop: // étiquette pour la déclaration goto
do {
if (i == 3) {
++i;
goto loop;
}
std :: cout << i << ’\n’;
++i;
} while (i < 10);
 Les Tableaux

Définition :
Un tableau est une structure de donnée, permettant de
stocker en mémoire un ensemble de valeurs du même
type à des adresses contiguës.
Les éléments du tableau peuvent être :
• des données de type simple : int, char, float, long,
double...
(la taille d'une case du tableau est alors le nombre
d'octets sur lequel la donnée est codée)
 Les Tableaux

Voici donc une manière de représenter un tableau :

donnée donnée donnée ... donnée donnée donnée

Les éléments du tableau peuvent être :

• Lorsque le tableau est composé de données de type simple,
on parle de tableau monodimensionnel (ou vecteur)
• Lorsque celui-ci contient lui-même d'autres tableaux on parle
alors de tableaux multidimensionnels (aussi matrice
ou table)
 Les tableaux unidimensionnels

Déclaration:
Un tableau unidimensionnel est un tableau qui contient
des éléments simples de même taille contenant des
éléments d'un type donné.
La déclaration d’un tableau à une dimension se fait de la
manière suivante :

type Nom_du_tableau [Nombre d'éléments]

 Les tableaux unidimensionnels

type Nom_du_tableau [Nombre d'éléments]

• type définit le type d'élément que contient le tableau.

• Nom_du_tableau est le nom que l'on décide de donner
au tableau, le nom du tableau suit les mêmes règles
qu'un nom de variable.
• Nombre d'éléments est un nombre entier qui
détermine le nombre de cases que le tableau doit
comporter.
 Les tableaux unidimensionnels

Exemple :
Déclaration d'un tableau :
int a[10];
• a est un tableau de 10 cases. Chaque case contient un
entier (type int).
• Les éléments sont a[0], a[1], a[2], a[3],…a[9]
Les tableaux unidimensionnels
 Les tableaux unidimensionnels

Stockage:
• Chaque élément est conservé à l'emplacement suivant
le long de la mémoire
• Essentiellement, le PC prend la première adresse
(désignée par la variable p) et compte ensuite.
 Les tableaux unidimensionnels

Accéder aux éléments:

• Pour accéder aux différents éléments d’un tableau, on
utilise l’opérateur [ ]. Chaque élément est repéré par sa
position nommée indice.
• Pour accéder à un élément du tableau, il suffit donc de
donner le nom du tableau, suivi de l'indice de l'élément
entre crochets :

Nom_du_tableau[indice]
 Les tableaux unidimensionnels

Nom_du_tableau [indice]

• L'indice du premier élément du tableau est 0

• Un indice est toujours positif
• L'indice du dernier élément du tableau est égal au
nombre d'éléments – 1
• Si nous initialisons moins de valeurs que la longueur du
tableau, C ++ attribue des zéros aux éléments restants.
 Les tableaux unidimensionnels
Manipuler les éléments:
Un élément du tableau (repéré par le nom du tableau et son
indice) peut être manipulé exactement comme une variable, on
peut donc effectuer des opérations avec (ou sur) des éléments
de tableau.
• Définissons un tableau de 10 entiers :
int Tab[10];
• Pour affecter la valeur 6 au huitième élément on écrira :
Tab[7] = 6;
• Pour affecter au 10ème élément le résultat de l'addition des
éléments 1 et 2, on écrira :
Tab[9] = Tab[0] + Tab[1];
Les tableaux unidimensionnels
Les tableaux unidimensionnels
 Les tableaux unidimensionnels

Initialiser les éléments:

Lorsque l'on définit un tableau, les valeurs des éléments
qu'il contient ne sont pas définies, il faut donc les initialiser,
c'est-à-dire leur affecter une valeur.
Une méthode rustique consiste à affecter des valeurs aux
éléments un par un :
• Tab[0] = Tab[1] = Tab[2] = 0;

 L'intérêt de l'utilisation d'un tableau est alors bien maigre..

 Les tableaux unidimensionnels

Initialiser les éléments:

Pour initialiser un tableau avec des valeurs spécifiques, il est
possible d'initialiser le tableau à la définition en plaçant entre
accolades les valeurs, séparées par des virgules :
int Tab[10] = {1, 2, 6, 5, 2, 1, 9, 8, 1, 5};
• Le nombre de valeurs entre accolades ne doit pas être supérieur
au nombre d'éléments du tableau

• Les valeurs entre accolades doivent être des constantes

(l'utilisation de variables provoquera une erreur du compilateur)
 Les tableaux unidimensionnels

Initialiser les éléments:

• Si le nombre de valeurs entre accolades est inférieur au
nombre d'éléments du tableau, les derniers éléments sont
initialisés à 0.
• Il doit y avoir au moins une valeur entre accolades.
• Ainsi, l'instruction suivante permet d'initialiser tous les
éléments du tableau à zéro :

• int Tab[10] = {0};

Les tableaux unidimensionnels
 Les tableaux unidimensionnels

Initialiser les éléments:

Une manière plus élégante consiste à utiliser le fait que pour
passer d'un élément du tableau à l'élément suivant il suffit
d'incrémenter son indice. Il est donc possible d'utiliser une
boucle qui va permettre d'initialiser successivement chacun
des éléments grâce à un compteur qui servira d'indice :

int Tab[10];
int Indice;
for (Indice = 0; Indice < 10; Indice++) {
cin>>Tab[Indice];
}
 Les tableaux multidimensionnels

Définiton:
Les tableaux multidimensionnels sont des tableaux qui
contiennent des tableaux.
Par exemple le tableau bidimensionnel (3 lignes, 4 colonnes)
suivant, est en fait un tableau comportant 3 éléments, chacun
d'entre eux étant un tableau de 4 éléments :
 Les tableaux multidimensionnels

Un tableau multidimensionnel se définit de la manière

suivante :
type Nom_du_tableau [a1][a2][a3] ... [aN]
• Chaque élément entre crochets désigne le nombre
d'éléments dans chaque dimension.
• Le nombre de dimensions n'est pas limité.
Un tableau d'entiers positifs à deux dimensions (3 lignes,
4 colonnes) se définira avec la syntaxe suivante :
int Tableau [3][4]
 Les tableaux multidimensionnels

int Tableau [3][4]

On peut représenter un tel tableau de la manière suivante :

le premier indice est l'indice de ligne, et le second est

l'indice de colonne.
 Les tableaux multidimensionnels

Initialiser les éléments:

L'initialisation d'un tableau multidimensionnel se fait à
peu près de la même façon que pour les tableaux
unidimensionnels. Il y a donc plusieurs façons d'initialiser
un tableau multidimensionnel :
• Initialisation individuelle de chaque élément :
Nom_du_tableau [0][0] = 2;
Nom_du_tableau [0][1] = 3;
 Les tableaux multidimensionnels

Initialiser les éléments:

• Initialisation à la définition :
type Nom_du_tableau [Taille1][Taille2]...[TailleN] = {a1,
a2, ... aN};
Les valeurs sont attribuées aux éléments successifs
en incrémentant d'abord les indices de droite, c'est-à-
dire pour un tableau à 2 dimensions : [0][0], [0][1],
[0][2] ... puis [1][0] etc.
 Les tableaux multidimensionnels

Initialiser les éléments:

• Initialisation grâce à des boucles :
Il faut faire des boucles imbriquées correspondant
chacune à un indice d'une dimension. Par exemple les
éléments de Tableau[3][4] pourront être initialisés par
les instructions suivantes :
int Tab[3][4], i, j;
for (i=0; i<3; i++) {
for (j=0; j<4; j++) {
cin>>Tab[i][j];
}
}
 Les Tableaux

Chaînes de caractères : En C++, une chaîne de caractères

est considérée comme un tableau de caractères dont le
dernier élément est le caractère '\0'.
Un tableau de chaîne de caractères peut être initialisé de la
manière suivante :

char msg[] = "Bonjour" ; // première façon

char msg[] = {'B', 'o', 'n', 'j', 'o', 'u', 'r', '\0'} ;// deuxième façon
 Quelques règles

Il ne faut pas confondre les éléments d’un tableau avec

le tableau lui-même. Ainsi, t[2] = 3, tab[i]++ sont des
écritures valides.
Mais t1 = t2, si t1 et t2 sont des tableaux, n’est pas
possible.
Il n’existe pas en C++ de mécanisme d’affectation
globale pour les tableaux.
 Quelques règles

Les indices peuvent prendre la forme de n’importe quelle

expression arithmétique d’un type entier.
Par exemple, si n, p, k et jsont de type int, il est valide
d’écrire :
t[n-3], t[3*p-2*k+j%1]
 Quelques règles

en C++, la dimension d’un tableau (son nombre d’éléments)

ne peut être qu’une constante, ou une expression constante.
Certains compilateurs l’acceptent néanmoins en tant
qu’extension du langage.
const int N = 50;
 Les Pointeurs

• Définition : un pointeur est une variable destinée à

contenir l'adresse (référence) physique de la case-
mémoire d'une autre variable.

• Les pointeurs constituent une notion fondamentale du

C++. Ils sont utilisés pour passer des paramètres à
une fonction ou pour créer des structures de données
complexes comme des tableaux de taille variable. Ils
sont toutefois complexe à utiliser et une source de
nombreux bugs.
 Les Pointeurs

Déclaration :
syntaxe : type *nom ;
Où : type est le type des variables pointées et nom est
l'identificateur du pointeur.

Exemple : int *p ; // p est un pointeur vers un entier.

 Les Pointeurs

Manipulation :

1. Référencement : L’opérateur unaire & fournit

l’adresse en mémoire d’une variable donnée.

Exemple :
int a ; // a est une variable ordinaire de type entier
int *x ; // x est un pointeur sur un entier
x=&a ; // opérateur de référencement (x reçoit l'adresse
de a)
 Les Pointeurs
POINTEURS – LES OPERATEURS * ET &
adresses valeurs variables Voici une représentation schématisée
0x0 de cet exemple:
…

#include <iostream>
0xn using namespace std;
0xffffcbf4 ptr
0xn+1
m main()
{
…

é
m int a;
0xffffcbf4
int *ptr;
o 0xffffcbf5 42 a
i ptr = &a;
r 0xffffcbf6 }
e
0xffffcbf7
…

…
 Les Pointeurs

2. Déréférencement : L’opérateur unaire * fournit la

valeur de la l’adresse en mémoire d’une variable
donnée.

Exemple :
int a=25 ; // a contient la valeur 25
int *x ; // x est un pointeur vers un entier
x=&a ; // x contient l'adresse de a
cout<<*x ; // affiche 25 (*x est le contenu de la
variable dont l'adresse est contenu dans x)
 Les Pointeurs

Incrémentation/décrémentation : l'incrémentation –
décrémentation d'un pointeur permet l'incrémentation –
décrémentation de l'adresse contenue dans celui-ci du
nombre d'octets réservé au type de donnée pointée.

Exemple:
int a=2,*x;
x=&a;
x++;
 Les Pointeurs

Remarques:
• Il est préférable d’initialiser le pointeur avant de
l’utiliser pour éviter les bugs!
• L'incrémentation/décrémentation d'un pointeur est utile
uniquement pour la manipulation de tableaux.
• L’incrémentation (décrémentation) exprime le fait
qu’on veuille atteindre l’élément suivant (précédent).
• Le résultat n’est correct que si l’élément pointé est
situé dans le même tableau.
 Les Pointeurs

Remarques:
• L’addition de deux pointeurs n’a pas de sens !
• La soustraction de deux pointeurs (ayant le même
type) situés dans le même tableau retourne le nombre
d’éléments qui les séparent.
• Un pointeur ne peut être comparé qu’à un pointeur du
même type ou un pointeur NULL.
• On ne doit affecter à un pointeur qu’une valeur de
pointeur ayant le même type sinon on doit s'attendre à
un bug.
 Les Pointeurs

Pointeurs et tableaux : en C++, un tableau est un pointeur.

Le nom d'un tableau est un pointeur constant sur le premier
élément de celui-ci.

Exemple : int tab[10];

int *p;
p=tab; // équivaut à p=&tab[0];
p++; // pointe vers l'élément tab[1].
 Les fonctions

Définition d'une fonction : une fonction est un sous-

programme appelé par le programme principal (ou
programme appelant) pour réaliser une tâche élémentaire.
Exemple: Par analogie à une usine de fabrication, le
programme appelant représente une chaîne de production et
la fonction représente une machine.
Il est à noter qu'une fonction peut appeler une autre fonction
(appel imbriqué) voire s'appeler elle-même (appel récursif).
 Les fonctions
Prototype d'une fonction : c'est un protocole entre la
fonction appelé et le programme appelant. Il définit l'ordre et
le type de chaque variable d'entrée ou de sortie de la
fonction. Le prototype de la fonction se met avant le
programme appelant.
Syntaxe: type_sortie nom_fonction (type1 var1,type2
var2,…)
{
déclaration des variables;
bloc d'instructions;
return(résultat du traitement);
}
 Les fonctions
Exemple:
int carre (int x)
{
int resultat;
resultat=x*x;
return(resultat);
}
• Le mot-clé return indique le résultat du traitement.
 Quelques remarques
• Si aucun type de sortie n'est spécifié, le type entier est pris par
défaut.
• Toutes les variables définies entre accolades sont dites locales à
la fonction sinon elles sont dites globales.
• Le nom de la fonction suit les mêmes règles que les noms de
variables:
 un nom de fonction peut comporter des lettres, des chiffres
et les caractères _ et & (les espaces ne sont pas autorisés !),
 le nom de la fonction, comme celui des variables est sensible
à la casse (différenciation entre les minuscules et
majuscules),
 Les fonctions

Appel d’une fonction : Pour exécuter une fonction, il suffit

de faire appel à elle en écrivant son nom (une fois de plus en
respectant la casse) suivie d'une parenthèse ouverte
(éventuellement des arguments) puis d'une parenthèse
fermée.
Exemple:
int main () {
int t, z;
t=3;
z=carre(t);
cout<<z<<endl; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ;
i f (a>b) r e s = a ;
return res ; }
...

i n t main() {
i n t x,y ;
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖
i f (a>b) r e s = a ;
return res ; } ―y‖

...

i n t main() {
i n t x,y ;
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖ 5
i f (a>b) r e s = a ;
return res ; } ―y‖

...

i n t main() {
i n t x,y ;
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖ 5
i f (a>b) r e s = a ;
return res ; } ―y‖ 10
...

i n t main() {
i n t x,y ;
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖ 5
i f (a>b) r e s = a ;
return res ; } ―y‖ 10
...
―z‖
i n t main() {
i n t x,y ;
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖ 5
i f (a>b) r e s = a ;
return res ; } ―y‖ 10 ―a‖ 10
...
―z‖ ―b‖ 5
i n t main() {
i n t x,y ;
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖ 5
i f (a>b) r e s = a ;
return res ; } ―y‖ 10 ―a‖ 10
...
―z‖ ―b‖ 5
i n t main() {
i n t x,y ; ―res‖ 5
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖ 5
i f (a>b) r e s = a ;
return res ; } ―y‖ 10 ―a‖ 10
...
―z‖ ―b‖ 5
i n t main() {
i n t x,y ; ―res‖ 10
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖ 5
i f (a>b) r e s = a ;
return res ; } ―y‖ 10 ―a‖ 10
...
―z‖ ―b‖ 5
i n t main() {
―res‖ 10
i n t x,y ;
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖ 5
i f (a>b) r e s = a ;
return res ; } ―y‖ 10
...
―z‖ 10
i n t main() {
i n t x,y ;
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions
i n t max(int a , i n t b )
{ i n t res=b ; ―x‖ 5
i f (a>b) r e s = a ;
return res ; } ―y‖ 10
...
―z‖ 10
i n t main() { ———————————–
i n t x,y ; z = 10
x=5 ;
y=10 ;
i n t z = max(y,x) ;
cout<<" z = "<<z ; }
 Les fonctions

Surcharge d'une fonction :

Un des apports les plus intéressants du C++ par rapport au
C, hormis l'ajout du concept objet, est la possibilité d'appeler
plusieurs fonctions avec le même nom, pour peu que celle-ci
aient leurs arguments différents (en type et/ou en nombre).
Ce principe est appelé surcharge de fonction. Il permet de
donner le même nom à des fonctions comportant des
paramètres différents et simplifie donc l'écriture de fonctions
sémantiquement similaires sur des paramètres de type
différent.
 Les fonctions

Surcharge d'une fonction :

En effet, une fonction est déterminée par ce que l'on appelle
sa signature, c'est-à-dire : son nom et ses paramètres. Il est
ainsi possible de définir une fonction réalisant la même
opération sur des variables différentes en nombre ou en
type.
Exemple:
int somme(int x,int y) {return(x+y);}
float somme(float x,float y) {return(x+y);}
float somme(float x,float y,float z) {return(x+y+z);}
 Les fichiers

Rappel, qu’est ce qu’un fichier?

• Une suite de données de même type !

• Stockées en mémoire secondaire (disque dur, CD,…).

• Sous forme d’octet (comme en mémoire centrale).

• Les données en mémoire centrale durent uniquement le

temps de programme => Mais un fichier est persistant.
Définition: Un fichier (file en anglais) est une suite
d’informations, enregistrée sur un support physique
(mémoire) et repérée par un nom logique.
 Les fichiers

Types de Fichiers :
1. Les fichiers textes : contiennent des informations sous
la forme de caractères (en général en utilisant le code
ASCII). La source d’un programme C++ est un exemple
de fichier texte.
2. Les fichiers binaires : contiennent directement la
représentation mémoire des informations (binaire). Un
fichier binaire peut aussi être vu comme une séquence
d’octets. Un exemple de fichier binaire est le résultat de
la compilation d'un programme C++.
 Les fichiers

Déclaration de fichiers :
La variable prédéfinie dans <fstream> est un constructeur
de fichiers logiques; et peut être :
• ofstream pour l'ouverture du fichier en écriture, ou
• ifstream pour l'ouverture du fichier en lecture.
 Les fichiers

Déclaration de fichiers :
Exemples :
• ofstream fichier1 ("C:/exemple.txt");// ouverture du fichier
texte.txt en écriture
• ifstream fichier2 ("C:/exemple.txt");// ouverture du fichier
texte.txt en lecture
 Les fichiers

Remarques :
• Pour utiliser un fichier, il fault tout d’abord l’ouvrir en utilisant
la méthode open(‘’ nom_de_fichier’’).
• Pour sauvegarder un fichier, il faut le fermer en utilisant la
méthode close().
• Pour écrire dans le fichier on utilise l'opérateur << .
• Pour lire dans le fichier on utilise l'opérateur >>.
 Les fichiers

Exemples :
• fichier1.open (‘’exemple.txt’’) // ouvre le fichier text nommé
«exemple».
• fichier1<<" Bonjour";// écrit Bonjour dans le fichier
exemple.txt.
• Fichier1>>x;// lit la valeur de la variable x en provenance du
fichier exemple.txt.
• Fichier1.close(); // sauvegarde le fichier exemple.txt.
 Les fichiers

Exemple sur l’utilisation de ofstream:

#include <iostream>
#include <fstream>
using namespace std;
int main () {
ofstream fichier1;
fichier1.open ("exemple.txt");
fichier1 << "salut tout le monde"<<endl;
fichier1.close();
}
 Les fichiers

Exemple sur l’utilisation de ifstream:

#include <iostream>
#include <fstream>
using namespace std;
int main () {
ifstream fichier1;
fichier1.open ("numbers.txt");
int x, y;
fichier1>>x>>y;
cout<<"num1: "<<x<<endl;
cout<<"num2: "<<y<<endl;
fichier1.close();
}
 Les fichiers

Règle générale :
La règle générale pour créer un fichier est la suivante :
• il faut l'ouvrir en écriture.
• on écrit des données dans le fichier.
• on ferme le fichier.
 Les fichiers

Règle générale :
Pour lire des données écrites dans un fichier :
• on l'ouvre en lecture.
• on lit les données en provenance du fichier.
• on ferme le fichier.
Paradigmes de programmation

• programmation procédurale : P.P.

(Pascal, C, etc.)
• programmation orientée objet : P.O.O. (Java,
C++, Delphi)
• etc.
 Programmation procédurale
(rappel de C)

Il s’agit de découper un programme en une série de

fonctions lesquelles ont pour but de réaliser un traitement
particulier : programmation procédurale.

DONNÉES

Sous-programmes
et
programmes
 Programmation procédurale
(rappel de C)

• le programme est composé des fonctions

• les données (variables) sont créées à l’intérieure des
fonction ou bien passées comme paramètres
• il y a un programme principal (main)
 Limitations

• Il n’y a pas de méthode ou de cadre pour bien

organiser les fonctions.
• Les modifications d’une fonction entraînent d’autres
modifications dans autre fonctions, etc. – la portée
d’une modification est trop grande et difficile à gérer.
• Redondance dans le code (la même chose est codé
plusieurs fois)
• Propagation des erreurs – déboggage difficile
 Programmation orientée objet

La programmation objet est inventée dans les années

1970 comme une extension de la programmation
procédurale.
L'idée est de concevoir les programmes non plus comme
des lignes de codes qui s'exécutent séquentiellement,
mais comme des objets qui dialoguent..
 Exemple

• Prenons ces informations :

• 11 Novembre 1918 (Armistice)
• 05 Juillet 1962 (Indépendance)
• 07 Mars 2005
• Ce sont des dates.
• Chaque date se caractérise par :
• un jour
• un mois
• une année.
 Les Dates

Date Indépendance

• Jour • 05

• Mois • Juillet

• Année • 1962

Une Date Armistice

•7 • 11

• Mars • Novembre

• 2005 • 1918
 Classes

• Le Jour, le Mois et l’Année sont les attributs d’une Date.

• Cet ensemble d’attributs est appelé une Classe.

 Objets

• Le 05 Juillet 1962 et le 11 Novembre 1918 sont chacune

des instances de la classe Date.

• Chacune de ces dates est appelée un Objet.

 Autre Exemple : Les planètes

• Saturne : planète gazeuse. Son diamètre est de 120.536 km.

Elle est à une distance moyenne de 1.426.725.400 km du
Soleil.
• Mars : planète rocheuse. Son diamètre est de 6794 km. Elle
est à une distance moyenne de 227.936.640 km du Soleil.
• Jupiter : planète gazeuse. Son diamètre est de 142.984 km.
Elle est à une distance moyenne de 779 millions de km du
Soleil.
• Terre : planète rocheuse. Son diamètre est de 12.756,28 km.
Elle est à une distance moyenne de 150.000.000 km du Soleil.
 Planète (suite)

Ces planètes ont en commun :

• Le Type : Rocheuse, Gazeuse
• La Distance au Soleil : 227936640, 779 millions,
1426725400, 150000000
• Le Diamètre : 12756.28, 120536, 142984, 6794
 La classe Planete

Planete Terre Saturne

•Type • Rocheuse • Gazeuse

•DistanceAuSoleil • 150000000 • 1426725400
•Diametre • 12756,28 • 120536

Jupiter Mars
• Gazeuse • Rocheuse
• 779 millions • 227936640
• 142984 • 6794
 Définir une classe en C++

class CDate class NomClasse

{ {
typeAttribut1 nomAttribut1;
int Jour;
typeAttribut2 nomAttribut2;
int Mois; typeAttribut3 nomAttribut3;
int Annee; typeAttribut4 nomAttribut4;
}; …
};
 Objet en C++

Comment créer un objet independance de type CDate ?

 La classe CDate est un type comme un autre (int,
char…)

{
CDate independance;
}
 Initialiser un Objet

Pour l’instant, notre objet independance n’est pas

encore le 05 Juillet 1962.

 Spécifier chaque attribut à la main

{
Independance.Jour = 05;
Independance.Mois = 07;
Independance.Annee = 1962;
}
 Initialiser un Objet

Autre exemple : la date armistice que l'on

souhaite initialiser au 11 Novembre 1918

{
CDate armistice;
armistice.Jour=11;
armistice.Mois=11;
armistice.Annee=1918;
}
 Intérêt de la POO

Spécifier des comportements génériques communs à tous

les objets de notre classe.

Par exemple :
• s'initialiser
• s'afficher
• vérifier si c'est contemporain
 Initialiser

class CDate void InitDate(int jour,

{ int mois,
int Jour ; int annee)
int Mois ; {
int Annee ; Jour = jour;
Mois = mois;
Annee = annee;
}
};
 Afficher

class CDate void Affiche()

{ int Jour ; {
int Mois ; cout
int Annee ; << Jour << "/"
<< Mois <<
"/" <<Annee ;
void InitDate(int jour,
}
int mois,
int annee) };
{…}
 Contemporain

class CDate bool Contemporain()

{ int Jour; {
int Mois;
if( Annee >= 2000 ) { return
int Annee; true; }
return false;
void InitDate(int jour,
}
int mois,
int annee) };
{…}

void Affiche()
{…}
 Exemple

{
CDate independance;
indépendance.InitDate(05,07,1962);
CDate armistice; armistice.InitDate(11,11,1918);

cout <<"La date "; independance.Affiche();

cout <<" est elle contemporaine ? "
<< indépendance.Contemporaine()<<endl;

cout <<"La date "; armistice.Affiche();

cout <<" est elle contemporaine ? "
<< armistice.Contemporain()<<endl;
}
 Résultat
{
CDate independance;
CDate armistice;

independance.InitDate(05,07,1962);
La date 05/07/1962 est elle contemporaine ? no
cout <<"La date ";
independance.Affiche();
cout <<" est elle contemporaine ? "
<< independance.Contemporain()<<endl;

armistice.InitDate(11,11,1918);
cout <<"La date ";
armistice.Affiche(); La date 11/11/1918 est elle contemporaine ? no
cout <<" est elle contemporaine ? "
<< armistice.Contemporain()<<endl;
}