08 Objetsetclasses 120926014317 Phpapp02 PDF

Programmation Orientée Objet en C++
8ème Partie: Objets et Classes
Fabio Hernandez
Fabio.Hernandez@in2p3.fr
Vue d'Ensemble
} Notions de base
} Types, variables, opérateurs
} Contrôle d'exécution
} Fonctions
} Mémoire dynamique
} Qualité du logiciel
} Evolution du modèle objet
} Objets et classes
} Fonctions membres
} Classes génériques
} Héritage
} Polymorphisme
} Héritage multiple
} Entrée/sortie
POO en C++: Objets et Classes 197 © 1997-2003 Fabio HERNANDEZ

Table des Matières
} Nature d'un Objet

} Nature d'une Classe
} Exemple: une classe simple
abstraction
définition de l'interface
utilisation
implémentation
modification
fonction membres
contrôle d'accès
initialisation/destruction
} Résumé

Nature d'un Objet
} Un objet représente une entité individuelle et identifiable,

réelle ou abstraite, avec un rôle bien défini dans le domaine du
problème
} Exemple: dans une usine de fabrication d'automobiles, on peut
identifier des objets tels
moteur
châssis
volant
système électrique
processus de montage
} Des objets peuvent être tangibles, mais peuvent ne pas avoir
une frontière physique très bien définie (rivière, des nuages, ...)

Nature d'un Objet (suite)
} Caractéristiques d'un objet

Etat
Comportement
Identité
} Etat
un attribut est une caractéristique, qualité ou trait intrinsèque qui
contribue à faire unique un objet
l'état d'un objet comprend les propriétés statiques (attributs) et les
valeurs de ces attributs
les valeurs des attributs peuvent être statiques ou dynamiques
du fait d'avoir un état, un objet occupe un espace dans le monde
physique et dans la mémoire de l'ordinateur
exemple: les attributs de l'objet point en deux dimensions sont les
coordonnées x et y

Nature d'un Objet (suite)
} Comportement
façon d'agir et de réagir d'un objet comme conséquence des
changements d'état et des opérations effectuées sur lui
représente l'activité de l'objet vue de l'extérieur
si on regarde un objet comme un serveur, son comportement est
l'ensemble des services offerts par lui à ses clients
exemple: un point peut être déplacé, tourné autour d'un autre point, etc.
le comportement dépend de l'état de l'objet et de l'opération
effectuée sur lui
l'état d'un objet représente le résultat cumulé de son comportement
} Identité
propriété d'un objet qui permet de le distinguer des autres objets de la
même classe

Nature d'une Classe
} Les notions de classe et d ’objet sont étroitement liées

} Une classe est un ensemble d'objets qui partagent une
structure et un comportement communs
} Une classe est seulement une abstraction
} Un objet est une instance (entité concrète) d'une classe en
temps d'exécution
} On peut voir la classe comme un moule pour la fabrication
d'objets
} Les objets fabriqués avec le même moule partagent structure
et comportement

Nature d'une Classe (suite)
} Deux vues d'une classe

interface
implémentation
} Interface
vue externe abstraite d'une classe
liste de services offerts par les instances de la classe (contrat)
une opération non spécifiée dans l'interface d'une classe ne peut être
appliquée sur une instance (objet) de cette classe
cache la structure interne de la classe (encapsulation)
réponse à la question quoi
contenue dans un fichier d'entête (.h)

Nature d'une Classe (suite)
} Implémentation
vue interne d'une classe
comprend les secrets (détails internes) de son comportement
l'implémentation d'une classe est constituée de l'implémentation de
chacune des opérations définies dans son interface
réponse à la question comment
contenue dans un fichier d'implémentation (.cpp)

Exemple: classe Point
} Ecriture en C++ d'une classe (interface et implémentation)

représentant la notion d'un point en deux dimensions
O x

Classe Point: abstraction
} Quels sont les attributs d'un point qui nous intéressent?

la coordonnée x
la coordonnée y
la distance à l'origine (ρ)
l'angle par rapport à l'horizontale (θ)
} Quelles sont les opérations applicables sur un point qui nous
intéressent ?
translation
rotation autour de l'origine
...

Classe Point : interface
} Définition (incomplète) de l'interface de la classe Point

} Fichier Point.h
class Point { // Not yet finished !!!

public:
float getX(); // returns the x coordinate
float getY(); // returns the y coordinate
float rho(); // returns the distance to the origin
float theta(); // returns the angle to the
// horizontal axis
void translate(float horizontal, float vertical);
void rotate(float angle);
};

Classe Point : interface (suite)
} getX, getY, rho, theta, translate et rotate sont des

méthodes (services) fournies par toutes les instances de la
classe Point
} getX, getY, rho et theta retournent une valeur de type
float
} translate et rotate ne retournent rien
} translate et rotate ont besoin d'information supplémentaire
pour accomplir leur mission
un déplacement horizontal et vertical, dans le cas de translate
un angle, dans le cas de rotate
} Y a-t-il des similarités avec la déclaration des fonctions,
étudiée précédemment?
} Le mot clé public sert à contrôler l'accès aux méthodes de la
classe. Plus d'informations à ce propos plus tard.
Classe Point : utilisation
} Comment utiliser les services offerts par les objets de la classe

Point?
il faut définir un objet de cette classe et ensuite...
lui envoyer un message indiquant le service que l'on demande
} La définition de l'objet est faite de la même façon que la
définition des objets des types primitifs
int count;
Point p;
} Pour envoyer le message indiquant le service demandé on utilise
la notation
service demandé
objet destinataire p.rotate(45.0);

du message
argument(s) du service
Classe Point : utilisation (suite)
} Utilisation d'objets de la classe Point (fichier main.cpp)

#include <iostream>
inclusion du fichier
#include "Point.h" qui contient
l'interface
void main()
de la classe
{
// Instantiate a Point object
Point p;
// Show its coordinates

cout << "p is ("
<< p.getX() << ',' << p.getY()
<< ')' << endl;

// Show its angle
cout << "The angle theta of p is: " << p.theta()
<< endl;
// Let's translate p
p.translate(10.0, 20.0);
// Show again its coordinates, after the translation

cout << "p is now (" << p.getX() << ',' << p.getY()
<< ')'<< endl;
} // main

} Lors de l'exécution de ce programme, il devrait s'afficher à

l'écran
p is (0.0,0.0)
The angle theta of p is: 0.0
p is now (10.0,20.0)

} La définition de pointeurs aux objets d'une classe se fait de la

même façon que celle des pointeurs aux objets des types
primitifs
int* anIntPointer;
Point* aPointPointer;
} L'allocation de mémoire se fait à l'aide de l'opérateur new
anIntPointer = new int;
aPointPointer = new Point;
} L'envoi de messages, à l'aide de l'opérateur ->
aPointPointer->translate(10.0, 20.0);
} La désallocation, à l'aide de l'opérateur delete
delete aPointPointer;

Classe Point : implémentation
} Comment implémenter chacun des services spécifiés dans le

contrat (interface de la classe) ?
} Tout d'abord, il faut déterminer les attributs qui constitueront
l'état d'un point, dans la perspective de notre abstraction
} Nous allons représenter un point comme un couple (x,y)
} Chacune des coordonnées est une valeur de type float
} Les attributs représentant les coordonnées x et y s'appelleront
x_ et y_ respectivement
} Le caractère souligné de x_ et y_ est une convention de style
} Les attributs x_ et y_ sont appelés les données membres, par
opposition aux fonctions membres ( getX, getY, rho, theta,
translate, rotate) de la classe
Classe Point : implémentation (suite)
public:
float getX();
// returns the x coordinate
float getY();
// returns the y coordinate
float rho();
// returns the distance to the origin
float theta();
// returns the angle to the
// horizontal axis
float x_; // x coordinate

float y_; // y coordinate
};

} Notation quasi UML (Unified Modeling Language)

http://www.rational.com/uml
Point Nom
Nomde
delalaclasse
classe
x_: float
y_: float Attributs
Attributs
getX: float
getY: float
rho: float
theta: float Opérations
Opérations
translate: void
rotate: void

} En temps d'exécution
// Create a point object
Point p1;
p1: Point
x_ = 0.0
y_ = 0.0
// Create another point object

Point p2; Deux
Deuxinstances
instances
différentes
différentesdedelalamême
même
p1: Point p2: Point classe Point,,avec
classePoint avecles
les
x_ = 0.0 x_ = 0.0 mêmes
mêmesvaleurs
valeursdans
dansleurs
leurs
y_ = 0.0 y_ = 0.0 attributs
attributs

} En temps d'exécution (suite)

// Translate p1
p1.translate(34.5, 18.8);
p1: Point p2: Point
x_ = 34.5 x_ = 0.0
y_ = 18.8 y_ = 0.0
// Now translate p2
p2.translate(-10.0, 20.0);
p1: Point p2: Point

x_ = 34.5 x_ = -10.0
y_ = 18.8 y_ = 20.0

} Et si on utilise des pointeurs

// Create a point pointer
Point* p1 = new Point;
p1
:Point
x_ = 0.0
y_ = 0.0
// Create another pointer

Point* p2 = p1; Une
Uneseule
seuleinstance
instance
p1 p2 de
delalamême
mêmeclasse
classe
:Point Point,,référencée
Point référencée
x_ = 0.0 par
pardeux
deuxpointeurs
pointeurs
y_ = 0.0 différents
différents
} Et si on utilise des pointeurs (suite)

// Translate the point pointed to by p1
p1->translate(34.5, 18.8);
p1 p2
:Point
x_ = 34.5
y_ = 18.8
// Now translate the point pointed to by p2

p2->translate(-10.0, 20.0);
p1 p2
:Point
x_ = 24.5
y_ = 38.8

} Nous pouvons maintenant implémenter chacune des fonctions

membres de la classe
} L'implémentation de ces fonctions sera écrite dans un fichier
de type .cpp
} Nous créons ainsi le fichier Point.cpp

Fichier Point.cpp
///////////////////////////////////////////////////////
// File: Point.cpp
// Description: implementation of the Point class
///////////////////////////////////////////////////////
#include "Point.h"
#include <math.h> // we need sin(), cos(), sqrt()
float Point::getX()
{
return x_;
}
float Point::getY()
{
return y_;
}

Fichier Point.cpp (suite)
float Point::rho()
{
return sqrt(x_*x_ + y_*y_);
}
float Point::theta()
{
return atan2(y_, x_);
}

Fichier Point.cpp (suite)
void Point::translate(float horizontal, float vertical)
{
x_ += horizontal;
y_ += vertical;
}
void Point::rotate(float angle) Une

Unefonction
fonction
{ membre
membrepeutpeuten
en
float currentRho = rho(); appeler
appelerd'autres
d'autres
float newTheta = theta() + angle; de
delalamême
même
x_ = currentRho * cos(newTheta); classe
classe
y_ = currentRho * sin(newTheta);
}

Contrôle d'accès
} Le mot clé public dans l'interface de la classe Point établit

pour un service (fonction membre), qu'il est utilisable par n'importe quel
objet client
pour un attribut (donnée membre), qu'il est accessible (y compris pour le
modifier) depuis n'importe quel autre objet
} En particulier, nous pourrions faire

Point p;
// WARNING: its x attribute can be modified!!!!

p.x_ = 47.0;

Contrôle d'accès (suite)
} L'accès public n'est pas souhaitable principalement pour les

attributs de la classe
} Les données membres d'une classe font partie des secrets de
l'implémentation et ne devraient donc pas être accessibles en
dehors de l'objet
} Nous devrions pouvoir encapsuler ces attributs de façon à ce
que les clients de la classe ne puissent pas y accéder
directement
} C++ offre plusieurs niveaux pour contrôler l'accès aux
fonctions/données membres
public
protégé
privé
} Accès public
Mot clé public
Les fonctions/données membres sont accessibles par tous les objets
} Accès protégé
Mot clé protected
Etroitement lié avec les mécanismes d'héritage
L'accès est limité aux classes de la hiérarchie
Plus de détails quand nous étudierons l'héritage
} Accès privé
Mot clé private
Les fonctions/données membres sont accessibles uniquement par les
fonctions qui implémentent les services offerts par la classe, et pas de
l'extérieur

} Il est nécessaire de modifier l'interface de la classe Point

public:
float getX(); // returns the x coordinate
float getY(); // returns the y coordinate
float rho(); // returns the distance to the origin
float theta(); // returns the angle to the
// horizontal axis
private:
float x_; // x coordinate
float y_; // y coordinate
};

} Il est maintenant impossible d'accéder de l'extérieur aux

attributs de la classe Point directement

Point p;
// Let's try to access the x_ attribute

cout << "p.x_ = "
<< p.x_ << endl; // Compilation ERROR:
// the x_ attribute is
// private!!!

} Notez qu'il n'est pas nécessaire de modifier l'implémentation

des fonctions membres de la classe (rotate, translate,
theta, rho, getX et getY)
} Toute fonction membre d'une classe peut accéder à tous les
attributs et à toute autre fonction membre, y compris ceux
privés, de la même classe
} C'est un mécanisme très puissant de la technologie objet. Il
permet de
séparer complètement interface et implémentation
cacher les détails (secrets) de l'implémentation aux clients
(encapsulation)
} Résultat: les modifications faites à l'implémentation de la
classe n'ont aucun impact chez les clients

tr
te an
t a sla
ro t e Encapsulation
Encapsulation::pourpour
x_ accéder
accéderauxauxdonnées
données
membres
membresde delalaclasse,
classe,ilil
y_ faut
faututiliser
utiliserles
lesservices
services
get
o
fournis
fournispar
parlalaclasse
rh
classe
X
get ta
Y h e
t
Classe Point
Fonctions Membres
} On peut différencier les fonctions membres d'une classe par

rapport à leur mission
gestion (comparaison, création/initialisation, destruction, copie, ...)
modification de l'état
consultation de l'état (attributs) de l'objet
fonctions d'aide
itération, pour les classes d'objets qui sont des conteneurs d'autres
objets
} Dans notre implémentation de la classe Point
getX(), getY(), rho() et theta() servent à consulter l'état de
l'objet
translate() et rotate() modifient l'état de l'objet
il n'y a pas (encore) des fonctions membres de gestion ni d'aide

Fonctions Membres (suite)
} Si le contraire n'est pas explicitement spécifié, en C++ les

fonctions membres sont des modificateurs potentiels de l'état
de l'objet
} En conséquence, il est impossible de demander un service à un
objet défini constant, si la fonction membre qui implémente le
service ne l'est pas
// Define a constant point
const Point origin;
// Retrieve the theta angle

float angle = origin.theta(); // Compilation ERROR:
// 'origin' is constant
// and Point::theta()
// is not

d'après l'interface de la classe, la fonction membre theta() est un
modificateur potentiel de l'état de l'objet origin
ceci est incompatible avec le fait que origin est constant
} Il faut modifier légèrement l'interface de la classe Point
pour informer le compilateur que Point::theta() ne modifie
pas l'état des objets de sa classe
} Il suffit d'ajouter le mot clé const à la déclaration de la
fonction membre

} Modification de l'interface de la classe Point (fichier

Point.h)
public:
// Modifiers
// Selectors
float getX() const; // x coordinate
float getY() const; // y coordinate

float rho() const; // distance to the origin

float theta() const; // angle to the
// horizontal axis
private:
// Data members
float x_; // Cartesian coordinates
float y_;
};

} Modification de l'implémentation de la classe Point (fichier

Point.cpp), pour refléter les changements dans l'interface
///////////////////////////////////////////////////////
// File: Point.cpp
// Description: implementation of the Point class
///////////////////////////////////////////////////////
#include "Point.h"
#include <math.h> // we need sin(), cos(), sqrt()

///////////////////////////////////////////////////////
// Modifiers
void Point::translate(float horizontal, float vertical)

{
x_ += horizontal;
y_ += vertical;
}
void Point::rotate(float angle)

{
float currentRho = rho();
float newTheta = theta() + angle;
x_ = currentRho * cos(newTheta);
y_ = currentRho * sin(newTheta);
}

///////////////////////////////////////////////////////
// Selectors
float Point::getX() const

{
return x_;
}
float Point::getY() const

{
return y_;
}

float Point::rho() const

{
return sqrt(x_*x_ + y_*y_);
}
float Point::theta() const
{
return atan2(y_, x_);
}

Fonctions Membres d'Initialisation
} Comme pour les types primitifs, lors de la définition d'un objet

le compilateur doit
réserver une quantité de mémoire suffisante pour stocker l'objet
donner une valeur initiale à l'objet
} Initialiser un objet composé de plusieurs données membres
(comme un objet de la classe Point) se traduit par donner une
valeur initiale à chacune d'elles
} Le compilateur fournit une fonction d'initialisation par défaut
pour chaque classe
} Appelée implicitement lors
de la définition d'un objet
Point p;

Fonctions Membres d'Initialisation (suite)
de l'allocation d'un objet via l'opérateur new
Point* pointPointer = new Point;
} Dans notre exemple de classe Point, cette fonction donne une
valeur initiale aux atributs x_ et y_ (probablement zéro)
} C++ offre au programmeur la possibilité de définir sa propre
méthode d'initialisation
} Cette méthode d'initialisation est appelée le constructeur
} Un constructeur est une fonction membre comme les autres,
avec deux caractéristiques particulières
il porte le même nom que la classe
il n'a pas un type de valeur de retour, même pas void
} Ajoutons le constructeur à la classe Point

class Point {
public:
// Constructor
Point();
// Modifiers
...
// Selectors
...
private:
// Data members
...
};
} Le fichier Point.cpp doit être modifié pour ajouter

l'implémentation du constructeur
///////////////////////////////////////////////////////
// Constructor
Point::Point()
{
x_ = 0.0;
y_ = 0.0;
}

} C++ permet de définir plusieurs constructeurs différents pour

la même classe
} Leur signatures doivent être différentes
} Nous pourrions ajouter à notre classe Point un constructeur
afin de pouvoir créer un objet et spécifier les valeurs initiales
des coordonées
l'implémentation de la classe Point ne nous permet pas de faire cela
directement, mais en deux étapes
// Create the point object
Point p; // p is (0.0, 0.0)
// Translate it
p.translate(45.0, 80.0);

class Point {
public:
// Constructors
Point();
Point(float initialX, float initialY);
// Modifiers
...
// Selectors
...
private:
// Data members
...
};
} La classe Point offre maintenant deux possibilités de création

d'objets
// Create a point at (45.0, 80.0)

Point p(45.0, 80.0); // calls Point::Point(float,float)
// Create a point at (0.0, 0.0)

Point origin; // calls Point::Point()
// Create a point at (5.0, 10.0) in the heap

Point* pointPointer = new Point(5.0, 10.0);

} Le fichier Point.cpp contiendra l'implémentation du nouveau

constructeur
///////////////////////////////////////////////////////
// Constructors
Point::Point() // Default constructor
{
x_ = 0.0;
y_ = 0.0;
}
Point::Point(float initialX, float initialY)

{
x_ = initialX;
y_ = initialY;
}

Fonction Membre de Destruction
} La fonction membre de destruction est appelée quand

un objet créé dans la pile d'exécution sort du contexte (fin de bloc ou
fin de fonction par exemple)
un objet créé dans le tas est explicitement détruit avec l'opérateur
delete
} Comme pour les constructeurs, le compilateur fournit un
destructeur par défaut
} Le destructeur est utile pour libérer les ressources acquis lors
de la création/modification de l'objet
libération de mémoire
fermeture des fichiers
libération de verrous
...

Fonction Membre de Destruction (suite)
} Une classe ne peut avoir qu'un seul destructeur

} Le destructeur porte le nom de la classe précédé du caractère
~ (tilda)
} Comme pour les constructeurs, le destructeur n'a pas de type
de valeur retour
} A la différence des constructeurs, le destructeur n'accepte
pas de paramètres

class Point {
public:
// Constructors/Destructor
Point();
Point(float initialX, float initialY);
~Point();
// Modifiers
...
// Selectors
...
private:
// Data members
...
};
} Le fichier Point.cpp contiendra l'implémentation du

destructeur
///////////////////////////////////////////////////////
// Destructor
Point::~Point()
{
// Nothing to be done
}

Organisation des Fichiers Source
Point.h Point.cpp
#include
#include <math.h>
<math.h>
#if
#if !defined(POINT_H)
!defined(POINT_H) #include "Point.h"
#include "Point.h"
#define
#define POINT_H
POINT_H
Point::Point()
Point::Point()
{{
class
class Point
Point {{ x_
x_ == 0.0;
0.0;
public:
public: y_ = 0.0;
y_ = 0.0;
Point(); }}
Point();
~Point();
~Point();
…… Point::~Point()
Point::~Point()
…… {{
private:
private: }}
float
float x_;
x_;
float
float y_;
y_; Point::getX()
Point::getX()
}; {{
}; return
return x_;
x_;
}}
#endif
#endif //
// POINT_H
POINT_H ……
……

Exercices
} Ajouter une fonction membre pour comparer deux objets de la

classe Point et déterminer s'ils sont identiques
} Ajouter une fonction membre pour copier un objet de la classe
Point dans un autre
} Ajouter un troisième constructeur (appelé constructeur de
copie) pour construire un objet de la classe Point à partir d'un
objet de la classe Point passé comme argument
} Ajouter une fonction membre pour modifier les valeurs des
coordonnées (x et/ou y) d'un objet de la classe Point
} Quelles modifications faut-il faire si l'on veut représenter un
Point en coordonnées polaires et non pas cartésiennes et ce
sans impacter les clients de la classe?

Résumé
} La classe est un moule pour construire des entités qui partagent

structure et comportement
} L'interface et l'implémentation d'une classe sont clairement
identifiées
} L'interface d'une classe est un contrat vis-à-vis des clients
} L'objet est la structure dynamique d'un programme
} Les objets collaborent (échangent des messages) pour résoudre
le problème en question
} Un objet est constitué d'attributs (structure) et de fonctions
membres (comportement)
} L'accès aux données et aux fonctions membres peut être
contrôlé et vérifié en temps de compilation

08 Objetsetclasses 120926014317 Phpapp02 PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

08 Objetsetclasses 120926014317 Phpapp02 PDF

Загружено:

Авторское право:

Доступные форматы

Programmation Orientée Objet en C++

8ème Partie: Objets et Classes

POO en C++: Objets et Classes 197 © 1997-2003 Fabio HERNANDEZ

} Nature d'un Objet

POO en C++: Objets et Classes 198 © 1997-2003 Fabio HERNANDEZ

} Un objet représente une entité individuelle et identifiable,

POO en C++: Objets et Classes 199 © 1997-2003 Fabio HERNANDEZ

} Caractéristiques d'un objet

POO en C++: Objets et Classes 200 © 1997-2003 Fabio HERNANDEZ

POO en C++: Objets et Classes 201 © 1997-2003 Fabio HERNANDEZ

} Les notions de classe et d ’objet sont étroitement liées

POO en C++: Objets et Classes 202 © 1997-2003 Fabio HERNANDEZ

} Deux vues d'une classe

POO en C++: Objets et Classes 203 © 1997-2003 Fabio HERNANDEZ

POO en C++: Objets et Classes 204 © 1997-2003 Fabio HERNANDEZ

} Ecriture en C++ d'une classe (interface et implémentation)

POO en C++: Objets et Classes 205 © 1997-2003 Fabio HERNANDEZ

} Quels sont les attributs d'un point qui nous intéressent?

POO en C++: Objets et Classes 206 © 1997-2003 Fabio HERNANDEZ

} Définition (incomplète) de l'interface de la classe Point

class Point { // Not yet finished !!!

POO en C++: Objets et Classes 207 © 1997-2003 Fabio HERNANDEZ

} getX, getY, rho, theta, translate et rotate sont des

} Comment utiliser les services offerts par les objets de la classe

objet destinataire p.rotate(45.0);

} Utilisation d'objets de la classe Point (fichier main.cpp)

// Show its coordinates

POO en C++: Objets et Classes 210 © 1997-2003 Fabio HERNANDEZ

// Show again its coordinates, after the translation

POO en C++: Objets et Classes 211 © 1997-2003 Fabio HERNANDEZ

} Lors de l'exécution de ce programme, il devrait s'afficher à

POO en C++: Objets et Classes 212 © 1997-2003 Fabio HERNANDEZ

} La définition de pointeurs aux objets d'une classe se fait de la

POO en C++: Objets et Classes 213 © 1997-2003 Fabio HERNANDEZ

} Comment implémenter chacun des services spécifiés dans le

float x_; // x coordinate

POO en C++: Objets et Classes 215 © 1997-2003 Fabio HERNANDEZ

} Notation quasi UML (Unified Modeling Language)

POO en C++: Objets et Classes 216 © 1997-2003 Fabio HERNANDEZ

// Create another point object

POO en C++: Objets et Classes 217 © 1997-2003 Fabio HERNANDEZ

} En temps d'exécution (suite)

p1: Point p2: Point

POO en C++: Objets et Classes 218 © 1997-2003 Fabio HERNANDEZ

} Et si on utilise des pointeurs

// Create another pointer

} Et si on utilise des pointeurs (suite)

// Now translate the point pointed to by p2

POO en C++: Objets et Classes 220 © 1997-2003 Fabio HERNANDEZ

} Nous pouvons maintenant implémenter chacune des fonctions

POO en C++: Objets et Classes 221 © 1997-2003 Fabio HERNANDEZ

POO en C++: Objets et Classes 222 © 1997-2003 Fabio HERNANDEZ

POO en C++: Objets et Classes 223 © 1997-2003 Fabio HERNANDEZ

void Point::rotate(float angle) Une

POO en C++: Objets et Classes 224 © 1997-2003 Fabio HERNANDEZ

} Le mot clé public dans l'interface de la classe Point établit

// Instantiate a Point object

// WARNING: its x attribute can be modified!!!!

POO en C++: Objets et Classes 225 © 1997-2003 Fabio HERNANDEZ

} L'accès public n'est pas souhaitable principalement pour les

POO en C++: Objets et Classes 227 © 1997-2003 Fabio HERNANDEZ

} Il est nécessaire de modifier l'interface de la classe Point

POO en C++: Objets et Classes 228 © 1997-2003 Fabio HERNANDEZ