1. Chapitre IV
Les propriétés des fonctions
membres
Toutes les possibilités offertes par C++ pour les fonctions restent valables pour les fonctions
membres (surcharge, arguments par défaut, …)
Exemple 4.1
On désir munir la classe point d'un constructeur qui permet de créer le point :
: (EXP04_01.CPP)
• (0,0) si aucun argument n'est fourni
• (abs,0) si on lui fournit abs comme seul argument
• (abs,ord) si on lui fournit les deux arguments abs et ord
Pour cela, il suffit de définir le constructeur de la classe avec des paramètres par défaut
class point
{
int x; int y;
public:
point(int = 0, int = 0);
… …
}
point::point(int abs, int ord){
x = abs; y = ord;
}

2. Les propriétés des fonctions membres 28
Exemple 4.2
On désire maintenant que le constructeur de la classe point crée le point
: (EXP04_02.CPP)
• (abs,abs) si on lui fournit un seul argument (abs)
Dans ce cas, on ne peut pas utiliser des valeurs par défaut, il faut par suite surcharger le
constructeur :
class point
{
int x; int y;
public:
point();
point(int);
point(int,int);
… …
}
point::point() { x = 0; y = 0;}
point::point(int abs) {x = abs; y = abs;}
point::point(int abs, int ord){ x = abs; y = ord;}
IV.1 Objets transmis en argument
• Considérons une classe T et une fonction F dont l'un des paramètres est un objet de T
transmis par valeur, par adresse ou par référence. Soit U une instance de T transmis en
argument à F, alors:
1. Si F est une fonction membre de T, elle aura accès à tous les membres données
de U, sinon elle n'aura accès qu'aux membres publiques de U
2. Si la transmission de U se fait par valeur, il y a recopie des membres données de
U dans un emplacement locale à F, ce qui entraîne certaines problèmes si la
classe contient des pointeurs
Exemple 4.3
Définir une fonction qui permet de comparer deux instances de la classe point. Cette
fonction devra retourner "true" si les deux objets coïncident et "false" sinon.
: (EXP04_03.CPP)
La comparaison nécessite l'accès aux coordonnées des points, qui sont des données privés,
par suite, la fonction doit être une fonction membre de la classe
La déclaration de la fonction dans la classe sera :
bool coincide(point)
et sa définition
bool point::coincide(point pt)
{
return ( (pt.x == x) && (pt.y == y));
}
• On peut prévoir pour cette fonction une transmission par adresse ou par référence.

3. Les propriétés des fonctions membres 29
IV.2 Objets fournis en valeur de retour
• Etant donné une classe T et une fonction F qui a l'une des formes suivantes :
T F(arguments); // retour par valeur
T * F(arguments); // retourne l'adresse
T & F(arguments) // retourne une référence
Alors F aura accès à tous les membres de l'objet retourné si elle est une fonction
membre de T, si non elle n'aura accès qu'aux membres publics de la classe.
Exemple 4.4
On désire définir la fonction symetrique() qui permet de retourner le symétrique d'un
point.
: (EXP04_04.CPP)
Cette fonction doit être une fonction membre de la classe point, puisqu'elle doit accéder
aux coordonnées du point, qui sont des données privées. La valeur de retour sera de type
point
La déclaration de la fonction dans la classe sera :
point symetrique();
et sa définition
point point::symetrique(){
point pt;
pt.x = -x; pt.y = -y;
return pt;
}
IV.3 Le pointeur this
• Dans une fonction membre, this représente un pointeur sur l'instance ayant appelé
cette fonction
• this est un pointeur constant, c'est-à-dire qu'on ne peut le modifier.
Exemple 4.5
class point {
: (EXP04_05.CPP)
int x; int y;
public:
point(int=0, int=0);
void affiche();
};
point::point(int abs, int ord) { x = abs; y = ord;}
void point point::affiche()
{
cout << " le point : (" << this->x << "," << this->y << ")" ;
cout << " est à l'adresse " << this << endl;
}
la fonction membre affiche() de la classe point affiche les coordonnées de l'objet et de son adresse.
IV.4 Fonctions membres en ligne
• Toute fonction membre définie dans sa classe (dans la déclaration de la classe) est
considérée par le compilateur comme une fonction inline. Le mot clé inline n'est plus
utilisé.

4. Les propriétés des fonctions membres 30
Dans l'exemple suivant, le constructeur de la classe point est défini en ligne
class point {
int x; int y;
public:
point(int abs = 0, int ord =0){
x = abs; y = ord;}
void affiche();
};
IV.5 Fonctions membres statiques
• On distingue deux types de membres :
♦ Membres d'instance : membres associés à une instance de la classe.
♦ Membres de classe : membres associés à la classe et qui ne dépendent d'aucune
instance de la classe.
• Les membres de classe, sont aussi dits membres statiques. Ils sont déclarés avec
l'attribut static, et existent même si aucun objet de la classe n'est crée.
• Ainsi on peut définir un membre donnée statique comme on peut définir une fonction
membre statique. L'accès à ces membres se fait avec l'opérateur de résolution de
portée (::) précédé par le nom de la classe ou d'un quelconque objet de la classe
Exemple 4.6
Dans cet exemple, on prévoit dans la classe point un membre donnée statique privé
nb_obj et une fonction membre NbObj() qui retourne le nombre d'instances crées.
:
Interface: (POINT2.H)
#ifndef POINT_H
#define POINT_H
class point{
int x;
int y;
static int nb_obj;
public:
point(int = 0, int = 0);
~point();
void affiche();
static int NbObj();
};
#endif
Corps de la classe: (POINT2.CPP)
#include "point2.h"
#include <iostream> // utilisé dans affiche()
using namespace std;
//--- definition obligatoire du membre donnée statique
int point::nb_obj;
//--- constructeur
point::point(int abs, int ord){
x = abs; y = ord;
nb_obj++;
}
//--- Destructeur
point::~point(){

5. Les propriétés des fonctions membres 31
nb_obj--;
}
//--- affiche
void point::affiche(){
cout << "(" << x << "," << y << ")" << endl;
}
//--- definition de la fonction membre statique
int point::NbObj(){
return nb_obj;
}
Programme test: (EXP04_06.CPP)
#include "point.h"
#include <iostream>
using namespace std;
int main()
{
/ Acces à la fonction membre statique avant la création des objets
cout << "Nombre de points : " << point::NbObj() << endl;
// Appel de la fct membre statique en utilisant un objet
point a;
cout << "Nombre de points : " << a.NbObj() << endl;
return 0;
}
IV.6 Les fonctions membres constantes
• Les objets, comme les autres types de C++, peuvent être déclarés constants avec
l'attribut const. Dans ce cas, seules les fonctions membres déclarées et définies avec
l'attribut const peuvent être appelées par des objets constants.
Plus précisément :
class T {
… …
public:
…
type_a F(…); // fct membre ordinaire
type_b G(…) const; // fct membre constante
type_c K(const T); // fct avec argument constant
};
// déclarations
T u; // instante non constante
const T v; // instante constante
// appels
u.F(…) // OK
v.F(…) // erreur : instance constante
u.G(…) // OK
v.G(…) // OK
//
T w;
u.K(v) // OK
u.K(w) // OK
v.K(w) // erreur : instance constante et fct non constante
v est une instance constante, donc elle ne peut être appelée ni par F ni par K, qui ne sont pas des fonctions
constantes

6. Les propriétés des fonctions membres 32
Exemple 4.7
Cet exemple montre la différence entre les variables simples et les objets lors de passage
en arguments à des fonctions demandant des arguments constants et la différence d'une
fonction membre et une fonction non membre agissant sur des objets constants.
: (EXP04_07.CPP)
#include <iostream>
using namespace std;
//-----------------------------------------------------------------
class point{
int x;
int y;
public:
point(int abs = 0, int ord = 0){
x = abs; y = ord;
}
void affiche() const; // fct membre constante
bool coincide(const point); // argument constant
void deplace(int,int);
};
void point::affiche() const{
cout << "(" << x << "," << y << ")" << endl;
}
bool point::coincide(const point pt){
return ( (pt.x == x) && (pt.y == y) );
}
void point::deplace(int dx, int dy){
x =+ dx; y =+ dy;
}
//-----------------------------------------------------------------
// fonction avec argument constant de type simple
void fct(const int k) { cout << k << endl; }
// fonction avec argument constant de type classe
point sosie(const point pt) { return pt; }
//----------------------------- TEST
int main()
{
// Cas d'une fonction simple avec argument de type simple
int i = 5;
const int j = 10;
fct(i); // OK
fct(j); // OK
// ----------------------Cas des objets
point a;
const point b(5,6);
//-----Appel d'une fonction non membre
point c;
c = sosie(a); // OK
c = sosie(b); // OK
//-----Appel d'une fonction membre non constante
a.deplace(1,1);
//b.deplace(1,1); // erreur : instance constante, fonction non
constante
//-----Appel de la fonction membre constante
cout << "a = " ; a.affiche();

7. Les propriétés des fonctions membres 33
cout << "b = " ; b.affiche();
cout << endl;
//-----Appel de la fonction membre non constante avec paramètres
constants
// instance non constant, argument constant
cout << ( a.coincide(b) ? "coincident" : "ne coincident pas" )<< endl;
// instance non constante, argument non constant
cout << ( a.coincide(a) ? "coincident" : "ne coincident pas" )<< endl;
// instance constante, fonction non constante : ERREUR
//cout << ( b.coincide(a) ? "coincident" : "ne coincident pas" )<< endl;
return 0;
}

8. Les propriétés des fonctions membres 34