"lesdeveloppeurs.net": C++ : PROPRIETES DES FONCTIONS MEMBRES (Cours et exercices corrigés)

I- SURDEFINITION DES FONCTIONS MEMBRES

En utilisant la propriété de surdéfinition des fonctions du C++, on peut définir plusieurs constructeurs, ou bien plusieurs fonctions membres, différentes, mais portant le même nom.

Exemple (à tester) et exercice III-1: Définition de plusieurs constructeurs:

#include <iostream.h> // Surdefinition de fonctions
#include <conio.h>

class point
{
int x,y;
public: point(); // constructeur 1
point(int);// constructeur 2
point(int,int);// constructeur 3
void affiche();
};

point::point() // constructeur 1
{x=0;y=0;}

point::point(int abs) // constructeur 2
{x = abs; y = abs;}

point::point(int abs,int ord) // constructeur 3
{x = abs; y = ord;}

void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void main()
{
clrscr();
point a,b(5);
a.affiche();
b.affiche();
point c(3,12);
c.affiche();
getch() ;}

Exercice III-2: Surdéfinition d’une fonction membre
Ecrire une deuxième fonction affiche de prototype void point::affiche(char *message)
Cette fonction donne la possibilité à l’utilisateur d’ajouter, à la position du point, un message sur l’écran.

II- FONCTIONS MEMBRES « EN LIGNE »

Le langage C++ autorise la description des fonctions membres dès leur déclaration dans la classe. On dit que l’on écrit une fonction « inline ».
Il s’agit alors d’une « macrofonction »: A chaque appel, il y a génération du code de la fonction et non appel à un sous-programme.
Les appels sont donc plus rapides mais cette méthode génère davantage de code.

Exemple (à tester) et exercice III-3:
Comparer la taille des fichiers exIII_1.obj et exIII_3.obj

#include <iostream.h> // Surdefinition de fonctions
#include <conio.h>

class point
{
int x,y;
public: point(){x=0;y=0;} // constructeur 1
point(int abs){x=abs;y=abs;}// constructeur 2
point(int abs,int ord){x=abs;y=ord;}// constructeur 3
void affiche();
};

void point::affiche()
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void main()
{
point a,b(5);
a.affiche();
b.affiche();
point c(3,12);
c.affiche();
getch() ;
}


III- INITIALISATION DES PARAMETRES PAR DEFAUT

Exemple (à tester) et exercice III-4:

#include <iostream.h> // Fonctions membres « en ligne »
#include <conio.h>

class point
{
int x,y;
public: point(int abs=0,int ord=2){x=abs;y=ord;}// constructeur
void affiche(char* = "Position du point"); // argument par defaut
};

void point::affiche(char *message)
{gotoxy(x,y-1);cout<<message;
gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void main()
{
point a,b(40);
a.affiche();
b.affiche("Point b");
char texte[10]="Bonjour";
point c(3,12);
c.affiche(texte);
getch() ;
}

IV- OBJETS TRANSMIS EN ARGUMENT D’UNE FONCTION MEMBRE

Quand on passe comme paramètre à une fonction membre ... un objet de la classe à laquelle appartient cette fonction:

1- Passage par valeur

Exemple (à tester) et exercice III-5:

#include <iostream.h>
#include <conio.h>// objets transmis en argument d'une fonction membre

class point
{
int x,y;
public: point(int abs = 0,int ord = 2){x=abs;y=ord;}// constructeur
int coincide(point);
};

int point::coincide(point pt)
{if ((pt.x == x) && (pt.y == y)) return(1);else return(0);}
// noter la dissymetrie des notations pt.x et x

void main()
{
int test1,test2;
point a,b(1),c(0,2);
test1 = a.coincide(b);
test2 = b.coincide(a);
cout<<"a et b:"<<test1<<" ou "<<test2<<"\n";
test1 = a.coincide(c);
test2 = c.coincide(a);
cout<<"a et c:"<<test1<<" ou "<<test2<<"\n";
getch() ;
}

Noter que l’on rencontre la notation « pt.x » ou « pt.y » pour la première fois. Elle n’est autorisée qu’à l’intérieur d’une fonction membre (x et y membres privés de la classe).

On verra plus tard que le passage d’un objet par valeur pose problème si certains membres de la classe sont des pointeurs. Il faudra alors prévoir une allocation dynamique de mémoire via un constructeur.

2- Passage par adresse

Exercice III-6: Modifier la fonction membre coincide de l’exercice prcédent de sorte que son prototype devienne int point::coincide(point *adpt). Ré-écrire le programme principal en conséquence.

3- Passage par référence

Exercice III-7: Modifier à nouveau la fonction membre coincide de sorte que son prototype devienne int point::coincide(point &pt). Ré-écrire le programme principal en conséquence.

V- EXERCICES RECAPITULATIFS

On définit la classe vecteur comme ci-dessous:

class vecteur
{float x,y;
public: vecteur(float,float);
void homotethie(float);
void affiche();
};

vecteur::vecteur(float abs =0.,float ord = 0.)
{x=abs;y=ord;}

void vecteur::homotethie(float val)
{x = x*val; y = y*val;}

void vecteur::affiche()
{cout<<"x = "<<x<<" y = "<<y<<"\n";}
Exercice III-8: La mettre en oeuvre dans void main(), en ajoutant une fonction membre float det(vecteur) qui retourne le déterminant des deux vecteurs (celui passé en paramètre et celui de l’objet).

Exercice III-9: Modifier la fonction déterminant de sorte de passer le paramètre par adresse.

Exercice III-10: Modifier la fonction déterminant de sorte de passer le paramètre par référence.


VI- OBJET RETOURNE PAR UNE FONCTION MEMBRE

Que se passe-t-il lorsqu’une fonction membre retourne elle-même un objet ?

1- Retour par valeur

Exemple (à tester) et exercice III-11: (la fonction concernée est la fonction symetrique)

#include <iostream.h>
#include <conio.h>

// La valeur de retour d'une fonction est un objet
// Transmission par valeur

class point
{
int x,y;
public: point(int abs = 0,int ord = 0){x=abs;y=ord;}// constructeur
point symetrique();
void affiche();
};

point point::symetrique()
{point res;
res.x = -x; res.y = -y;
return res;
}

void point::affiche()
{cout<<"Je suis en "<<x<<" "<<" "<<y<<"\n";}

void main()
{point a,b(1,6);
a=b.symetrique();a.affiche();b.affiche();
getch() ;}

2- Retour par adresse (***)

Exemple (à tester) et exercice III-12:
#include <iostream.h>
#include <conio.h>

// La valeur de retour d'une fonction est un objet
// Transmission par adresse

class point
{
int x,y;
public: point(int abs = 0,int ord = 0){x=abs;y=ord;}// constructeur
point *symetrique();
void affiche();
};

point *point::symetrique()
{point *res;
res = new point;
res->x = -x; res->y = -y;
return res;
}

void point::affiche()
{cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void main()
{
point a,b(1,6);
a = *b.symetrique();a.affiche();b.affiche();
getch() ;}

3- Retour par référence (***)

La valeur retournée l’est par référence. On en verra l’usage dans un prochain chapitre.

Exemple (à tester) et exercice III-13:

#include <iostream.h>
#include <conio.h>

// La valeur de retour d'une fonction est un objet
// Transmission par reference

class point
{
int x,y;
public: point(int abs = 0,int ord = 0){x=abs;y=ord;}// constructeur
point &symetrique();
void affiche();
};
point &point::symetrique() // La variable res est obligatoirement static
{static point res; // Pour passer par reference
res.x = -x; res.y = -y;
return res;
}

void point::affiche()
{cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void main()
{
point a,b(1,6);
a=b.symetrique();a.affiche();b.affiche();
getch() ;}

Remarque: « res » et « b.symetrique »occupent le même emplacement mémoire (car « res » est une référence à « b.symetrique ». On déclare donc « res » comme variable static, sinon, cet objet n’existerait plus après être sorti de la fonction.

VII- EXERCICES RECAPITULATIFS

Exercice III-14: Reprendre la classe vecteur. Modifier la fonction homotéthie, qui retourne le vecteur modifié. (prototype: vecteur vecteur::homotethie(float val)).

Exercice III-15 (***): Même exercice, le retour se fait par adresse.

Exercice III-16 (***): Même exercice, le retour se fait par référence.


VIII- LE MOT CLE « THIS »

Ce mot désigne l’adresse de l’objet invoqué. Il est utilisable uniquement au sein d’une fonction membre.

Exemple (à tester) et exercice III-17:

#include <conio.h>// le mot cle THIS: pointeur sur l'objet l'ayant appel
#include <iostream.h>// utilisable uniquement dans une fonction membre

class point
{int x,y;
public:
point(int abs=0,int ord=0) // constructeur en ligne
{x=abs;y=ord;}
void affiche();
};
void point::affiche()
{cout<<"Adresse: "<<this<<" - Coordonnees: "<<x<<" "<<y<<"\n";}

void main()
{point a(5),b(3,15);
a.affiche();b.affiche();
getch() ;}

Exercice III-18: Remplacer, dans l’exercice III-6, la fonction coincide par la fonction suivante:

int point::coincide(point *adpt)
{if ((this->x == adpt->x) && (this->y == adpt->y))
return(1);else return(0);}

IX- EXERCICE RECAPITULATIF

Exercice III-19: Reprendre la classe vecteur, munie du constructeur et de la fonction d’affichage. Ajouter
- Une fonction membre float vecteur::prod_scal(vecteur) qui retourne le produit scalaire des 2 vecteurs.
- Une fonction membre vecteur vecteur::somme(vecteur) qui retourne la somme des 2 vecteurs.

XI- CORRIGE DES EXERCICES

Exercice III-2:

#include <iostream.h> // Surdefinition de fonctions
#include <conio.h>

class point
{
int x,y;
public: point(); // constructeur 1
point(int);// constructeur 2
point(int,int);// constructeur 3
void affiche();
void affiche(char *); // argument de type chaine
};

point::point() // constructeur 1
{x=0;y=0;}

point::point(int abs) // constructeur 2
{x=y=abs;}

point::point(int abs,int ord) // constructeur 3
{x = abs; y = ord;}

void point::affiche() // affiche 1
{gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void point::affiche(char *message) // affiche 2
{gotoxy(x,y-1);cout<<message;
gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}

void main()
{point a,b(5);
a.affiche();
b.affiche("Point b:");
point c(3,12);
char texte[10] = "Bonjour";
c.affiche(texte);
getch() ;}

Exercice III-6:

#include <iostream.h>
#include <conio.h>

// objets transmis en argument d'une fonction membre - transmission de l'adresse

class point
{
int x,y;
public: point(int abs = 0,int ord = 2){x=abs;y=ord;}// constructeur
int coincide(point *);
};

int point::coincide(point *adpt)
{if ((adpt->x == x) && (adpt->y == y)) return(1);else return(0);}
// noter la dissymetrie des notations pt->x et x

void main()
{point a,b(1),c(0,2);
int test1,test2;
test1 = a.coincide(&b);
test2 = b.coincide(&a);
cout<<"a et b:"<<test1<<" ou "<<test2<<"\n";
test1 = a.coincide(&c);
test2 = c.coincide(&a);
cout<<"a et c:"<<test1<<" ou "<<test2<<"\n";
getch() ;}

Exercice III-7:

#include <iostream.h>
#include <conio.h>

// objets transmis en argument d'une fonction membre - transmission par reference

class point
{
int x,y;
public: point(int abs = 0,int ord = 2){x=abs;y=ord;}// constructeur
int coincide(point &);
};

int point::coincide(point &pt)
{if ((pt.x == x) && (pt.y == y)) return(1);else return(0);}
// noter la dissymetrie des notations pt.x et x

void main()
{point a,b(1),c(0,2);
int test1,test2;
test1 = a.coincide(b);
test2 = b.coincide(a);
cout<<"a et b:"<<test1<<" ou "<<test2<<"\n";
test1 = a.coincide(c);
test2 = c.coincide(a);
cout<<"a et c:"<<test1<<" ou "<<test2<<"\n";
getch() ;}

Exercice III-8:

#include <iostream.h>
#include <conio.h>
// Classe vecteur - Fonction membre determinant - Passage par valeur
class vecteur
{float x,y;
public: vecteur(float,float);
void homotethie(float);
void affiche();
float det(vecteur);};

vecteur::vecteur(float abs =0.,float ord = 0.)
{x=abs;y=ord;}

void vecteur::homotethie(float val)
{x = x*val; y = y*val;}

void vecteur::affiche()
{cout<<"x = "<<x<<" y = "<<y<<"\n";}

float vecteur::det(vecteur w)
{float res;
res = x * w.y - y * w.x;
return res;}

void main()
{vecteur v(2,6),u(4,8);
v.affiche();v.homotethie(2);v.affiche();
cout <<"Determinant de (u,v) = "<<v.det(u)<<"\n";
cout <<"Determinant de (v,u) = "<<u.det(v)<<"\n";getch() ;}

Exercice III-9:

#include <iostream.h>
#include <conio.h>
// Classe vecteur - Fonction membre determinant - Passage par adresse
class vecteur
{float x,y;
public: vecteur(float,float);
void homotethie(float);
void affiche();
float det(vecteur *);};

vecteur::vecteur(float abs =0.,float ord = 0.)
{x=abs;y=ord;}

void vecteur::homotethie(float val)
{x = x*val; y = y*val;}

void vecteur::affiche()
{cout<<"x = "<<x<<" y = "<<y<<"\n";}

float vecteur::det(vecteur *w)
{float res;
res = x * w->y - y * w->x;
return res;}

void main()
{vecteur v(2,6),u(4,8);
v.affiche();v.homotethie(2);v.affiche();
cout <<"Determinant de (u,v) = "<<v.det(&u)<<"\n";
cout <<"Determinant de (v,u) = "<<u.det(&v)<<"\n";getch() ;}

Exercice III-10:

#include <iostream.h>
#include <conio.h>
// Classe vecteur - Fonction membre determinant - Passage par reference
class vecteur
{float x,y;
public: vecteur(float,float);
void homotethie(float);
void affiche();
float det(vecteur &);};

vecteur::vecteur(float abs =0,float ord = 0)
{x=abs;y=ord;}

void vecteur::homotethie(float val)
{x = x*val; y = y*val;}

void vecteur::affiche()
{cout<<"x = "<<x<<" y = "<<y<<"\n";}

float vecteur::det(vecteur &w)
{float res;
res = x * w.y - y * w.x;
return res;}

void main()
{vecteur v(2,6),u(4,8);
v.affiche();v.homotethie(2);v.affiche();
cout <<"Determinant de (u,v) = "<<v.det(u)<<"\n";
cout <<"Determinant de (v,u) = "<<u.det(v)<<"\n";getch() ;}

Exercice III-14:

#include <iostream.h>
#include <conio.h>
// Classe vecteur - Fonction homotethie - Retour par valeur
class vecteur
{float x,y;
public: vecteur(float,float); // Constructeur
vecteur homotethie(float);
void affiche();};

vecteur::vecteur(float abs =0,float ord = 0)
{x=abs;y=ord;}

vecteur vecteur::homotethie(float val)
{vecteur res;
res.x = x*val; res.y = y*val;
return res;}

void vecteur::affiche()
{cout<<"x = "<<x<<" y = "<<y<<"\n";}

void main()
{vecteur v(2,6),u;
v.affiche();u.affiche();
u = v.homotethie(4);
u.affiche();getch() ;}

Exercice III-15:

#include <iostream.h>
#include <conio.h>
// Classe vecteur - Fonction homotethie - Retour par adresse
class vecteur
{float x,y;
public: vecteur(float,float); // Constructeur
vecteur *homotethie(float);
void affiche();};

vecteur::vecteur(float abs =0.,float ord = 0.) // Constructeur
{x=abs;y=ord;}

vecteur *vecteur::homotethie(float val)
{vecteur *res;
res = new vecteur;
res->x = x*val; res->y = y*val;
return res;}

void vecteur::affiche()
{cout<<"x = "<<x<<" y = "<<y<<"\n";}


void main()
{vecteur v(2,6),u;
v.affiche();u.affiche();
u = *v.homotethie(4);
u.affiche();getch() ;}

Exercice III-16:

#include <iostream.h>
#include <conio.h>
// Classe vecteur -Fonction homotethie - Retour par reference
class vecteur
{float x,y;
public: vecteur(float,float); // Constructeur
vecteur &homotethie(float);
void affiche();};

vecteur::vecteur(float abs =0,float ord = 0)
{x=abs;y=ord;}

vecteur &vecteur::homotethie(float val)
{static vecteur res;
res.x = x*val; res.y = y*val;
return res;}

void vecteur::affiche()
{cout<<"x = "<<x<<" y = "<<y<<"\n";}

void main()
{vecteur v(2,6),u;
v.affiche();u.affiche();
u = v.homotethie(4);
u.affiche();getch() ;}

Exercice III-18:

#include <iostream.h>// objets transmis en argument d'une fonction membre
#include <conio.h>// Utilisation du mot clé THIS

class point
{
int x,y;
public: point(int abs = 0,int ord = 0){x=abs;y=ord;}// constructeur
int coincide(point *);
};

int point::coincide(point *adpt)
{if ((this->x == adpt->x) && (this->y == adpt->y))
return(1);else return(0);}

void main()
{point a,b(1),c(1,0);
cout<<"a et b:"<<a.coincide(&b)<<" ou "<<b.coincide(&a)<<"\n";
cout<<"b et c:"<<b.coincide(&c)<<" ou "<<c.coincide(&b)<<"\n";
getch() ;}

Exercice III-19:

#include <iostream.h>
#include <conio.h>

// Creation d'une classe vecteur, avec constructeur, affichage
// Produit scalaire de 2 vecteurs

class vecteur
{float x,y;
public:vecteur(float,float);
vecteur somme(vecteur);
float prod_scal(vecteur);void affiche();};

vecteur::vecteur(float xpos=0,float ypos=0)
{x = xpos; y = ypos;}

float vecteur::prod_scal(vecteur v) // tester le passage par reference &v
{float res;
res = (x * v.x) + (y * v.y);
return (res);}

vecteur vecteur::somme(vecteur v) // tester aussi le passage par reference &v
{vecteur res;
res.x = x + v.x;
res.y = y + v.y;
return res;}

void vecteur::affiche()
{cout<<"x= "<<x<<" y= "<<y<<"\n";}

main()
{vecteur a(3);a.affiche();vecteur b(1,2);b.affiche();
vecteur c(4,5),d;c.affiche();
cout<<"b.c = "<<b.prod_scal(c)<<"\n";
cout<<"c.b = "<<c.prod_scal(b)<<"\n";
c = a.somme(b);
d = b.somme(a);
cout<<"Coordonnees de a+b:";c.affiche();cout<<"\n";
cout<<"Coordonnees de b+a:";d.affiche();cout<<"\n";
getch() ;}

Les exercices exécutables:

EXIII_1.CPP

EXIII_2.CPP

EXIII_3.CPP

EXIII_4.CPP

EXIII_5.CPP

EXIII_6.CPP

EXIII_7.CPP

EXIII_8.CPP

EXIII_9.CPP

EXIII_10.CPP

EXIII_11.CPP

EXIII_12.CPP

EXIII_13.CPP

EXIII_14.CPP

EXIII_15.CPP

EXIII_16.CPP

EXIII_17.CPP

EXIII_18.CPP

EXIII_19.CPP