Vous êtes sur la page 1sur 116

Introduction

à la programmation
orientée objets (POO)
I. Introduction au Langage C++
1.Historique (C++)
• Le C++ dont le concepteur est Bjarne Stroustrup (1982),
est fortement inspiré de deux autres langages de
programmation : C et Simula 67.
• le C++ reprend d'ailleurs l'ensemble des règles
syntaxiques du C, mais il corrige certains points faibles en
apportant des améliorations, extensions, nouveautés dont
les principales sont liées à la programmation orientée
objet inspirée surtout de SIMULA 67 mais aussi de ADA,
ALGOL 68...
2.Implantation des modules en C++

• Un module C++ est généralement implanté par deux


fichiers : un fichier d’interface qui regroupe les services
offerts par le module (définition de types, constantes,
déclaration de fonctions) et un fichier d’implantation
qui permet de définir les fonctions déclarées dans
l’interface. Les extensions conventionnellement utilisées
en C++ sont :
 .hh, .H pour les fichiers d’interface (les headers).
 .cc, .cpp, .C pour les fichiers d’implantation .
3.Structure d’un programme C++ :
• Pour pouvoir être compilé en une séquence binaire
exécutable, le code source doit fournir au compilateur
un «point d’entrée». Par convention, ce point d’entrée est
en C++ une fonction intitulée main qui peut être définie
de deux manières différentes :
• Programme sans paramètre :
int main() { ... }

• Programme avec paramètres :


int main(int argc, char *argv[]) { ... }
• argc : nombre de paramètres à passer dans main.
• argv: tableau de paramètres, le premier contient la chaîne
donnant le nom du programme.(exemple:
"C:\Programme Files\...\Hello.exe ")
• Note : La fonction main doit renvoyer un code d'erreur d'exécution
du programme, le type de ce code est int. La valeur 0 retournée
par la fonction main indique que tout s'est déroulé correctement.
• Exemple (Hello.CPP):

#include <iostream>
using namespace std;

int main() {
cout << "Hello world!";
}
II. Principe de la POO
Approches de programmation
a) La programmation procédurale
• La programmation procédurale (C, Pascal, Basic, …) est
constituée d’une suite d’instructions (souvent réunies
en fonctions) exécutées par une machine. Ces
instructions ont pour but d’agir sur des données pour
produire un effet quelconque.
b) La programmation Orientée Objet
• Une nouvelle entité est créée, objet, afin de regrouper les
fonctions et les données.
• Peu ou pas de variables globales.
• Un programme est vu comme un ensemble d’entités. Au cours
de son exécution, ces entités collaborent en s’envoient des
messages dans un but commun.
1. Notion d’objet:
• Un objet est une entité ayant une identité unique et regroupant
à la fois des données et des procédures (et/ou des fonctions).
Cette entité est sensée décrire un objet du monde réel. Le terme
‘objet’ est pris dans le sens large, cela peut être un objet
physique (comme une voiture, un avion, …) ou un objet
immatériel (comme un concept, une situation, une relation …).

• Exemple: Le diagramme suivant montre une voiture (identité) qui


contient les valeurs de trois attributs différents: la couleur, la masse et
la puissance fiscale (données ).
2. Encapsulation :
• Le regroupement des données et des fonctions qui les
manipulent (encapsulation).

• Les données d’un objet sont appelés ‘Attributs’ ou


encore ‘Champs’ et désignent sa partie statique.
• Les procédures ou fonctions sont appelées ‘Méthodes’
et représentent sa partie dynamique.
• Les attributs et méthodes d’un objet, représentent ses
‘propriétés’.
• Exemples :
1) Une Tasse de café est un objet, dont les propriétés pourraient
être :
couleur, quantité de boisson, température (données )
remplir( ) , boire( q ), laver( ) (Méthodes)
3. Abstraction des données :

• En général, la partie statique d’un objet reste


cachée au monde extérieur, c’est sa partie privée,
alors que la partie dynamique (les méthodes) est
visible et joue le rôle d’interface entre l’objet et son
entourage, c’est sa partie publique.
• Ce procédé de cacher les données du monde
extérieur est ce qu’on appelle l’abstraction des
données.
4. Communication entre objets :

• L’abstraction des données implique que la communication


avec un objet n’est possible qu’à travers ses méthodes
(jouant le rôle d’interface avec le monde extérieur).
• Dans un programme objet, le traitement n’est effectué
que par un ensemble d’objets communicant entre eux, par
invocation de méthodes publiques. La terminologie utilisée
pour décrire l’appel d’une méthode d’un objet est l’envoi de
message.
5. L'instanciation (Lien: 'instance_de')
Une classe d'objets est une catégorie représentant un type
d'objets et qui sert de moule pour la création (ou
l'instanciation) de nouveaux objets. Dans la figure suivante,
les objets Tasse1, Tasse2 et Tasse3 sont des instances de la
classe 'Tasse de Café'
• Tous les objets ayant une même structure et même
comportement appartiennent à la même classe (ils sont de
même type).
• Ainsi avant de commencer à créer des objets, il est nécessaire
de définir d'abord leurs classes d'appartenances. La définition
d'une classe consiste à lui donner un nom unique et à définir
les attributs et méthodes formant ses propriétés.
• En C++ on pourra définir une classe à l'aide de la déclaration :

class nom_classe {
// déclaration d'attribut et de méthodes
};
6. Notion de constructeur et destructeur

• Dans l'exemple précédent, la déclaration :


tasse_cafe tasse1;
permet de créer un nouvel objet (tasse1). L'espace
mémoire qui lui est nécessaire a été alloué par une
méthode spéciale qu'on appelle constructeur. Cette
méthode porte toujours le même nom que sa classe
(tasse_cafe) et est définie automatiquement par le
compilateur (c'est le constructeur par défaut).
• Le programmeur peut s'il le désir étendre le
constructeur par défaut, en déclarant un ou plusieurs
constructeurs pour sa classe, afin de réaliser certaines
tâches lors de la création de nouveaux objets (par
exemple initialisation des attributs par des valeurs
données). Les différents constructeurs déclarés par le
programmeur portent tous le même nom (le nom de la
classe) mais diffèrent par la liste des arguments. Un
constructeur ne retourne jamais une valeur. Aucun
type ne doit être spécifié comme résultat.
Le destructeur par défaut permet de libérer l'espace
occupé par l'objet. Le programmeur pourra aussi
déclarer son propre destructeur pour réaliser, en
plus, certaine tâches particulières. Le nom d'un
destructeur est toujours le nom de sa classe précédé
par le caractère : '~' (par exemple ~tasse_cafe() pour
la classe tasse_cafe ou ~date() pour la classe date).
Un destructeur ne retourne jamais de type et ne
peut pas avoir des paramètres.
7. L'héritage (Lien : 'est-un')
• Lorsqu'on déclare une nouvelle classe C, on a la
possibilité de spécifier que cette nouvelle classe doit
hériter des propriétés d'une ou de plusieurs classes
mères. Ainsi les nouvelles propriétés définies, seront
rajoutées à celles héritées pour former un nouveau
concept plus spécifique que ceux déjà définis dans les
classes mères. La classe C est alors une spécialisation
de ses classes mères. Ces dernières sont appelées les
super-classes de C.
• La figure suivante montre un exemple
ou la classe employe hérite de la
classe personne car tout employé est
d'abord une personne, et donc a
comme propriétés un nom, un
prénom, une adresse, etc... De plus,
un employé est aussi caractérisé par
d'autres propriétés propres aux
employés (comme le NSS, un salaire,
une fonction, etc ...). Les employés
forment alors une sous-classe de
l'ensemble des personnes.
De même la classe etudiant hérite
aussi de la classe personne pour les
mêmes raisons. La classe stagiaire est
une sous-classe de employe et de
etudiant (héritage multiple). Donc un
objet de type stagiaire et en même
temps un employe et un etudiant.
8. POLYMORPHISME
lorsqu'une classe C1 hérite d'une autre classe C2, cette
dernière lui transmet toutes ses propriétés (attributs et
méthodes). C1 pourra alors rajouter de nouvelles propriétés
pour spécialiser la définition de sa classe mère. En réalité, C1
peut rajouter de nouveaux attributs de nouvelles méthodes
et/ou redéfinir une ou plusieurs méthodes héritées afin de
tenir compte des nouveaux attributs de C1. C'est la notion de
surcharge de fonction utilisée dans C++ adaptée aux
méthodes d'une classe. Les méthodes redéfinies doivent avoir
les mêmes signatures (même déclaration d'entête), les seuls
changements concernent les corps des méthodes. C'est la
notion de méthodes polymorphique, c'est à dire un même
message pouvant être envoyé à plusieurs types d'objets
différents, chacun le traitant à sa manière.
III. Eléments du langage C++
Une structure simple d’un programme C++
1. Commentaires
• il est possible d’ajouter des commentaires facilitant ainsi la
lecture et la compréhension du programme.
• Toute suite de caractères encadrée par les symboles ‘/*’ et ‘*/’
correspond à un commentaire, et ne joue évidemment aucun
rôle lors de l’exécution du programme. Il faut noter aussi le
symbole ‘//’ pour un commentaire sur une seule ligne.
2. Identificateurs
• Un identificateur est un nom donné à un objet du
programme (variable, constante, fonction), composé de
lettres et de chiffres commençant par une lettre. Le
caractère _ (souligné) est considéré comme une lettre.
 En C/C++, les lettres minuscules sont différenciées des
majuscules ainsi TAILLE, Taille et taille sont trois
identificateurs différents et peuvent être utilisés dans le
même programme.
 Les mots réservés par le compilateur, dans la syntaxe du
C++, ne peuvent être utilisés comme identificateurs à cause
des confusions que cela pourrait entraîner.
3. Directives du préprocesseur

• Les directives du préprocesseur permettent d'effectuer un


prétraitement du programme source avant qu'il soit
compilé. On y retrouve ce dont le compilateur a besoin
pour compiler correctement un programme. Ces
directives sont identifiées par le caractère dièse (# qui
constitue un signal au préprocesseur) comme premier
caractère de la ligne. On les utilise pour l’inclusion de
fichiers, …
• La directive #include insère, au moment de la compilation, le
contenu d'un fichier, généralement réservé à l'inclusion de
fichiers appelés fichiers en-tête contenant des déclarations de
fonctions précompilées, de définition de types... Il sert à
inclure des librairies qui regroupent des ensembles de
fonctions qui permettent de faciliter la tâche du
programmeur. Ces fichiers sont traditionnellement suffixés
par .h (header file), mais en C++, il n'est pas toujours
nécessaire de spécifier l'extension .h surtout si on ajoute la
déclaration using namespace std;
invoque le fichier qui comporte des routines auxiliaires
concernant les opérations d’entrée/sortie (par exemple saisie
au clavier et affichage à l’écran).
4. Points-virgules

• Le point virgule est un terminateur d’instruction, on en


met donc après chaque instruction. On met également
un point virgule après chaque déclaration.
5. Type de données
• chaque entité (variables, fonctions, …) manipulée dans
un programme doit être déclarée et son type est vérifié
à la compilation. Il permet la représentation des
données sous différents formats. Les différents types
de données de base à partir desquels on peut
construire tous les autres types, dits types dérivés
(tableaux,…) sont les suivants:
•C++ introduit le type bool (booléen) qui s'accompagne des mots-clés true et
false.
•Il existe aussi le type void : il s'agit d'un "pseudo-type" utilisé pour spécifier le
fait qu'il n'y a pas de type. Ce type sera surtout utilisé au moment de déclaration
des fonctions (fonctions ne renvoyant rien).
6. Les variables
• Les variables, qui doivent être déclarées avant leur
utilisation, sont des données dont la valeur peut être
modifiée durant l'exécution du programme. Chaque
variable possède un type de données, une adresse
mémoire et un nom qui est son identificateur. Pendant
l’exécution du programme, elles occupent de la place
mémoire.
•En utilisant le mot clé réservé const, nous pouvons indiquer que la
valeur de cette variable ne change pas (constante) au cours d'un
programme comme dans:
const int MAX = 1000;
const char NEWLINE = '\n';
L’initialisation de telles variables est obligatoire lors de leur
déclaration.
• En ce qui concerne le type caractère, il existe des
caractères spéciaux (constantes) représentant une
séquence d’échappement qui seront toujours précédés
de l’anti-oblique (backslash : \) et sont interprétés
comme suit :
7. Mots réservés
• Les mots réservés du langage sont des noms
prédéfinis qui ont une signification particulière, et ne
peuvent pas servir de noms de variables personnelles.
8. Opérateurs et expressions
• Opérateurs arithmétiques
Il est possible de convertir explicitement une valeur d’un
certain type vers un autre, quelconque, en forçant la
transformation à l'aide de la syntaxe:
(Type) <Expression>
Int I=3, J=4;
float K;
K = (float)I/J;
La valeur de I est explicitement convertie en float. La valeur de J
est automatiquement convertie en float. Le résultat de la division
(type rationnel, valeur 0.75) est affecté à K.

Les contenus de I et de J restent inchangés; seulement les valeurs utilisées dans les
calculs sont converties.
•Opérateurs logiques et opérateurs de comparaison
• Les opérateurs logiques permettent de calculer des
expressions logiques, au résultat vrai, ou faux.

• Les résultats de ces opérateurs sont du type booléen. Le


résultat d'une expression logique vaut true si elle est vraie
et false sinon.
•Opérateurs d'affectation
• Le symbole d’affectation = est un opérateur à part
entière qui peut être utilisé au sein d’expressions. Son
rôle consiste à évaluer l’expression du membre de
droite et à transférer ce résultat comme valeur de
l’objet au membre de gauche.
Exemple:
9. Les entrées/sorties
• La saisie/affichage ou entrée/sortie (I/O) est gérée par des
librairies, c’est-à-dire des ensembles de fonctions/objets
standard pré-programmées, livrées avec les compilateurs.
Un programme qui utilise les flux standard d'entrée/sortie
doit comporter la directive
#include <iostream.h>
ou
#include <iostream>
using namespace std
• Les flux d'entrée/sortie sont représentés dans les
programmes par les trois variables, pré-déclarées et pré-
initialisées, suivantes :
• cout, le flux standard de sortie, habituellement associé à
l'écran,
• cin, le flux standard d’entrée, habituellement associé au
clavier,
• cerr, le flux standard pour la sortie des messages d’erreur
associé à l’écran.
• Les écritures et lectures se font à l'aide des opérateurs
<<, appelé opérateur d'injection (injection de données
dans un flux de sortie), et >>, appelé opérateur
d'extraction (extraction de données d'un flux d'entrée).
• Un fichier source C++ correspond à un fichier texte
contenant des lignes de code. Ce fichier prend
généralement pour extension .cpp Lorsqu'un
programme est chargé, son exécution commence
par l'appel d'une fonction spéciale du programme.
Cette fonction doit impérativement s'appeler
main() (principal en anglais) pour que le
compilateur puisse savoir que c'est cette fonction
qui marque le début du programme.
Notions de base
I. Les structures de contrôle

1. La structure alternative

• La structure alternative (ou instruction


conditionnelle) permet de ne pas exécuter
systématiquement certaines instructions, mais
seulement dans certains cas bien prévus par le
programmeur.
La partie <expression logique > peut désigner :
· une variable d'un type numérique,
· une expression retournant un résultat numérique.
La partie <bloc d'instructions> peut désigner :
· un bloc d'instructions compris entre accolades,
· une seule instruction terminée par un point-virgule.
Si <expression logique > est vrai <bloc d'instructions 1> est exécuté.
Dans le cas contraire c’est <bloc d'instructions 2> qui est exécuté.
• Les structures de décision imbriquées
s'écrivent par la construction abrégée:
• Exemple
2. La structure de sélection (switch)
• L'instruction switch permet de remplacer
plusieurs instructions if-else imbriquées. Cette
instruction permet de gagner en lisibilité quand
le nombre de if-else imbriqués augmente. La
variable de contrôle est comparée à la valeur
des constantes de chaque cas (case). Si la
comparaison réussit, les instructions du case
sont exécutées jusqu'à la première instruction
break rencontrée.
variable_controle doit être de type int, short, char ou long.
break fait sortir du sélecteur. En l'absence de break, l'instruction suivante est
exécutée; on peut ainsi tester plusieurs cas différents et leur attribuer la même
instruction.
Le bloc "default" n'est pas obligatoire. valeur1, valeur2, …. doivent être des
expressions constantes.
L’instruction switch correspond à une cascade d’instructions if ...else.
• Exemple:
3. Les instructions répétitives
• Nous disposons de trois structures de contrôle
d'itérations, appelées aussi structures répétitives ou
encore boucles, qui nous permettent d’exécuter
plusieurs fois certaines phases de programmes. Les
boucles conditionnelles sont:
1) la structure : for (pour…)
2) la structure : while (tant que ...),
3) la structure : do - while (faire… tant que)
• Ces boucles ont toutes en commun le fait que
l’exécution des instructions à répéter dépend, comme
avec les instructions alternatives, d’une condition
(<expression logique >).
3.1. Instruction for
• Exemple:
3.2. Instruction while:
• Si le bloc instruction est composé de plusieurs
instructions, on les placera entre les symboles
de début et de fin de bloc: “{” et “}” soit :
• Exemple:
3.3. Instruction do ... while
4. Instructions de branchement

• Les instructions de branchement transfèrent le


contrôle du programme d’une instruction à
une autre.
• mots réservés:
break ; continue ; goto ; return
II. Les tableaux
Tableaux à une dimension

Exemple:

• Utilisation: Un élément du tableau est repéré par son


indice. Les tableaux commencent à l'indice 0. L'indice
maximum est donc dim-1.
Appel: Nom_Tableau[indice]

Exemple Tab1[2] = 3;
Tableaux à deux dimensions

Exemple: int Tab[4][5];

• Utilisation : Un élément du tableau est repéré par ses


indices. Les tableaux commencent aux indices 0. Les
indices maxima sont donc dim1-1, dim2-1.
Appel : Nom_Tableau [indice1][indice2]

Exemple: Tab[2][4] = 25;


• Initialisation et réservation automatique
Lors de la déclaration d'un tableau, on peut initialiser ses
composantes en indiquant la liste des valeurs respectives
entre accolades.
Exemple
Exemple1:

• Ecrire un programme qui lit la dimension N (<=


NE_Max=10) d'un tableau T du type int, remplir le tableau
par des valeurs entrées au clavier. Calculer et afficher
ensuite le produit des éléments du tableau.
Exemple2:

• Ecrire un programme qui affiche les éléments


du tableau à deux dimensions suivant :
int A[3][5] = {{ 0, 1, 2, 3, 4}, {10,11,12,13,14}, {
20,21,22,23,24} };
III. Les chaînes de caractères
• Une chaîne de caractères peut être traitée et manipulée
à travers un tableau de caractères à une dimension
(vecteur de caractères), avec des déclarations dont la
syntaxe est de type :
char Ident[dim];
Ident : Nom de la chaîne de caractères
• Il existe aussi un type spécial string (le mot anglais pour
une chaîne de caractères), dont la syntaxe est de type :
string Ident;
Il faut inclure <string>
• Exemple1:

Le caractère nul '\0' (null terminator).

• Exemple2:
IV. Les fonctions
une fonction est un module qui désigne une entité de
données et d'instructions qui fournissent une solution à
une partie bien définie d'un problème. Une fonction peut
faire appel à d'autres fonctions, leur transmettre des
données et recevoir des données en retour. L'ensemble
des modules ainsi reliés doit alors être capable de
résoudre le problème global.

En général, le nom d'une fonction apparaît à trois


endroits dans un programme:
1) lors de la déclaration
2) lors de la définition
3) lors de l'appel
• Exemples:
Appel et déclaration de fonctions
• Une déclaration de fonction, qui se termine par un
point-virgule, fournit des indications sur le type, le
nom et sur d’éventuels paramètres. Mais
contrairement à une définition, une déclaration de
fonction ne fait que donner au compilateur des
renseignements sur l’existence d’une entité et n’en
crée pas de nouvelle.
• Les fonctions, une fois définies, peuvent être
appelées dans le corps d'autres fonctions, ou de la
fonction elle-même (récursivité). La définition ou la
déclaration d’une fonction doit se faire avant l’appel
de celle-ci.
• Exemple:
Passage de paramètres par valeur
• les paramètres d'une fonction sont à considérer
comme des variables locales qui sont initialisées
automatiquement par les valeurs indiquées lors
d'un appel. A l'intérieur de la fonction, nous
pouvons donc changer les valeurs des paramètres
sans influencer les valeurs originales dans les
fonctions appelantes.
• Exemple:
Surcharge des fonctions
• La surcharge de fonction consiste à définir des
fonctions ayant le même nom, mais un type et/ou un
nombre d'arguments différents. Cette technique
permet donc de définir des fonctions faisant ou non le
même traitement dans des contextes différents.
• Par exemple on peut définir
int Somme(int, int)
et
float Somme(float,float),
• Exemple:

y);
V. Les pointeurs et les références
Un pointeur: qu'est-ce que c'est ?

• C’est donc une variable dont le contenu est


l'adresse mémoire d'une autre variable c'est-
à-dire la position en mémoire de cette autre
variable. Un pointeur permet donc de
retrouver la valeur d'une variable (par son
adresse) et d'y accéder.
Déclaration de pointeurs
• type* nom_du_pointeur;

• Exemple:
Une référence: qu'est-ce que c'est ?

• Une référence vers un objet permet de définir


un nouveau nom, un alias, un synonyme, pour
désigner l’emplacement mémoire de l’objet
référencé. En tant qu'alias, la référence doit
impérativement être initialisée, avec l'objet
référencé.
Déclaration de références
• Les références se déclarent de la manière suivante :
type &nom_référence = identificateur;
• La référence doit être initialisée à la déclaration. Après
cette déclaration, nom_référence peut être utilisé partout
où identificateur peut l'être. Ce sont des synonymes.
Pointeurs, références et arguments de fonctions
Allocation dynamique de la mémoire
Classes et objets
1. Instance de classe:
2. Accès au membre d’un objet:
• Les objets créés de façon statique sont
automatiquement détruits dès que le
programme quitte la portée où ils ont été
créés, en général à la sortie du bloc. Le
programmeur n’a donc pas besoin de les
détruire.
Pour la création dynamique d’un objet, il convient de
respecter les étapes suivantes :
• définir un pointeur vers la classe ;
• utiliser l’opérateur new ;
• détruire l’objet après son utilisation.
• L’opérateur new crée un objet de type points et renvoie
l’adresse de l’objet créé, ce qui permet d’initialiser le
pointeur
• Dans le cas de la création dynamique, il faut
obligatoirement détruire les objets après les avoir
utilisés. Pour cela, C++ fournit l’opérateur delete qui
permet de détruire l’objet référencé par un pointeur.
3. Opérateurs de résolution de portée:
• On remarque la présence du "Points::"
(:: opérateur de résolution de portée) qui signifie
que la fonction est en faite une méthode de la
classe Points. Le reste est complètement identique.
4. Définition des classes/fichiers entête:
NOTIONS D’ENCAPSULATION

• L'encapsulation ou masquage d'information


consiste à séparer les aspects externes d'un
objet accessibles pour les autres, qu'on
désigne par publique, des détails
d'implémentation interne, rendus invisibles
aux autres, qu'on désigne par privé.
La visibilité d’une caractéristique détermine si d’autres
classes peuvent l’utiliser directement.
On utilise 3 niveaux de visibilité:
+ (Public) :
Les données et fonctions membres sont accessibles dans
toute l'application.
# (Protected) :
Les données et fonctions membres ne sont accessibles que
par les fonctions membres de la classe et de toutes classes
dérivées (héritage).
- (Private) :
Les données et fonctions membres ne sont accessibles que
par les fonctions membres de la classe. Par défaut les
membres sont privés.
Programme principal:

Commentaires :
· L’attribut couleur est privé.
· La méthode colorier est privée.
Initialisation et constructeur:
Un constructeur est une fonction membre spéciale
dont la tâche est d'initialiser l'objet; elle porte le
même nom que la classe, elle n'a pas de résultat,
et elle peut avoir 0 ou plusieurs paramètres. Elle
est appelée lors de la déclaration de l'objet d'une
façon implicite.
• Un constructeur doit s’en tenir aux règles suivantes:
 Un constructeur doit porter le même nom que sa
classe.
 Un constructeur ne peut pas être défini avec une
valeur de retour même pas void.
 Un constructeur sans paramètres est un constructeur
par défaut.
 Un constructeur dont tous les paramètres ont des
paramètres par défaut est un constructeur par défaut.
 Un constructeur doit être public.
Les destructeurs:

Vous aimerez peut-être aussi