mohammed benjelloun service d’informatique faculté polytechnique de mons
DESCRIPTION
Programmation en. Mohammed BENJELLOUN Service d’Informatique Faculté Polytechnique de Mons Mohammed . Benjelloun @fpms.ac.be 2005-2006. Appel par valeurs, pointeurs, référence s ??!!. #include … void fonct (int a) { a=1 ; } voidmain(void){ int var = 5; fonct ( var ) ; - PowerPoint PPT PresentationTRANSCRIPT
++- 1M. BENJELLOUN : 2005-06 Info II
Mohammed BENJELLOUN
Service d’Informatique
Faculté Polytechnique de Mons
2005-2006
Programmation en
++- 2M. BENJELLOUN : 2005-06 Info II
#include …
void fonct (int a){ a=1 ;}
void main(void){ int var = 5; fonct (var); cout << var ;}
5
#include …
int fonct (int a){ a=1 ; return a;}
void main(void){ int var = 5; var = fonct (var); cout << var;}
1
#include …
void fonct (int &a){ a=1 ;}
void main(void){ int var = 5; fonct (var); cout << var ;}
1
#include …
void fonct (int *a){ *a=1 ;}
void main(void){ int var = 5; fonct (&var); cout << var ;}
1
Appel par valeurs, pointeurs, références ??!!
++- 3M. BENJELLOUN : 2005-06 Info II
Déclaration d'une structure comportant Déclaration d'une structure comportant des fonctions membres des fonctions membres
struct point{ int x ; int y ;} ;
• initialise pour attribuer des valeurs aux "coordonnées" d'un point ;• deplace pour modifier les coordonnées d'un point ;• affiche pour afficher un point .Voici comment nous pourrions déclarer notre structure point :
Supposons que nous souhaitions associer à la structure trois fonctions :
struct point{int x ; // déclaration "classique" des données int y ; // déclaration des fonctions membre (méthodes) void initialise (int, int) ;void deplace (int, int) ;void affiche () ;} ;
++- 4M. BENJELLOUN : 2005-06 Info II
// Définition des fonctions membres du type point
#include <iostream>using namespace std ;
void point::initialise (int abs, int ord){x = abs ; y = ord ;}
void point::deplace (int dx, int dy){x += dx ; y += dy ;}
void point::affiche (){cout << "Je suis en " << x << " " << y << "\n" ;}
Définition des fonctions membres
point::initialise
opérateur de "résolution de portée"
Il signifie que l'identificateur initialise concerné est celui défini dans point. En l'absence de ce "préfixe" (point::), nous définirions effectivement une fonction nommée initialise(), mais celle-ci ne serait plus associée à point ; il s'agirait d'une fonction "ordinaire" nommée initialise, et non plus de la fonction membre initialise de la structure point.
struct point { int x , y;
void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;
++- 5M. BENJELLOUN : 2005-06 Info II
void main(){ point a, b ;
// on peut accéder aux "membre " avec . a.initialise (5, 2) ; a.affiche () ; a.deplace (-2, 4) ; a.affiche () ; b.initialise (1,-1) ; b.affiche () ;}
Je suis en 5 2 Je suis en 3 6 Je suis en 1 -1
void point::initialise (int abs, int ord){x = abs ; y = ord ;}
void point::affiche (){cout << "Je suis en " << x << " " << y << "\n" ;}
struct point{int x, y ; void initialise (int, int) ;void deplace (int, int) ;void affiche () ;} ;
++- 6M. BENJELLOUN : 2005-06 Info II
Objet et classe Le fondement de la programmation orientée objet (POO) est de pouvoir protéger
certaines données d’une structure, d’où la nécessité des classes.La notion de classe donne en fait la Définition d'un objet.
En C++ la structure est un cas particulier de la classe. Plus précisément, une classe sera une structure dans laquelle seulement certains membres et/ou fonctions membres seront "publics", c'est-à-dire accessibles "de l'extérieur", les autres membres étant dits "privés".
++- 7M. BENJELLOUN : 2005-06 Info II
struct Client{ // Données membres string Nom, Prenom; int Solde; // Déclaration fonctions membres
void Saisir ();void Afficher ();bool Etat_Client();
};
class Client{ private: // Données membres string Nom, Prenom; int Solde; public:
// Déclaration fonctions membresvoid Saisir ();void Afficher ();bool Etat_Client();
};
Cachées auxfonctions externes
Accessibles depuisl'extérieur de la classe
La déclaration d'une classe est voisine de celle d'une structure. Il suffit de:• remplacer le mot clé struct par le mot clé class,• préciser quels sont les membres publics (fonctions ou données) et les membres privés en utilisant les mots clés public et private.
Définition d'une classe
Encapsulation
(masquage des données)(masquage des données)
++- 8M. BENJELLOUN : 2005-06 Info II
Que signifient public, private et protected ?
Un membre déclaré publicpublic dans une classe peut être accédé par toutes les autres classes et fonctions. Un membre déclaré privateprivate dans une classe ne peut être accédé que par les autres membres de cette même classe.
Un membre déclaré protected protected dans une classe ne peut être accédé que par les autres membres de cette même classe ainsi que par les membres des classes dérivées.
++- 9M. BENJELLOUN : 2005-06 Info II
Un membre public d'une classe peut être accédé partout où il est visible ; un membre privé ne peut être accédé que depuis une fonction membre de la classe .
class point{ private : // déclaration des membres privés int x ; int y ; public : // déclaration des membres publics void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;
class point{ int x ; int y ; public : void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;
void point::initialise (int abs, int ord){x = abs ; y = ord ;}
++- 10M. BENJELLOUN : 2005-06 Info II
Un objetUn objet Un objetUn objet est donc une instanciation d’une classe. est donc une instanciation d’une classe.
Cet objet possède tous les attributs et toutes les Cet objet possède tous les attributs et toutes les fonctions membres de la classe, mais avec des fonctions membres de la classe, mais avec des valeurs d’attributs propres à l’objet. valeurs d’attributs propres à l’objet.
class Liste{public: int i; string nom; Liste *Suiv; void AffListe(void);};
// pointeur sur le premier élément de la liste Liste *debut=new Liste;
void main(){ point a, b ;…
++- 11M. BENJELLOUN : 2005-06 Info II
void main(){ point a, b ; // 2 objets de type point
// on peut accéder aux "membre public" avec . a.initialise (5, 2) ; a.affiche () ; a.deplace (-2, 4) ; a.affiche () ; b.initialise (1,-1) ; b.affiche () ;}
Je suis en 5 2 Je suis en 3 6 Je suis en 1 -1
++- 12M. BENJELLOUN : 2005-06 Info II
Les mots clés public et private peuvent apparaître à plusieurs reprises dans la définition d'une classe, comme dans cet exemple :class X{ private :...public :...private :...} ;
Si l'on rend publics tous les membres d'une classe, on obtient l'équivalent d'une structure. Ainsi, ces deux déclarations définissent le même type point :struct point class point{ int x ; { public : int y ; int x ; void initialise (...) ; int y ;..... void initialise (...) ;} ; .. .. } ;
++- 13M. BENJELLOUN : 2005-06 Info II
class point{ int x ; int y ; public : void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;
void point::initialise (int abs, int ord){x = abs ; y = ord ;}
class point{ int x ; int y ; public :
void initialise (int abs, int ord){ x = abs ; y = ord ; }
void deplace (int, int) ; void affiche () ;} ;
meilleure lisibilité du programme.
++- 14M. BENJELLOUN : 2005-06 Info II
#include <iostream>using namespace std;class CRec { public: int Long; int Larg; };void main(){ CRec Rc1, Rc2; int Surface = 0; Rc1.Long = 30; Rc1.Larg = 24; Rc2.Long = Rc1.Long/2; Rc2.Larg = Rc1.Larg*2; Surface = Rc1.Long * Rc1.Larg; cout << endl << "Surface rectangle 1 = " << Surface; cout << endl << " Surface rectangle 2 = " << Rc2.Long * Rc2.Larg;}
#include <iostream>using namespace std;class CRec { public: int Long; int Larg; int CalcSurf() { return (Long*Larg); }};void main(){ CRec Rc1, Rc2; int Surface = 0; Rc1.Long = 30; Rc1.Larg = 24; Rc2.Long = Rc1.Long/2; Rc2.Larg = Rc1.Larg*2; Surface = Rc1.CalcSurf(); cout << endl << "Surface rectangle 1 = " << Surface; cout << endl << " Surface rectangle 2 = " << Rc2.CalcSurf();}
++- 15M. BENJELLOUN : 2005-06 Info II
class Etudiant {string Nom;int AnEtud;int Note;
public : void saisieEtud(); void afficherEtud(); };
class Direction { string Titre; string Nom;
public : void FonctDir();};
void Direction : :FonctDir(){ Direction B; Etudiant A;
Titre = "Doyen"; // OK B.Titre ="Recteur"; // OK
Note = 50; // Not OK A.Note = 70; // Not OK};
friend Direction;
OK
++- 16M. BENJELLOUN : 2005-06 Info II
#include <iostream>#include <string>using namespace std ;
class Copain;
class Qui { string LeNom;
public: void sonnom(string n) { LeNom=n; } friend Copain; // Les fonctions membres de la classe Copain ont ainsi accès // aux attributs privés de la classe Qui.};
class Copain { string nom;
public: void sonnom(string n) { nom=n; } void moi() { cout << nom << " "; } void monami(Qui &q) { cout << q. LeNom << " "; // accès au membre private de Qui
// si pas de friend Copain; dans Qui // cannot access private member declared in class 'Qui'
}};
void main() { Qui QQui; Copain Cop;
QQui.sonnom("Laurel"); Cop.sonnom("Hardy");
Cop.moi(); cout << "est l'ami de "; Cop.monami(QQui); cout << endl;}
Hardy est l'ami de Laurel
friendfriendClasse amieClasse amie
++- 17M. BENJELLOUN : 2005-06 Info II
Un constructeur est une fonction membre d’initialisation (définie comme les autres fonctions membres) qui sera exécutée automatiquement à chaque création d'un objet. Le constructeur : porte le nom de sa classe, définit l'initialisation d'une instance, appelé implicitement à toute création d'instance, ne peut retourner aucune valeur, (fonction membre non typée même pas void ), peut admettre des arguments qui sont en fait les valeurs d’initialisation des différents champs de la variable.
Constructeur et destructeur
Il peut y avoir autant de constructeurs que l’on veut (tant qu’ils diffèrent par leur nombre et types d’arguments), ce qui est très intéressant pour initialiser les variables avec différents types; mais il n’y a qu’un seul destructeur par classe !
class point{ /* déclaration des membres privés */ int x, y ; public : // déclaration des membres publics point (int, int) ; // constructeur point (float, float) ; // constructeur point () ; // constructeur} ;
++- 18M. BENJELLOUN : 2005-06 Info II
De même, le destructeur est une fonction membre appelée automatiquement au moment de la destruction de l'objet, il :
porte le nom de sa classe précédé d'un tilde (~), n'a pas de type de retour (même pas void), définit la "désinitialisation" d'une instance, appelé implicitement à toute disparition d'instance, fonction membre non typée et sans paramètre.
mais il n’y a qu’un seul destructeur par classe !
class point{ /* déclaration des membres privés */ int x, y ; public : // déclaration des membres publics point () ; // constructeur ~ point (); //prototype du destructeur } ;
point ::point () {cout << "In constructeur \n" ;x=0; y = 0;}
point :: ~ point () {cout << "In destructeur \n" ;x=0; y = 0;}
++- 19M. BENJELLOUN : 2005-06 Info II
Constructeurs par défautConstructeurs par défaut
Point::Point()Point::Point(){{ X = 0;X = 0; Y = 0;Y = 0;}}
Par définition, le constructeur par défaut est : A::A(); // Avec aucun paramètre ! Rôle : il crée une instance non initialisée quand aucun autre constructeur fourni n’est applicable.
void Etudiant::Etudiant(){saisie();cout<< "Entrer NumCarte"<<" ";cin>>NumCarte;cout<<"Entrer AnEtud"<<" ";cin>>AnEtud;for (int i=0; i<3; i++){
cout << "\nNote["<<i<<"] =";cin >> Note[i];
}};
++- 20M. BENJELLOUN : 2005-06 Info II
Comment concevoir le type de classe CLAS de façon que ce programme :
void main() {CLAS x;cout << " Salut \n" ;}
Fournisse les résultats suivants :Creation Objet SalutDestruction Objet.
CLAS :: CLAS () {cout << "Creation Objet \n" ;}
CLAS :: ~ CLAS () {cout << "Destruction Objet \n" ;}
++- 21M. BENJELLOUN : 2005-06 Info II
Constructeurs par paramètresConstructeurs par paramètres
Tab:: Tab ( int taille ) // Constructeur{TabElement = new TElement [taille] ;}Tab ::~ Tab () // Destructeur{delete [] TabElement ;}
class CRec { public: int Long; int Larg; CRec( int Lo, int La){ Long = Lo; Larg = La; }};
++- 22M. BENJELLOUN : 2005-06 Info II
class point{ /* déclaration des membres privés */ int x, y ; public : // déclaration des membres publics point () ; // constructeur ~ point (); //prototype du destructeur } ;
La déclaration suivante convient-elle toujours ?
point a ;
à partir du moment où un constructeur est défini, il doit pouvoir être appelé (automatiquement) lors de la création de l'objet a. Ici (Ex2), le constructeur a besoin de deux arguments.Ceux-ci doivent obligatoirement être fournis dans notre déclaration, par exemple : point a(2,5) ;
Ex1
class point{ /* déclaration des membres privés */ int x, y ; public : // déclaration des membres publics point (int, int) ; // constructeur ~ point (); //prototype du destructeur } ;
Ex2
++- 23M. BENJELLOUN : 2005-06 Info II
class x { int i,j ;public: x(int , int ) ;} ;
x::x(int a,int b) {...}
void main(void) { x vx1(2,3) ; // ok x vx1= x(3,5) ; // ok x vx ; // déclenche une erreur de compilation.
...Le programme ci-dessus déclenche une erreur car à la déclaration de la variable vx, le compilateur recherche une fonction sans paramètres.
++- 24M. BENJELLOUN : 2005-06 Info II
#include <iostream>using namespace std;class CRec { public: int Long, Larg; CRec (int Lo, int La){ cout << “In Constructeur Param“<< endl ; Long = Lo; Larg = La; }
CRec (){ cout << “In Constructeur 0“<< endl ; }
int CalcSurf() { return (Long*Larg); }};
void main(){ CRec Rc1(10,20), Rc2, Rc3; int Surface = 0; Surface = Rc1.CalcSurf(); cout << endl << "Surface rectangle 1 = " << Surface;
cout << endl << " Surface rectangle 2 = " << Rc2.CalcSurf();
Rc3.Long = 30; Rc3.Larg = 24;
cout << endl << " Surface rectangle 3 = " << Rc3.CalcSurf();}
In Constructeur ParamIn Constructeur 0In Constructeur 0
Surface rectangle 1 = 200 Surface rectangle 2 = 687194768 Surface rectangle 3 = 720
Initialisation et affectation Initialisation et affectation
++- 25M. BENJELLOUN : 2005-06 Info II
#include <iostream>using namespace std;class CRec { int Long, Larg; public: CRec (int Lo, int La){ cout << “In Constructeur Param“<< endl ; Long = Lo; Larg = La; }
CRec (){ cout << “In Constructeur 0“<< endl ; }
int CalcSurf() { return (Long*Larg); }};
void main(){ CRec Rc1(10,20), Rc2, Rc3; int Surface = 0; Surface = Rc1.CalcSurf(); cout << endl << "Surface rectangle 1 = " << Surface;
cout << endl << " Surface rectangle 2 = " << Rc2.CalcSurf();
Rc3.Long = 30; Rc3.Larg = 24;
cout << endl << " Surface rectangle 2 = " << Rc3.CalcSurf();}
private:
Erreur
Initialisation et affectation Initialisation et affectation
error C2248: 'Long' : cannot access private member declared in class 'CRec'
++- 26M. BENJELLOUN : 2005-06 Info II
Constructeurs par défaut et par Constructeurs par défaut et par paramètresparamètres
Un constructeur par défaut et par paramètres : Un constructeur par défaut et par paramètres : Constructeur possédant des paramètres avec des valeurs de Constructeur possédant des paramètres avec des valeurs de défaut.défaut.
class CRec { int Long; int Larg; public: CRec( int Lo=0, int La=0){ Long = Lo; Larg = La; }};
CRec X; // OKCRec Y(1); // OKCRec Z(1,2); // OK
constructeur I (0, 1 ou 2 arguments)
++- 27M. BENJELLOUN : 2005-06 Info II
#include <iostream>using namespace std ; // création d'un patron de fonctionstemplate <class T> T min (T a, T b){ if (a < b) return a ; // ou return a < b ? a : b ; else return b ;}
void main(){ int n=4, p=12 ; float x=2.5, y=3.25 ; char a='A', b='B';
cout << "min (n, p) = " << min (n, p) << "\n" ; // int min(int, int) cout << "min (x, y) = " << min (x, y) << "\n" ; // float min (float, float) cout << "min (a, b) = " << min (a, b) << "\n" ; // char min (char, char)}
patron de patron de fonctionsfonctions
min (n, p) = 4min (x, y) = 2.5min (a, b) = A
++- 28M. BENJELLOUN : 2005-06 Info II
template<class T> void swap(T& x, T& y) { T tmp = x; x = y; y = tmp; }
void main() { int i,j; /*...*/ swap(i,j); // Instancie swap pour int float a,b; /*...*/ swap(a,b); // Instancie swap pour float char c,d; /*...*/ swap(c,d); // Instancie swap pour char string s,t; /*...*/ swap(s,t); // Instancie swap pour String }
++- 29M. BENJELLOUN : 2005-06 Info II
#include <iostream>#include <string>using namespace std ; // création d'un patron de classe
template <class T> class point { T x ; T y ; public : point (T abs=0, T ord=0) { x = abs ; y = ord ; } void affiche () ;} ;template <class T> void point<T>::affiche () { cout << "Paire : " << x << " " << y << "\n" ;}
void main (){ point <int> ai (3, 5) ; ai.affiche () ; point <char> ac ('d', 'y') ; ac.affiche () ; point <double> ad (3.5, 2.3) ; ad.affiche () ; point <string> as ("Salut", " A vous") ; as.affiche () ;}
patron de classepatron de classe
T prend la valeur int pour la classe point
Paire : 3 5Paire : d yPaire : 3.5 2.3Paire : Salut A vous
++- 30M. BENJELLOUN : 2005-06 Info II
La réutilisationLa réutilisation
L'héritage est un principe propre à la programmation orientée objet, L'héritage est un principe propre à la programmation orientée objet, permettant de créer une nouvelle classe à partir d'une classe existante. permettant de créer une nouvelle classe à partir d'une classe existante.
L’héritageL’héritage
Il est possible de représenter sous forme de hiérarchie de classes, parfois appelée arborescence de classes, la relation de parenté qui existe entre les différentes classes. L'arborescence commence par une classe générale appelée superclasse (parfois classe de base, classe parent, classe mère ou père). Puis les classes dérivées (classe fille ou sous-classe) deviennent de plus en plus spécialisées. Ainsi, on peut généralement exprimer la relation qui lie une classe fille à sa mère par la phrase "est un" .
Un omnivore est un animal mais pas forcement l’inverse
Permet l’extension d'une classe de base afin de lui ajouter des fonctionnalités particulières tout en conservant les fonctionnalités déjà définies dans la classe de base.
++- 31M. BENJELLOUN : 2005-06 Info II
Principe de l’héritagePrincipe de l’héritage• Les classes dérivées sont un mécanisme simple pour définir une nouvelle
classe en ajoutant des facilités à une classe existante sans reprogrammer ou recompiler la classe de base.
• On peut ainsi utiliser l’héritage pour les besoins de généralisation, de réutilisation.
• La classe dérivée hérite des attributs et des fonctions de la classe de base.
• La classe dérivée est plus spécifique que la classe en ajoutant des attributs et des fonctions membres.
class Personne {string nom, prenom;
public :void saisie();void afficher();
};
class Etudiant : public Personne{int NumCarte;int AnEtud;int Note[3];
public : friend Direction;Etudiant *suiv;void saisieEtud();void afficherEtud();
};
++- 32M. BENJELLOUN : 2005-06 Info II
En C++, il existe En C++, il existe l’héritage simplel’héritage simple, et , et l’héritage multiplel’héritage multiple. Dans ce . Dans ce cours, nous ne nous intéresserons qu’à l’héritage simple.cours, nous ne nous intéresserons qu’à l’héritage simple.
Dans la définition de la classe dérivée, afin d’utiliser l’héritage, on Dans la définition de la classe dérivée, afin d’utiliser l’héritage, on ajoute le symbole ajoute le symbole :: après le nom de la classe en précisant par la suite après le nom de la classe en précisant par la suite quelle est la classe de base.quelle est la classe de base.
Ex:Ex:class ClasseDeriveeclass ClasseDerivee :: public public ClasseBaseClasseBase {...}{...} class Vehicule { … };
class voiture : public Vehicule { public: // ... };
On mentionne cette relation de plusieurs manières:•voiture est une sorte de Vehicule •voiture est "dérivée de" Vehicule •voiture est un Vehicule spécialisé. •voiture est une "sous-classe" de Vehicule •Vehicule est une "classe de base" de voiture •Vehicule est la "superclasse" de voiture
class Personne { public: Personne(string nom){…} …};
class Travailleur : public Personne { public: …};
class Employeur : public Personne { ...};..
++- 33M. BENJELLOUN : 2005-06 Info II
Mode de dérivationMode de dérivation
Lors de la définition de la classe dérivée il est possible de spécifier le mode de dérivation par l'emploi d'un des mots-clé suivants : public, protected ou private.
Ce mode de dérivation détermine quels membres de la classe de base sont accessibles dans la classe dérivée.
Par défaut, le type d’héritage est privé (par défaut le mot-clé private.)
Les membres privés de la classe de base ne sont jamais accessibles par les membres des classes dérivées.
class ClasseDeriveeclass ClasseDerivee : : ModeMode ClasseBaseClasseBase {...}{...}
++- 34M. BENJELLOUN : 2005-06 Info II
class CptBanque {
int ident; float solde;
public:
CptBanque(int id, float so = 0);
void deposer(float);
void retirer(float);
float getSolde();
};
class CptPlus : public public CptBanque {
float prelev;
public:
void prelever();
CptPlus(int id, float pr, float so);
};
La classe CptPlus est un CptBanque avec de nouvelles fonctionnalités (un prélèvement automatique). Elle hérite des champs et méthodes de CptBanque et possède en plus un champ prelev et de la méthode prelever. Qualifier la classe CptPlus comme héritant public de CptBanque, signifie que tous les champs et méthodes public de la classe CompteBanque (classe de base) sont définis implicitement public dans la classe ComptePrelevementAuto (classe dérivée public).
héritage simple public héritage simple public
Héritage Héritage PublicPublic: Les types d’attributs: Les types d’attributsC'est la forme la plus courante d'héritage C'est la forme la plus courante d'héritage
++- 35M. BENJELLOUN : 2005-06 Info II
Héritage Public: Les types d’attributsHéritage Public: Les types d’attributsC'est la forme la plus courante d'héritage C'est la forme la plus courante d'héritage
Classe de base Classe dérivée
private private
protected protected
public public
Les attributs Les attributs privateprivate, , protectedprotected et et publicpublic de la classe de base restent les mêmes de la classe de base restent les mêmes pour la classe dérivée.pour la classe dérivée.
Le type d’attribut protected est Le type d’attribut protected est le plus utilisé lors de l’héritage.le plus utilisé lors de l’héritage.
class ClasseDerivee : class ClasseDerivee : publicpublic ClasseBaseClasseBase
class Vehicule { public: void pub1(); protected: void prot1(); private: void priv1();};class Voiture : public Vehicule { public: int pub2() { pub1(); // OK prot1(); // OK priv1(); // ERREUR }};Voiture X;X.pub1(); // OK X.pub2(); // OK
protégés (protected), c'est à dire accessibles aux membres de la classe et ses classes dérivées (par héritage);
++- 36M. BENJELLOUN : 2005-06 Info II
REDEFINITION DE METHODES DANS LA CLASSE DERIVEEREDEFINITION DE METHODES DANS LA CLASSE DERIVEE
Les méthodes (fonctions, …) de la classe de base peuvent être redéfinies Les méthodes (fonctions, …) de la classe de base peuvent être redéfinies dans la classe dérivée (dans la classe dérivée (le même nom que dans la classe de base)le même nom que dans la classe de base). Elles . Elles demeurent accessibles via l'opérateur de résolution de portée ("::").demeurent accessibles via l'opérateur de résolution de portée ("::").
#include <iostream>using namespace std;
class X { public: void f1(){ cout << "\n In F1 X"; } void f2(){ cout << "\n In F2 X"; } protected: int K;};
class Y : public X { public: void f2() { cout << "\n In F2 Y"; } void f3();};
void Y::f3() { f1(); // appel de f1 de la classe X f2(); // appel de f2 de la classe Y X::f2(); // f2 de la classe X X::K = 5; // accès au membre K de la classe X
cout << "\n In F3 K =" << k; K = 14; // accès au membre K de la classe X
cout << "\n In F3 K =" << K;}
void main() { X A; Y B; A.f2(); B.f3(); }
In F2 X In F1 X In F2 Y In F2 X In F3 K =5 In F3 K =14
++- 37M. BENJELLOUN : 2005-06 Info II
/* --- Déclaration et définition de la classe pointcol ----- */class pointcol : public point // pointcol dérive de point{ int couleur ; public : void colore (int cl) { couleur = cl; cout << "\n couleur = " << couleur << "\n" ; }} ;
void main(){ pointcol p ; p.initialise (10,20) ; p.colore (5) ; p.affiche () ; p.deplace (2,4) ; p.affiche () ;}
#include <iostream>using namespace std ;
// ------------ Déclaration de la classe point class point{ /* déclaration des membres privés */ private : int x ; int y ; /* déclaration des membres publics */ public : void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;
//Définition des fonctions membres de la classe point void point::initialise (int abs, int ord){ x = abs ; y = ord ;}void point::deplace (int dx, int dy){ x = x + dx ; y = y + dy ;}void point::affiche (){ cout << "Je suis en " << x << " " << y << "\n" ;}Les membres publics de la classe de base (point)
seront des membres publics de la classe dérivée (pointcol).
couleur = 5Je suis en 10 20Je suis en 12 24
++- 38M. BENJELLOUN : 2005-06 Info II
class pointcol : public point // pointcol dérive de point{ int couleur ; public : void colore (int cl) { couleur = cl; cout << "\n couleur = " << couleur << "\n" ; }} ;
void main(){ point A; pointcol B;
A.initialise (5,10); A.affiche () ;
B.initialise (20,30); B.affiche () ;
A=B;
A.affiche () ; B.affiche () ;}
#include <iostream>using namespace std ;
class point{ /* déclaration des membres privés */ private : int x ; int y ; /* déclaration des membres publics */ public : void initialise (int, int) ; void deplace (int, int) ; void affiche () ;} ;
void point::initialise (int abs, int ord){ x = abs ; y = ord ;}void point::deplace (int dx, int dy){ x = x + dx ; y = y + dy ;}void point::affiche (){ cout << "Je suis en " << x << " " << y << "\n" ;}
Je suis en 5 10Je suis en 20 30Je suis en 20 30Je suis en 20 30
Conversions automatiques : si B hérite de A, alors toutes les instances de B sont aussi des instances de A, et il est donc possible de faire : A a; B b; a=b;
++- 39M. BENJELLOUN : 2005-06 Info II
#include <iostream>#include "point.hpoint.h" /* déclaration de la classe point (nécessaire */ /* pour compiler la définition de pointcol) */using namespace std ;
class pointcol : public point { int couleur ; public : void colore (int cl) { couleur = cl ; } void affichec () ; void initialisec (int, int, int) ;} ;
void pointcol::affichec (){ affiche () ; cout << " et ma couleur est : " << couleur << "\n" ;}
void pointcol::initialisec (int abs, int ord, int cl){ initialise (abs, ord) ; couleur = cl ;}
void main(){ pointcol p ; p.initialisec (10,20, 5) ; p.affichec () ; p.affiche () ; p.deplace (2,4) ; p.affichec () ; p.colore (2) ; p.affichec () ;}
Utilisation de pointcol
Je suis en 10 20 et ma couleur est : 5Je suis en 10 20Je suis en 12 24 et ma couleur est : 5Je suis en 12 24 et ma couleur est : 2
++- 40M. BENJELLOUN : 2005-06 Info II
class Personne {string nom, prenom;
public :void saisie();void afficher();string Lenom();string Leprenom();
};
class Etudiant : public Personne{int NumCarte;int AnEtud;int Note[3];
public : friend Direction;Etudiant *suiv;void saisie();void afficher();
// void saisieEtud();// void afficherEtud();};
class Prof : public Personne{string Service;float Salaire;
public :void saisie();void afficher();Prof *suiv;
};
class Direction : public Prof{string Titre;
public : void saisieDir(); void afficherDir();
void moyenne(Etudiant *Tete);};
++- 41M. BENJELLOUN : 2005-06 Info II
void main (void){Etudiant *debET= NULL;Prof *debProf= NULL;Direction D;
int choix =1;string chrch;
do{ choix= menu(); switch (choix){
case 1: cout<<"Saisie Etudiants :"<<endl; debET = insereTete(debET); affichage(debET); break;
case 2: cout<<"Saisie Profs :"<<endl; debProf = insereTete(debProf); affichage(debProf); break;
case 3: cout<<"Doyen Calcul Moyenne :"<<endl; D.moyenne(debET); break;
case 4 : cout << "\n Prof a chercher nom ? : "; cin >> chrch; if (Tposition(chrch, debProf) == -1) cout << "Le "<< chrch <<" n'est pas dans la liste \n\n"; break;
…
++- 42M. BENJELLOUN : 2005-06 Info II
Qu'est ce que la "STL"?
La STL ("Standard Templates Library") est une librairie qui est constituée principalement par des classes containers (Conteneurs :collections d'objets ; très efficace), ainsi que des fonctionnalités pour parcourir (iterator) leur contenu et des algorithmes pour travailler sur leur contenu.
STL : C++ AlgorithmsC++ VectorsC++ Double-Ended QueuesC++ ListsC++ Priority QueuesC++ QueuesC++ Stacks C++ SetsC++ MultisetsC++ MapsC++ Multimaps C++ Bitsets Iterators
STLSTL
++- 43M. BENJELLOUN : 2005-06 Info II
C++ Lists :Container constructors create lists and initialize them with some data
Container operators assign and compare lists
assign assign elements to a list
begin returns an iterator to the beginning of the list
clear removes all elements from the list
empty true if the list has no elements
endreturns an iterator just past the last element of a list
erase removes elements from a list
insert inserts elements into the list
pop_back removes the last element of a list
pop_front removes the first element of the list
push_back add an element to the end of the list
push_front add an element to the front of the list
remove removes elements from a list
remove_if removes elements conditionally
sort sorts a list into ascending order
splice merge two lists in constant time
swap swap the contents of this list with another
++- 44M. BENJELLOUN : 2005-06 Info II
#include <list>#include <iostream>using namespace std;void main() { //creer une liste (fifo) list<int> listInt; //rajouter des valeurs a la fin de la liste listInt.push_back(33); listInt.push_back(10); //afficher et enlever des valeurs au debut de la liste cout <<listInt.front() <<endl; listInt.pop_front(); //rajouter des valeurs a la fin de la liste listInt.push_back(44); //afficher et enlever des valeurs au debut de la liste cout <<listInt.front() <<endl; listInt.pop_front(); cout <<listInt.front() <<endl; listInt.pop_front();}
Utilisation du conteneur séquentiel listUtilisation du conteneur séquentiel list
331044
++- 45M. BENJELLOUN : 2005-06 Info II
#include <vector>#include <iostream>using namespace std;
void main() { int MAX=10; //créer un vecteur qui stocke MAX entiers vector<int> vecInt(MAX); //remplir vecteur for (int i=0; i<MAX; i++) { vecInt[i] = i+1; } //afficher vecteur for (int i=MAX-1; i>=0; i--) { cout <<vecInt[i] <<endl; }}
10987654321
Utilisation du conteneur séquentiel vectorUtilisation du conteneur séquentiel vector
++- 46M. BENJELLOUN : 2005-06 Info II
void main() { MyMap ListeMap; // Liste MyMap :: iterator my_it; // iterateur
char buffer[5];
ListeMap["Mary"] = 1234567; // Mary est un string ListeMap["Mary"] = 5551212; // Le numéro de Mary a changé
// Inserser en utilisant la fonction <tt>insert</tt>: TRi croissant ListeMap.insert( MyMap :: value_type( "Xavier", 777 ) ); ListeMap.insert( MyMap :: value_type( "Chuck", 1234567 ) ); ListeMap.insert( MyMap :: value_type( "James Bond", 007 ) ); ListeMap.insert( MyMap :: value_type( "Rob", 666 ) );
ListeMap.insert( MyMap :: value_type( "Xavier", 777 ) ); ListeMap.insert( MyMap :: value_type( "Chuck", 1234567 ) );
// Parcourir et afficher la liste for( my_it = ListeMap.begin(); my_it != ListeMap.end(); my_it++ ) cout << (*my_it).first << " " << (*my_it).second << endl;
// Effacer la liste de la mémoire ListeMap.erase(ListeMap.begin(), ListeMap.end());
cout << "\n FIN \n";}
#pragma warning(disable: 4786)
#include <iostream>#include <string>
#include <map> // Pour STL type map
using namespace std;typedef map < string, int > MyMap;
Chuck 1234567James Bond 7Mary 5551212Rob 666Xavier 777
FIN
++- 47M. BENJELLOUN : 2005-06 Info II
#include <string>#include <iostream>
#include <map>using namespace std;void main(){
map<string, int, less<string > > age; // age est une map de string à int
age["Fred"] = 42; // Fred a 42 ans deage["Barney"] = 37; // Barney a 37 ans
++age["Fred"]; // incrémente l'âge de Fred.cout << "Fred a " << age["Fred"] << " an(s)\n";
--age["Barney"];cout << "Barney a " << age["Barney"] << " an(s)\n";
}