Introduction à C++ pour programmeurs C

Transcription

SITEL - Université de Neuchâtel
Introduction à C++ pour
programmeurs C
Dr. E. Benoist
Novembre 2007
1
Table of Contents
Héritage
Surcharge de méthode
Surcharge d’opérateur
Métodes virtuelles
Destructeur
Classe abstraite
Exemple: Gestion des salles de l’Université
Librairie Standard
Templates
Strings
Conteneurs / Iterateurs
2
Héritage et Polymorphisme
I
Jour 1 : Notion d’encapsulation
• Objet = structure contenant des membres variables et
fonctions.
• Classe = groupe d’objets;
• La classe possède des variables partagées par tous les objets
• ainsi que des méthodes ne nécessitant pas d’instance.
I
Jour 2 (matin): Héritage
• Héritage: une classe B étand une classe A
• Réutilisation de code
I
Jour 2 (après midi): Librarie standard C++
• Strings
• Conteneurs (Vecteurs, listes, map, iterateurs)
3
Héritage
I
Une classe peut hériter d’une ou plusieurs autres classes
I
On dit dans ce cas qu’elle étend ces classes.
Principe
I
• la classe B hérite de la classe A
• Toute instance de B est automatiquement une instance de A
• Une instance de B a donc toutes les variables membres et les
fonctions membres de A.
• Dans les méthodes de B on ne peut par contre voir que ce qui
est protected et public de A.
I
Héritage signifie : “EST UN”
• Un objet de la classe B est aussi un objet de la classe A
• (la réciproque n’est pas vraie !!!)
Héritage
4
Une classe B hérite d’une classe
A
class B : public A {
...
};
Usage:
int main() {
B b;
A a = b;
A ∗ ptra = &b; // OK
B ∗ ptrb = &a; // Erreur
}
Héritage
5
Exemple avec Pointeurs
A∗
B∗
B∗
A∗
A∗
I
c1
c2
c3
c4
c5
=
=
=
=
=
new
new
new
c3;
new
A();
B();
B();
B();
Type vs Classe
• Les variables c4 et c5 sont de type ClassA, mais pointent sur
des instances de la classe B
Héritage
6
Héritage
I
La classe mère (ClassA)
class ClassA
{
public:
ClassA(int v1, int v2);
int getVal1() const;
private:
int val1 ;
int val2;
};
Héritage
7
Héritage des membres (Cont.)
I
Définition de la classe fille (ClassB)
class ClassB : public ClassA
{
public:
ClassB(int v1, int v2, int v3);
void setVal3(int v2);
private:
int val3 ;
};
Héritage
8
Héritage des membres (Cont.)
I
Dans la classe B on peut utiliser les membres protected
et public de la classe A
ClassA∗ a1 = new ClassA(1,9);
ClassB∗ b1 = new ClassB(1,0,10);
ClassA∗ b2 = new ClassB(2,9,3);
cout << b1−>getVal1()<<",";
cout << b1−>getVal2()<<",";
cout << b1−>getVal3()<<endl;
cout << b2−>getVal3()<<endl; // ERREUR: membre inconnu
Héritage
9
Visibilité de la classe mère
I
I
Les membres de la classe mère peuvent avoir une
visibilité différente de celle qu’ils avaient dans cette
classe
La visibilité est définie dans l’héritage
• public l’héritage est visible depuis l’extérieur, les instances de
la classe fille sont partout des instances de la classe mère. Les
membres ont la même visibilité que dans la classe mère
• protected l’héritage n’est visible que dans la classe et dans les
classes qui en héritent. Les membres protected et public de
la classe mère deviennent protected dans la classe fille.
• private cet héritage n’est visible que dans cette unique classe
et tous les membres sont private.
Héritage
10
Visibilité de la classe mère
(Cont.)
class A { ... };
class B : public A { ... };
class C : protected A { ... };
class D : private A { ... };
int main() {
B b; C c; D d;
A ∗ ptr;
ptr = &B; // OK
ptr = &C; // Erreur (ca ne marchera que dans C et toutes ses derivees
ptr = &D; // Erreur (ca ne marchera que dans D}
}
Héritage
11
Construction
I
I
Chaque instance de la classe fille est aussi une instance
de la classe mère
Le constructeur de la classe mère est appelé par le
constructeur de la classe fille
// Constructeur de la classe B
// Les deux premiers parametres sont directement passes a
// la classe mere
ClassB::ClassB(int v1, int v2, int v3):ClassA(v1,v2){
val3 = v3;
}
// Le constructeur en recopie fait aussi appel
// au constructeur en recopie de la classe mere
ClassB::ClassB(const ClassB& b):ClassA(b){ ...}
I
Constructeur en recopie est appelé à chaque = ou
passage de paramètre par copie.
Héritage
12
I
Les méthodes définies dans la classe mère peuvent être
redéfinies dans la classe fille
I
La méthode appelée est celle correspondant au type du
pointeur ou de la variable.
I
Permet de modifier le comportement de la classe fille
Héritage
13
Surcharge de méthode (Cont.)
class A {
...
public:
void f(int);
};
...
public:
void f(int);
};
int main() {
B b;
b.f(0); // Appel de B::f
A ∗ ptra = &b;
ptra−>f(0); // Appel de A::f au lieu de B::f
};
Héritage: Surcharge de méthode
14
Surcharge de méthode (Cont.)
class ClassA {
...
public:
int computeTotal();
};
class ClassB : public ClassA {
...
public:
int computeTotal();
};
int main() {
ClassA∗ c1 = new ClassA(1,0);
ClassB∗ c2 = new ClassB(2,0,3);
ClassA∗ c4 = c3;
coutIntroduction
<< c1−>getVal1()
<< endl;
à C++ pour programmeurs C
coutHéritage:
<< c1−>computeTotal()
<< endl;
15
Surcharge d’opérateur
I
I
C++ offre la possiblité de surcharger les opérateurs
Par exemple:
• Opérateurs arithmétiques : operator+,
operator-,operator*,operator/,
• Opérateurs d’accés (read/write): operator[],
• Opérateur de flux de sortie: operator>>
Héritage: Surcharge d’opérateur
16
I
Exemple classe des complexes
• Opérateurs internes à la classe,
class Complex{
public:
Complex operator+(Complex& c2);
Complex operator∗(Complex& c2);
Complex operator−(Complex& c2);
Complex operator+(double d);
...
}
• Définitions des opérateurs peuvent utiliser this
Complex Complex::operator+(Complex& c2){
return Complex(this−>getReal()+c2.getReal(),
this−>getImaginary()+c2.getImaginary());
}
Complex Complex::operator+(double d){
return Complex(this−>getReal()+d,this−>getImaginary());
}
...
17
I
Exemple classe des complexes
• Opérateurs externes à la classe (pas de this possible)
ostream& operator<<(ostream& s, const Complex& z);
Complex operator+(double d, const Complex& c);
• Définition des opérateurs
Complex operator+(double d, const Complex& c){
return Complex(c.getReal()+d,c.getImaginary());
}
ostream& operator<<(ostream& s, const Complex& z){
return s <<"(" <<z.getReal() <<","<<z.getImaginary()<<")";
}
18
Méthodes virtuelles
I
On a vu: en cas de surcharge d’une méthode ou d’un
opérateur:
• La méthode utilisée dépend du type du pointeur et pas de la
classe de l’instance.
I
I
Souhait: Que l’on puisse redéfinir une méthode dans une
sous-classe et que cette méthode soit executée
Technique: méthode virtuelle
• Une méthode virtuelle est définie dans une classe
• Cette méthode est surchargée dans une classe fille
• Si une instance de la classe fille est affectée à un pointeur de la
classe mère, c’est la méthode de la classe fille qui est appelée.
Héritage: Métodes virtuelles
19
I
Exemple 1
lass A {
...
public:
virtual void f(int);
};
...
public:
void f(int);
};
int main() {
B b;
b.f(0); // Appel de B::f
A ∗ ptra = &b;
ptra−>f(0); // Appel de B::f
};
20
I
Exemple 2
class ClassA
{ ...
virtual int anotherResult();
...}
{ ...
int anotherResult();
...};
int main(int argc,char ∗argv[])
{
ClassA∗ c4 = c3;
// Resultat different (methode non virtuelle)
cout << "Class B=" <<c3−>computeTotal();
cout << " ClassA="<< c4−>computeTotal() << endl;
// Meme resultat (methode virtuelle)
cout << "Class B=" <<c3−>anotherResult();
cout << " ClassA="<< c4−>anotherResult() << endl;
}
21
Destructeur
I
Le destructeur de la classe mère est appelé
automatiquement après le destructeur de la classe fille.
I
Les appels aux destructeurs se font dans l’ordre inverse
des appels aux constructeurs.
Si une classe contient une méthode virtuelle, son
destructeur doit aussi être virtuel
I
• Si un pointeur de la classe mère référence un objet de la classe
fille,
• Il faut que ce soit le destructeur de la classe fille qui soit
appelé et pas le destructeur de la classe mère.
• Il y a plus de mémoire allouée pour une instance de la classe
fille, si celle-ci n’est pas désaluée : risque de mémory leak.
Héritage: Destructeur
22
Méthode virtuelle pure / classe
abstraite
I
Une méthode peut être déclarée dans une classe mais
non définie
• On l’appelle alors virtuelle pure
I
Une classe ayant une méthode virtuelle pure est dite:
“Classe Abstraite”
• Une classe abstraite ne peut pas être instanciée
• Pour être instanciée, une classe fille doit implémenter la (ou
les) méthode(s) virtuelle(s) pure(s).
Héritage: Classe abstraite
23
Classe abstraite (Cont.)
I
Example
class ClassA
{ ...
virtual int methodX() = 0;
...}
{ ...
int methodX();
...};
{
ClassA∗ c4 = new ClassA(3,4); // illegal
}
24
Classe abstraite (Cont.)
I
Classe abstraite: Usage
•
•
•
•
I
Ne peut pas être instanciée
Partiellement fini
Décrit ce que doit faire la classe
Ne décrit pas comment le faire
Un contrat entre l’utilisateur et le réalisateur des
implémentations.
• L’utilisateur d’une telle classe peut programmer tout son code
en utilisant la classe abstraite comme type.
• L’utilisateur n’a pas à savoir avec quelle implémentation il
travaille.
• Les réalisateurs de la classe réelle doivent juste respecter le
contrat.
25
Exemple: Gestion des salles de
l’Université
I
I
Toutes les salles de l’Université ont un numéro (unique)
Deux sortes de salles à l’Université
• Les bureaux (Offices) qui ont un propriétaire
• Les salles de classe (Classroom) qui ont un nombre de places
assises et qui savent si elles contiennent un beamer.
I
Trois classes:
• Room une classe de base (qui pourrait être abstraite mais ne
l’est pas)
• Classroom hérite de Room
• Office hérite de Room aussi
Héritage: Exemple: Gestion des salles de l’Université
26
Room.h
class Room
{
public:
Room(int number);
int getNumber() const;
void setNumber(int number);
virtual std::string toString() const;
private:
int number;
};
27
Room.cpp
Room::Room(int n){
Room::numberInstances++;
this−>number = n;
Room::hm−>insert(std::make_pair(n,this));
}
int Room::getNumber() const{
return this−>number;
}
void Room::setNumber(int n){
this−>number = n;
}
std::string Room::toString() const
{
std::ostringstream str;
str <<"Number"<< this−>number;
return
str.str();
}
28
Office.h
class Office : public Room
{
public:
Office(int number, std::string owner);
std::string getOwner() const;
void setOwner(string& v2);
string toString() const;
private:
string owner ;
};
29
Office.cpp
Office::Office(int number, string owner):Room(number){
this−>owner = owner;
}
string Office::getOwner() const{
return this−>owner;
}
void Office::setOwner(string& owner){
this−>owner = owner;
}
string Office::toString() const
{
return Room::toString()+this−>owner;
}
30
Classroom.h
class Classroom : public Room
{
public:
Classroom(int number, int nbOfSeats, bool hasBeamer);
int getnbOfSeats() const;
void setNbOfSeats(int nbOfSeats);
bool hasBeamer() const;
void addBeamer();
void removeBeamer();
std::string toString() const;
private:
int nbOfSeats ;
bool beamer;
};
31
Classroom.cpp
Classroom::Classroom(int number, int nbOfSeats, bool hasBeamer): Room(numb
{
this−>nbOfSeats = nbOfSeats;
this−>beamer = hasBeamer;
}
int Classroom::getnbOfSeats() const
{ return this−>nbOfSeats; }
void Classroom::setNbOfSeats(int nbOfSeats)
{ this−>nbOfSeats = nbOfSeats; }
bool Classroom::hasBeamer() const
{ return this−>beamer; }
void Classroom::addBeamer()
{ this−>beamer = true; }
void Classroom::removeBeamer()
{ this−>beamer = false; }
std::string Classroom::toString() const
{
std::ostringstream str;
str <<"Classroom"<<
Room::toString() << ";"<< nbOfSeats;
32
testEntry.cpp
{
Room∗ c1 = new Room(1);
Room∗ c2 = new Classroom(101,50,true);
Room∗ c3 = new Classroom(102,45,false);
Room∗ c4 = new Classroom(103,30,false);
Room∗ c5 = new Office(104,"Hans Muster");
Room∗ c6 = new Office(105,"Toto");
Room∗ c7 = new Office(106,"E.Benoist");
cout << c4−>toString() << endl;
cout << c7−>toString() << endl;
}
33
Exercice numéro 3
Voir sur www.benoist.ch/coursCPP/exercises.php
34
Librairie Standard
I
Templates (i.e. patrons)
I
Strings
I
Conteneurs / Itérateurs
Librairie Standard
35
Templates
I
Les classes contenant quelquechose, sont dépendantes
de cette chose.
• Par exemple notre classe contenant des int (stack puis doubly
linked list en exercice)
I
Idée: mettre le type de la donnée de coté et écrire une
classe générique
I
Nous avons des classes dynamiques.
I
La définition de cette classe contient une partie variable
(le type).
I
La classe (avec la définition de toutes ses méthodes)
doit être incluse lors de la compilation. (et pas pendant
l’édition de liens)
Librairie Standard: Templates
36
Templates: Exemple classe
stack générique
I
I
Nous reprenons notre stack d’int dans laquelle nous
remplaçons la partie variable
Nous voulons pouvoir utiliser la classe comme ceci
{
LinkedList<int>∗ l2 = new LinkedList<int>();
l2−>push(0);
l2−>push(1);
l2−>push(2);
while(l2−>size() > 0){
cout << l2−>pop()<< ", ";
}
cout << endl;
}
37
Template (Cont.)
Node.h
template <class Type>
class Node
{
public:
Node(Type val, Node<Type>∗ next);
Type getVal();
void setVal(Type i);
Node<Type>∗ getNext();
void setNext(Node<Type>∗ next);
private:
Type val;
Node<Type>∗ next;
};
38
Template (Cont.)
Node.cpp
template <class Type> Node<Type>::Node(Type val, Node<Type>∗ next){
this−>val = val;
this−>next = next;
}
Type Node<Type>::getVal(){
return this−>val;
}
void Node<Type>::setVal(Type i){
this−>val=i;
}
Node<Type>∗ Node<Type>::getNext(){
return this−>next;
}
void Node<Type>::setNext(Node<Type>∗
next){
39
Template (Cont.)
LinkedList.h
#include "Node.h"
#include "Node.cpp"
class LinkedList
{
public:
LinkedList();
~LinkedList();
void push(Type val);
Type pop();
int size();
private:
Node<Type>∗ firstNode;
Type number;
};
40
LinkedList.cpp
#include "LinkedList.h"
template <class T> LinkedList<T>::LinkedList(){
firstNode = 0;
number=0;
}
template <class T>
LinkedList<T>::~LinkedList<T>(){
while(size()!=0){
pop();
}
}
void LinkedList<Type>::push(Type val){
number++;
firstNode = new Node<Type>(val,firstNode);
return;
}
Type LinkedList<Type>::pop(){
41
Strings
I
I
La bibliothèque standard offre un support pour les
chaînes de caractères.
les chaînes en C sont des char*
• Fin de chaine donnée avec caractère 0.
• Allocation dynamique assez délicate.
I
En C++ la chaîne est stockée sous forme d’objet string
I
Nous devons charger la bibliothèque <string> pour
pouvoir l’utiliser
Librairie Standard: Strings
42
Méthodes pratiques des strings
I
length() retourne la longueur de la string
I
operator+ concaténation de la string avec des strings ou des
chars.
I
operator>> opérateur de flux d’entrée
I
operator<< opérateur de flux de sortie
I
operator[] accés aux caractères à l’aide de leur index.
I
empty() teste si la string est vide
I
append(const string& str) concatène str à la string
this
43
String exemples
#include <string>
class Office : public Room
{
public:
Office(int number, std::string owner);
std::string getOwner() const;
void setOwner(std::string& v2);
std::string toString() const;
private:
std::string owner ;
};
44
Suite de l’exemple
std::string Office::toString() const
{
return Room::toString()+this−>owner;
}
45
Conteneurs/Iterateurs
I
I
Mode de stockage générique des éléments
Permet de disposer de Structures de données standard sans
programmer
•
•
•
•
vector structure objet représentant un array
list structure chainée de liste
map donnée regroupant une cle et une valeur
...
Librairie Standard: Conteneurs / Iterateurs
46
Vector
I
La classe vector correspond à un array d’éléments
• Accés efficace à l’aide d’un indice
• Insertion et effacage difficile au milieu
I
Offre de multiple fonctionnalités en plus
• Opérateur [] pour avoir une syntaxe proche des arrays
• methode push_back(elem) permet d’inserer dans le vecteur
(gestion automatique de la mémoire)
• méthode size() retourne le nombre d’éléments contenus dans
la structure.
47
Vector: Exemple
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
for(int i=0;i<v1.size();i++){
cout << v1[i] << endl;
}
48
Iterator
I
Objet de type pointeur sur un élément d’un conteneur
I
Utilisé pour visiter une structure conteneur
ContainerType C; // Any standard container type,
// like std::list<sometype>
//for (ContainerType::iterator it = C.begin(); it != C.end(); ++it){
// for mutable iterator (if you need to modify elements)
for (ContainerType::const_iterator it = C.begin();
it != C.end(); ++it) {
std::cout << ∗it << std::endl;
}
49
Iterator: Example
vector<int> v1;
v1.push_back(1);
...
for (vector<int>::const_iterator it = v1.begin(); it != v1.end(); ++it) {
cout << ∗it << std::endl;
}
vector<string> v2;
v2.push_back("AA");
...
for (vector<string>::const_iterator it = v2.begin();
it != v2.end(); ++it) {
cout << ∗it << std::endl;
}
50
Map
I
Structure de liste associative
• On associe une clé à une valeur
• Template utilise deux types: <cle,valeur>
I
Méthodes pour insérer, tester et retourner les éléments
stockés:
• insert(make_pair(key,value)) insère une paire dans la
map
• find(key) retourne la paire correspondant à la clé donnée
I
la paire retournée peut être à nouveau scindée en deux
• le membre first contient la clé
• le membre second contient la valeur.
51
Map: Exemple
I
Dans notre exemple de gestion des pièces, nous voulons
une méthode statique pour retrouver une Room
connaissant son numéro
static Room∗ getRoom(int n);
I
Nous définissons donc une variable de classe (static)
qui contiendra les éléments
• clé: int
• valeur: Room*
class Room
{ ...
private:
static std::map<int,Room∗>∗ hm;
}
52
Map: Exemple (Suite)
I
Nous définissons la méthode d’accés
Room∗ Room::getRoom(int n){
std::map<int,Room∗>∗ hm1 = Room::hm;
return hm1−>find(n)−>second;
}
53
Exercice numéro 4
Voir sur www.benoist.ch/coursCPP/exercises.php
54

Introduction à C++ pour programmeurs C

Transcription

Documents pareils

FICHE CLIENT

Examen - Master 1 - UPMC

2006-07.cours.chapitre5.entrees-et-sorties.java2015

FOIRES TAIWAN 2015 1.xlsx - Taiwan Trade Center, Algiers

class - DCanL

lambda-calcul et types - Cel

e-brochure

Conférence - L`autorisation d`exercer le recours collectif

Arts du Crique à Kizou Aventures

$1,200 per month grapevine.ca

Jahia Modules

Liste des distances aéropostales