1. Programmation Orientée Objet
C++
Pr. Nabil EL AKKAD
A. U: 2023/2024
Université Sid Mohammed Ben Abdellah
Ecole Nationale des Sciences Appliquées
Fès
3. Introduction
C++ présente, par rapport au C, des extensions qui ne sont pas véritablement
orientées P.O.O. En voici un bref résumé :
• Nouvelle forme de commentaire (en fin de ligne),
• Plus grande liberté dans l’emplacement des déclarations (initialisation),
• Notion de référence facilitant la mise en œuvre de la transmission d’arguments par
adresse,
• Surdéfinition des fonctions : attribution d’un même nom à différentes fonctions, la
reconnaissance de la fonction réellement appelée est faite d’après le type et le
nombre des arguments figurant dans l’appel (on parle parfois de signature),
• Nouveaux opérateurs de gestion dynamique de la mémoire : new et delete,
• Possibilité de définir des fonctions "en ligne" (inline), ce qui accroît la vitesse
d’exécution, sans perdre pour autant le formalisme des fonctions.
3
4. Commentaires
/* commentaire multi-ligne
En C */
C
/* même chose en langage de programmation
C++, mais … */
// … on a aussi
// commentaire à une seule ligne
C++
Déclaration de variables : n’importe où et de les initialiser
4
Règles:
• Toujours déclarer ses variables au dernier moment.
• Initialiser TOUTES les variables.
• Déclarer une variable par ligne.
5. Constantes
Pointeur variable vers une chaîne de
caractères variable.
char* c1;
Pointeur variable vers une chaîne de
caractères constante.
const char* c2;
Pointeur constant vers une chaîne de
caractères variable.
char* const c3;
Pointeur constant vers une chaîne de
caractères constante.
const char* const c4;
5
6. Type de base
• Le type d’une donnée détermine :
– La place mémoire (sizeof()) , les opérations légales et les bornes
6
Réf: http://www.cplusplus.com/
7. • Héritage des mécanismes de bases du C (pointeurs inclus)
• Déclaration et initialisation de variables :
bool varTrue = true; // variable booléenne
cout << varTrue;//pour afficher true ou false
int i = 0; // entier
long j = 123456789; // entier
long float f = 3.1; // réel
double pi = 3.141592653589793238462643; // réel à double précision
char c=‘a’; // caractère
• Initialisation à la mode objet :
int i(0) ;
long j(123456789);
7
Type de base (suite)
8. Porté des variables
• La portée (visibilité) d’une variable commence à la fin de sa déclaration jusqu’à la
fin du bloc de sa déclaration
int i, j, m; // variable globale
void f (int i) { // une fonction nommée f de paramètre i
int j; j=i; } // j est une variable locale
• Opération
int a, b=3, c, d=3;
a=++b; // équivalent à b++; puis a=b; => a=b=4
c=d++; // équivalent à c=d; puis d++; => c=3 et d=4
• Opérateurs de comparaison
– if(i==j) // évalué à vrai (true ou !=0) si i égal j
– if(i!=j) // évalué à vrai (true ou !=0) si i est différent de j
– if(i>j) // ou (i<j) ou (i<=j) ou (i>=j)
– if(i) // toujours évalué à faux si i==0 et vrai si i!=0
– if(false) // toujours évalué à faux
– if(true) // toujours évalué à vrai
– if (i=1) // toujours vrai car i vaut 1
• Ne pas confondre = (affectation) et == (test d’égalité) 8
Type de base (suite)
9. Règles de conversion automatique
9
Deux entiers:
D'abord, les types char et short sont convertis en int. Ensuite, l'ordinateur choisit le
plus large des deux types dans l'échelle suivante:
int, unsigned int, long, unsigned long
Un entier et un rationnel:
Le type entier est converti dans le type du rationnel.
Deux rationnels:
L'ordinateur choisit le plus large des deux types selon l'échelle suivante:
float, double, long double
affectations et opérateurs d'affectation:
Lors d'une affectation, le résultat est toujours converti dans le type de la destination.
Si ce type est plus faible, il peut y avoir une perte de précision.
Les conversions non dégradantes telles que
char -> double, int -> long.
Les conversions dégradantes, par affectation telles que
int -> char, double -> float, double -> int.
10. Notion de référence
En C++, une référence est un moyen d'associer un nouveau nom à
un objet existant déjà.
Il ne s'agit donc pas d'un moyen permettant de créer un nouvel objet
int i = 5 ;
int &j = i ;
j est une référence sur i, cela veut dire que la variable i a deux noms i et j.
int a = 10;
int & x = a; permet de déclarer une référence x vers la variable a.
10
11. Fonctions
• Appel de fonctions est toujours précédé de la déclaration de la fonction sous
la forme de prototype (signature) ;
• Une et une seule définition d’une fonction donnée mais autant d’utilisation
que nécessaire ;
• Passage des paramètres par valeur (comme en C) ou par référence ;
• Possibilité de surcharger ou sur-définir une fonction ;
int racine_carree (int x) {return x * x;}
double racine_carree (double y) {return y * y;}
• Possibilité d’attribuer des valeurs par défaut aux arguments ;
void MaFonction(int i=3, int j=5); // Déclaration
int x =10, y=20;
MaFonction(x, y); // Appel avec 2 argument
MaFonction(x); // Appel avec 1 argument
MaFonction();
11
12. Prototypage Obligatoire
• Il faut mettre en début de programme la liste des prototypes de
fonctions appelées.
• Exemple :
#include <iostream.h>
int main ()
{
float AireRectangle(float, float);
float Longueur = 10.;
float Largeur=5.;
float Aire = AireRectangle(Longueur, Largeur);
return 0;
}
float AireRectangle(float L , float l )
{
…
} 12
13. // déclaration dans le fichier d’entête.
void function( int param1, int param2 = 10 );
header.h
// implémentation des fonctions
void function( int param1, int param2 ) {
// affiche ‘param1’ et ‘param2’ dans le console
}
impl.cpp
// fonction main
int main() {
function( 5, 3 );
function( 5 );
return 0;
}
client.cpp
13
Prototypage Obligatoire (suite)
14. Surdéfinition des fonctions
• Deux fonctions peuvent avoir le même nom, mais pas la même liste
d’arguments:
Exemple :
int Maximum ( int i, int j);
float Maximum ( float x , float y ) ;
• Une fonction se distingue par sa liste d’arguments.
• On dit que la fonction est surdéfinie (Surchargé).
• On peut surdéfinir une fonction autant de fois que l’on veut.
14
15. Surcharge de fonctions
int square( int value );
float square( float value );
double square( double value );
Surcharge d’opérateurs
typedef struct Complex {
float x_;
float y_;
};
Complex& operator+(
Complex& lhs,
const Complex& rhs
);
complex.h
Utilisation de Complex comme d’un type standard
header.h
15
Surdéfinition (suite)
16. Surcharge (suite)
• Les types des paramètres peuvent être utilisés pour la
surcharge, mais pas la valeur de retour.
Exemples non autorisés
double square( double value );
float square( double value );
Erreur de compilation
16
double somme(int, int);
int somme(int, int);
somme(2,6); // Ambigüité sur la fonction appelée
17. 2
b
1
a 2
b
Passage des arguments par valeur
Exemple :
#include <stdio.h>
void echange (int a, int b){
int c;
c=a; a=b; b=c;
}
int main(){
void echange (int , int );
int A, B;
A=1; B=2;
echange (A,B);
cout << “ A = “ << A << “ B = “ <<
B << endl; return 0;
}
A=1 B=2
1
A 2
B
2
b
2
a 1
b
17
- Aucun lien entre le paramètre formel a et le paramètre réel A.
- Paramètre formel a est initialisé avec la valeur du paramètre réel A=1.
18. Passage des arguments par adresse
Exemple :
#include <stdio.h>
void echange (int * ap, int * bp){
int c;
c=*ap; *ap=*bp; *bp=c;
}
int main(){
void echange (int *, int *);
int A, B;
A=1; B=2;
echange (&A, &B);
cout << “ A = “ << A << “ B = “ << B
<< endl; return 0;
}
B
A B
2
A
1
B
2
A
1
&A
B
2
A
1
B
2
A
1
&B
&A
B
2
A
1
B
2
A
1
&B
ap bp
&A
B
2
A
1
B
2
A
1
&B
ap bp
c
&A
B
2
A
1
B
1
A
2
&B
ap bp
c
1
&A
B
2
A
1
B
1
A
2
&B
A=2 B=1
18
- Il y a un lien entre le paramètre formel ap et le paramètre réel A.
- Paramètre formel ap est initialisé avec le contenu de l'adresse pointant sur A.
- Il y a un lien potentiel entre les paramètres formels de la fonction et les paramètres réels.
- La gestion des adresses est effectuée par le programmeur (lourde et difficile à lire).
19. Passage des arguments par référence
Exemple:
#include <iosteam>
using namespace std ;
void echange (int & a, int & b){
int c;
c=a; a=b; b=c;
}
int main(){
void echange (int & , int & );
int A, B;
A=1; B=2;
echange (A,B);
cout << “ A = “ << A << “ B = “ << B << endl;
return 0;}
c
1
A=2 B=1
1
A 2
B 2
b
2
A 1
B
19
-Le paramètre formel a est un alias de l’emplacement mémoire du paramètre réel A.
-En C++ le compilateur peut se charger lui même de la gestion des adresses.
20. Problème du passage des arguments
• Si un argument est passé par valeur :
La fonction travaille sur une copie, la variable passée est protégée;
• Si un argument est passé par référence :
La fonction travaille sur la variable sans recopie, la variable passée n’est pas
protégée;
Solution:
• Si l’on veut éviter une recopie de l’argument et protéger sa valeur : on utilise le
qualificatif const.
Exemple:
fonction ( const int & )
20
21. Valeurs des arguments d’une fonction par défaut
• On peut donner des valeurs par défaut aux arguments d’une fonction au niveau
de son prototype:
int main ()
{
void AireRectangle ( float = 1 , float = 1 ) ;
// Appel de la fonction avec les arguments par défaut.
AireRectangle ( ); // Résultat 1.*1.
// Appel de la fonction avec un argument par défaut.
AireRectangle (5.); // Résultat 5.*1. ==AireRectangle(5,1)
// Appel de la fonction avec ses arguments donnés.
AireRectangle (2.,3.); // Résultat 2.*3.
return 0;
}
21
22. • Règle 1: les arguments par défaut sont donnés de droite à gauche:
void fonction ( int , float =2., int=1) ; // OK correct
void Fonction ( int =1, float = 2. , int ) ; // Erreur Compilation
• Règle 2: la séquence de valeurs par défaut est continue sans interruption.
void fonction ( int = 1, float , int=2) ; // Erreur Compilation
22
Valeurs des arguments d’une fonction par défaut
(suite)
23. Opérateurs d’allocation et de Désallocation mémoire
• Les opérateurs new et new [] réserve de la mémoire.
Exemple:
int * ip = new int;
int * itab = new int[10];
• Les opérateurs delete et delete[] libèrent cette zone mémoire.
Exemple:
delete ip ;
delete [] itab ;
• Nécessairement new ==> delete et
new[] ==> delete[]
23
24. Allocation et désallocation mémoire en
C et C++
int* var = (int*)malloc(sizeof(int));
int* t= (int*)malloc(n*sizeof(int));
…
free( var );
free( t);
C
int* var = new int;
int* t= new int[10];
…
delete var;
delete [] t;
C++
24
25. Entrées / Sorties : cin/cout
25
Entrées/sorties fournies à travers la librairie iostream
cout << expr1 << … << exprn
• Instruction affichant expr1 puis expr2 , etc.
• cout : « flot de sortie » associé à la sortie standard (stdout).
• << : opérateur binaire associatif à gauche, de première opérande cout , de 2ème
l’expression à afficher, et de résultat le flot de sortie.
• << : opérateur surchargé (ou sur-défini), utilisé aussi bien pour les chaînes de
caractères, que les entiers, les réels etc.
cin >> var1 >> … >> varn
• Instruction affectant aux variables var1 , var2 , … les valeurs lues (au clavier)
• cin : « flot d’entrée » associée à l’entrée standard (stdin)
• >> : opérateur similaire à <<
26. 26
Possibilité de modifier la façon dont les éléments sont lus ou écrits dans le flot :
dec lecture/écriture d'un entier en décimal
oct lecture/écriture d'un entier en octal
hex lecture/écriture d'un entier en hexadécimal
endl insère un saut de ligne et vide les tampons
setw(int n) affichage de n caractères
setprecision(int n) affichage de la valeur avec n chiffres, avec éventuellement
un arrondi de la valeur
setfill(char) définit le caractère de remplissage
flush vide les tampons après écriture
#include <iostream.h>
#include <iomanip.h> // attention à bien inclure cette librairie
int main() {
int i=1234;
float p=12.3456;
cout << "|" << setw(8) << setfill('*')
<< hex << i << "|" << endl << "|"
<< setw(6) << setprecision(4)
<< p << "|" << endl; return 0;
}
|*****4d2|
|*12.35|
Entrées / Sorties :cin/cout (suite)
27. Espaces de noms (namespace)
• Utilisation d’espaces de noms (namespace) lors de l’utilisation de nombreuses
bibliothèques pour éviter les conflits de noms;
• Espace de noms : association d’un nom à un ensemble de variables, types ou
fonctions;
Exemple:
Si la fonction MaFonction() est définie dans l’espace de noms MonEspace,
l’appel de la fonction se fait par MonEspace::MaFonction()
• Pour être parfaitement correcte :
– std::cin
– std::cout :: opérateur de résolution de portée
– std::endl
• Pour éviter l’appel explicite à un espace de noms : using
using std::cout ; // pour une fonction spécifique
On écrit:
using namespace std; // pour toutes les fonctions 27
28. Exemple d’un programme C++
#include <iostream>
using namespace std;
int main() {
int n1;
cout << "Saisir un entier : " << endl; // Affiche à l’écran
cin >> n1; // Lit un entier
int n2, somme;
cout << "Saisir un autre entier : " << endl;
cin >> n2;
Somme = n1+ n2;
cout << "La somme de " << n1<< " et de " << n2 << " vaut : " <<
somme << endl; // endl = saut de ligne
return 0;
}
28
29. Organisation d’un programme C++
• Programme C++ est constitué en générale de plusieurs modules, compilés
séparément:
• Fichier entête : d’extension .h (ou .hh ou .hpp)
– Contenant les déclarations de types, fonctions, variables et
constantes, etc.
– Inclus via la commande #include
• Fichier source : d’extension .cpp ou .cc
29
MonFichierEnTete.h
#include <iostream>
extern char* MaChaine;
extern void MaFonction();
MonFichier.cpp
#include "MonFichierEnTete.h"
void MaFonction() {
cout << MaChaine << " n " ;
}
MonProgPrincipal.cpp
#include "MonFichierEnTete.h"
char *MaChaine="Chaîne à afficher";
int main() {
MaFonction();
return 0;
}
30. Préprocesseur
• La directive la plus courante #include: inclus un fichier dans un autre.
– On peut mettre n’importe quoi dans un fichier inclus, y compris du code
exécutable, mais par convention on n’y place que des déclarations.
– Un fichier qui est inclus s’appelle un « header » et est normalement un
fichier qui se termine en .h (ou parfois .hh, ou encore .hxx, .hpp pour le C++)
– #include <someheader.h> réservé aux headers du système.
– #include "someheader.h" pour nos propres headers, ceux qu’on va créer.
30
31. Directives préprocesseurs: #define
• Le C et le C++ sont dotés d’un préprocesseur qui est une sorte de méta-langage de
macros.
• Toutes les directives du préprocesseur commencent par le caractère #.
• Elle offre en fait deux possibilités :
– Définition de symboles (c’est sous cette forme que nous l’avons employée
jusqu’ici) ;
– Définition de macros.
• Exemple de définition de symboles :
• #define nbmax 5 //remplacer nbmax par 5
• #define entier int // entier a, b ;
• #define bonjour printf("bonjour")
• #define affiche printf("resultat %dn", a)
• #define ligne printf("n")
31
32. Définition de macros.
• On peut définir des macros en préprocesseur avec la directive #define, c’est à dire
des expressions qui ressemblent à des fonctions (normalement très courtes) qui
sont substituées directement dans le texte du programme. Une macro très
courante est :
#define MIN(a,b) ((a) < (b)) ? (a) : (b)
Utilisation:
int a = MIN(2, 5);
• Les macros préprocesseur sont une grande source de pièges difficiles. À les éviter
si possible. En C++, on peut presque toujours les remplacer par une fonction inline.
– Les macros peuvent entraîner des "effets de bord" indésirables, ou du moins
imprévus.
32
#define carre(x) x * x
int a = 4;
cout <<" carre de 4 "<<carre(a++)<<endl; //qui incrémentent 2 fois la
//variable a (a++*a++).
Directives préprocesseurs: #define (suite)
33. Fonctions inlines
// declaration
inline bool max( int x, int y );
// implementation
inline int max( int x, int y ) {
return (x > y) ? x : y;
}
header.h
33
• Une fonction en ligne indique au compilateur que: chaque appel à la fonction inline
devra être remplacé par le corps de cette fonction.
• Afin de générer un exécutable de taille raisonnable, il est donc en pratique utilisé
pour des fonctions "courtes" en terme de nombre d'instructions.
• Elle se définit et s'utilise comme une fonction ordinaire, la seule différence est que
l’on fait précéder son en-tête par la spécification inline.
Une fonction en ligne doit être définie dans le même fichier source que celui
où on l'utilise. Elle ne peut plus être compilée séparément !
34. Fonctions inlines: Exemple
#include <cmath> // ancien <math.h> pour sqrt
#include <iostream>
using namespace std ;
/* définition d’une fonction en ligne */
inline double norme (double vec[3]) {
int i ;
double s = 0 ;
for (i=0 ; i<3 ; i++)
s+= vec[i] * vec[i] ;
return sqrt(s) ;
}
34
/* exemple d’utilisation */
int main() {
double v1[3], v2[3] ;
int i ;
for (i=0 ; i<3 ; i++) {
v1[i] = i ; v2[i] = 2*i-1 ;
}
cout << "norme de v1 : " << norme(v1) << "n" ;
cout << "norme de v2 : " << norme(v2) << "n" ;
return 0;
}
Résultat
norme de v1 : 2.23607
norme de v2 : 3.31662
