Vous êtes sur la page 1sur 36

Classes et objets

Une classe regroupe des objets qui ont des propriétés et des comportements
communs.
point, rectangle, personne
Un objet est une entité, qui possède un état et un comportement:
objet = état + comportement

Attribut ou membre
L’état d’un objet est l ‘ensemble des valeurs de ses attributs. Un attribut est
une propriété de l’objet.

Encapsulation des données


Tout attribut d’une classe est définie dans l’implémentation de la classe et il
est accédé par une méthode de la classe.
Classes et objets
Un programme orienté objet en C++ comprend 3 fichiers
Un fichier .h : La déclaration de la classe
Un fichier .cpp : La définition de la classe
Le fichier main : traitement des objets

Le fichier .h est l’interface de la classe.


Le fichier .cpp est le corps de la classe.

// fichier classe.h
#ifndef CLASSE_H
#define CLASSE_H
#include ... // includes de classes eventuelles
...
class Classe {
...
};
#endif
un fichier classe.cpp possède la structure suivante :
// fichier classe.cpp
#include « classe.h »
#include ...
...
Classe : :methode(...) { // definition de la méthode
...
}

.. // autres definitions de fonctions membres


Classes et objets
Déclaration de classe
class Point {
int x ; // un membre
int y ;
public :
void affiche() ;
};
x et y sont des membres de la classe Point.
affiche est une fonction membre de la classe Point.

Définition des fonctions membres de la classe

void Point::affiche() {
cout << ‘’ x =‘’ << x << endl;
cout << ‘’ y = ‘’ << y << endl;
}
Classes et objets
Exemple d’utilisation de la classe Point par un
programme
main() {
Point a ;
a.affiche() ;
}
Classes et objets
Constructeur et destructeur d'objets
Un constructeur d’objet est une fonction membre
particulière d’une classe qui est appelée lors de la
création d’un objet.
Classe()
Un destructeur d’objet :
remet l’objet dans un état terminal et
libère l’emplacement mémoire associé à l’objet.
~Classe()
Classes et objets
class Point {
...
public :
Point();
Point(int, int) ; // le constructeur de la classe
~Point() ; // le destructeur de la classe
...
};
Point::Point(){}
Point : : Point(int a, int b) {
x=a;
y=b;
}
Point : : ~Point() {}
main() {
Point a(5, 2) ;
...
Point b(-1, 1) ;
...
}
Lecture/Ecriture
<iostream> est la bibliothèque du C++
permettant de faire des entrées sorties.
Ecrire sur la sortie standard
#include <iostream>
using namespace std;
main (){
cout << “ bonjour le monde ! ” << endl ;
}
Afficher la valeur d’une variable.
#include <iostream>
using namespace std;
main () {
int n = 25 ;
cout << “ la valeur de n est ” << n << endl ;
}
Lire sur l’entrée standard
#include <iostream>
using namespace std;
main () {
int n;
cout << “ entrer une valeur : ” ;
cin >> n ;
cout << “ la valeur entrée est ” << n << endl ;
}
Plusieurs valeurs
#include <iostream>
using namespace std;
main () {
int n; float x ; char t[64] ;
cout << “ entrer un entier, un flottant et une chaîne de caractères:
”;
cin >> n >> x >> t ;
cout << “ l’entier vaut ” << n ;
cout << “ le flottant vaut ” << x ;
cout << “ la chaîne vaut ” << t << endl ;
}
Types de base
Déclaration et initialisation de variables :
Type nom(valeur);
bool a(true); // variable booléenne
cout << boolalpha <<a; // pour que cela affiche
// true ou false
int i(0); // entier
long j(123456789); // entier long
float f(3.1); // réel
// réel à double précision
double pi(3.141592653589793238462643);
char c(‘a’); // caractère
Constante symbolique : const int taille = 1000;
// Impossible de modifier taille dans la suite du programme const définit une expression
constante = calculée à la compilation
Tableau
Tableau statique
int tab1[5] ; // Déclaration d’un tableau de 5 entiers
// Déclaration et initialisation d’un tableau de 3 entiers
int tab2 [] = {1,2,3} ; // Les indices commencent à zéro
int tab3[3][5];
char chaine[]= "Ceci est une chaîne de caractères";
// Attention, le dernier caractère d’une chaîne est ‘\0’
char ch[]= "abc" ;
char ch[]= {‘a’,‘b’,‘c’, ‘\0’};
Tableau dynamique
include <vector>
vector<int> tab(5); // tableau de 5 entiers
vector<int> tab(5,3) // tableau de 5 entiers valant 3
vector <int> tab // illimité
tab.push_back(2); //tab[0]=2

tab.size();//taille du tableau
chaînes de caractères
Sur la classe string : méthodes appliquées aux objets de la classe string
#include <iostream>
#include <string>
using namespace std;
int main ()
{
string str ("chaîne test");
cout << " str contient " << str.length() << " caractères s.\n";
return 0;
}
cin>>str; // lit un mot
getline(cin,str); // lit tous les mots
cin.ignore() //vide le tampon
size(), find(car),
erase(pos,nb) ;//supprime lecontenu
substr(int debut int nbcar); //extraire une sous chaine
Mathématiques
include <cmath>
sqrt(), sin(), cos(), tan(), exp(), log(), log10(),
fabs(), floor(), ceil(), pow(x,y)

include<ctime>
include<cstdlib>
rand() //aléatoire
Pointeurs

2 opérateurs : new et delete


float *pf = new float;

int *pi = new int[20];

delete pf;
delete [] pi;
Type référence (&)

int i = 5;
int & j = i; // j reçoit i
// i et j désignent le même emplacement mémoire

int i = 5;
int & j = i; // j reçoit i
j += 2; // i reçoit i+2 (=7)
Fonctions
Passage des paramètres par valeur
#include <iostream>
void echange(int,int); // Déclaration (prototype) de la fonction
int main()
{

echange(n,p); // Appel de la fonction
}
void echange(int a, int b) // Définition de la fonction
{

}
les valeurs de n et p restent inchangées
Fonctions
Passage des paramètres par adresse
#include <iostream>
void echange(int*,int*); // Modification de la signature
int main()
{

echange(&n,&p);
}
void echange(int* a, int* b)
{

}

les valeurs de n et p ont été modifiées


Fonctions
Passage des paramètres par référence
#include <iostream>
void echange(int&,int&);
int main()
{

echange(n,p); // attention, ici pas de &n et &p

}
void echange(int& a, int& b)
{

c=a; a=b; b=c;
}
a et n correspondent au même emplacement mémoire, de même pour b et p
les valeurs de n et p sont modifiées
Classes et objets
Constructeur par recopie (copy constructor) :
Constructeur créé par défaut mais pouvant être redéfini
Appelé lors de l’initialisation d’un objet par recopie d’un autre objet, lors du passage par valeur d’un objet en
argument de fonction ou en retour d’un objet comme retour de fonction
MaClasse c1;
MaClasse c2=c1; // Appel du constructeur par recopie

Possibilité de définir explicitement un constructeur par copie si nécessaire :


•Un seul argument de type de la classe
•Transmission de l’argument par référence

MaClasse(MaClasse &);
MaClasse(const MaClasse &) ;
Classes et objets
class Exemple
{
int x;
public :
Exemple(int); // Déclaration du constructeur
~Exemple(); // Déclaration du destructeur
};

int main()
{ Exemple e(1); // Déclaration d'un objet Exemple
Exemple e2=e; // Initialisation d’un objet par recopie
return 0;
}
Classes et objets
class Exemple
{
int x;
public :
Exemple(int);
// Déclaration du constructeur par recopie
Exemple(const Exemple &);
~Exemple();
};

// Définition du constructeur par recopie


Exemple::Exemple (const Exemple & e)
{ cout << "** Appel du constructeur par recopie ";
x = e.x;
// Recopie champ à champ
cout << " - valeur de l'attribut après recopie = " << x << endl;
};

Exemple e2(1);
Exemple e1(e2);
Classes et objets
Passage des paramètres objets
Transmission par valeur
bool Egal( Exemple e);

bool Exemple::Egal(Exemple e)
{ return (x == e.x) ;
}
int main()
{ Exemple e1, e2;

if (e1.Egal(e2)==true)
// e2 est recopié dans un emplacement
// local à Egal nommé e
// Appel du constructeur par recopie
}
Transmission par référence

bool Egal(const Exemple & e) //pas de recopie, référence à e


Classes et objets
Méthode retournant un objet
•Transmission par valeur
Exemple Suivant() ;

Exemple Exemple::Suivant()
{ Exemple e;
e.x=x+1;
return e; // Appel du constructeur par recopie
}
•Transmission par référence
Exemple & Suivant();

Exemple & Exemple::Suivant()


{
}

e1=e2.Suivant();
Classes et objets
Auto-référence : pointeur this
Pointeur sur l’objet (i.e. l’adresse de l’objet) ayant appelé
Uniquement utilisable au sein des méthodes de la classe

void AfficheAdresse() ;

Exemple::AfficheAdresse()
{ cout << "Adresse : " << this ;
}

e1.AfficheAdresse();
Classes et objets
Membres statiques
Un membre commun à tous les objets de la classe.

Class Exemple {
static int a ;
float b ;
public :
Exemple(float) ;
...
};
...
Exemple : :a = 0 ;// définition d’un membre statique nécessaire
...
Exemple e(1), f(2) ;
...
Classes et objets

Static applicable aux attributs et aux méthodes


Définition de propriété indépendante de tout objet de la classe propriété de la classe
Class Exemple
{
static int NbObjets; // Attribut statique
public:
// constructeur inline
Exemple() {Exemple:: NbObjets++;};
// Affichage du membre statique inline
void AfficherNbObjets ()
{ cout << "Le nombre d'objets instances de la
classe est : " << NbObjets << endl;
};
static int GetNbObjets() {return NbObjets;};
};
Classes et objets
// initialisation de membre statique
int Exemple::NbObjets=0;
int main ()
{
cout << "Nombre d'objets de la classe :"
<< Exemple ::GetNbObjets() << endl;

Exemple a; a.AfficherNbObjets();
Exemple b, c;
b.AfficherNbObjets(); c.AfficherNbObjets();
Exemple d;
d.AfficherNbObjets(); a.AfficherNbObjets();
};
Surcharge des méthodes
MaClasse(); Afficher();
MaClasse(int); Afficher(char* message);

Possibilité de définir des arguments par défaut


MaClasse(int = 0); Afficher(char* = "" );
Surcharge d’opérateurs
Possibilité en C++ de redéfinir n’importe quel opérateur unaire ou binaire : =, ==, +, -, *, \, [], (), <<, >>, ++, -- ,
+=, -=, *=, /= , & etc.
class Exemple
{…
bool operator== (const Exemple &);
};

bool Exemple::operator==(const Exemple& e)


{
return(x==e.x) ;
}

Exemple e1, e2;



if (e1==e2) …
Surcharge d’opérateurs
Méthode amie : friend
Fonction extérieure à la classe ayant accès aux données privées de la classes

friend type_retour NomFonction (arguments) ;


// A déclarer dans la classe amie

class Exemple
{…
friend bool operator== (const Exemple &, const Exemple &); // fonction amie
};

bool operator==(const Exemple& e1, const Exemple& e2)


{
return(e1.x==e2.x) ;
}

Exemple e1, e2;



if (e1==e2) …
Surcharge d’opérateurs
class Exemple
{ … // Pas de fonction friend ici pour l’opérateur ==
};
// Fonction extérieure à la classe
bool operator==(const Exemple& e1, const Exemple& e2)
{
return(e1.GetX()==e2.GetX()) ;
}

Main()
Exemple e1, e2;

if (e1==e2) …
Surcharge d’opérateurs
class Exemple
{…
const Exemple& operator= (const Exemple &);
};

const Exemple& Exemple::operator=(const Exemple& e)


{
if (this == &e) return * this ; // auto-assignation
x=e.x;
return *this;
}

Main()
Exemple e1(2),e2;

e2=e1; …
Objet membre
Possibilité de créer une classe avec un membre de type objet d’une classe
class point {
int abs, ord ;
public :
point(int,int);
};

class cercle
{
point centre; // membre instance de la classe point
int rayon;
public :
cercle (int, int, int);
};
Objet membre
#include "ObjetMembre.h"
point::point(int x=0, int y=0)
{
abs=x; ord=y;
cout << "Constr. point " << x << " " << y << endl;
}
cercle::cercle(int abs, int ord, int ray) : centre(abs,ord)
{
rayon=ray; cout << "Constr. cercle " << rayon << endl;
}
int main()
{
point p; cercle c (3,5,7);
}