II. Les Fonctions Membre

1. La surdéfinitions des fonctions membre :

Une propriété de C++ nous autorise à surdéfinir une fonction ordinaire, cela est aussi possible avec les fonctions membre et cela s'applique même au constructeur(mais pas au destructeur). La surdéfinitions consiste à pouvoir disposer de plusieurs fonctions ayant le même nom mais ayant un nombre d'argument différent donc une définition différente, mais dans l'absolue ces fonctions font le même traitement. C'est le programme, lors de la compilation, qui choisit à quelle fonction il doit faire référence. Voici les modifications que nous allons apporter à notre classe point :

Le constructeur point, le choix du bon constructeur se faisant grâce aux nombres d'arguments :

 

• 0 argument, les deux cordonnées sont initialisé à zéro au départ.
• 1 argument, la valeur de cet argument est affectée aux deux données membre.
• 2 arguments, c'est le cas déjà rencontré.

La fonction affiche pour que l'on puisse l'appeler :

• Sans argument comme auparavant.
• Avec une chaîne de caractères qui s'affiche avant la position de l'objet.

#include <iostream.h>

//Déclaration de la classe point//
class point
	{
	 int x,y;

  public:
	 point();        //Les 3 types de constructeur
	 point(int);
	 point(int,int);
	
	 void affiche();      //Les 2 fonctions affiche
	 void affiche(char*);
	};

point::point()
	{
	 x=0;y=0;
	}

//Définition des fonctions membre//
point::point(int abs)
	{
	 x=y=abs;
	}

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

void point::affiche()
	{
	 cout<<"je suis en "<<x<<" "<<y<<endl;
	}

void point::affiche(char* message)
	{
	 cout<<message;
	 affiche();
	}

void main()
 {
  point a;
  a.affiche;
  
  point b(5);
  b.affiche("point b ");

  point c(4,6);
  c.affiche("hello world ");
 }

je suis en 0 0
point b je suis 5 5
hello world je suis en 4,6

Nous avons vu que la fonction affiche(char*) appel la fonction affiche(), en effet une fonction membre peut toujours en appelé une autre quelle soit publique ou privée.

Comme toutes les fonctions, les fonctions membre accepte les arguments par défauts ceci afin de limiter le nombre de fonctions surdéfinies. Nous aurions pus remplacer les deux fonctions affiche par une seule fonction affiche prenant en argument un message de type char * initialiser à la chaîne vide(NULL).

void affiche(char*=""); /*déclaration de la fonction
 				membre dans la classe*/

void point::affiche(char *message) //définition de la fonction
	{
	 cout<<message<<"je suis en "<<x<<y<<endl;
	}

La simplification des fonctions surdéfinie n'est pas toujours possible, il faut donc faire attention lors de la mise en place des arguments par défauts pour ne pas dénaturer le rôle de la fonction.

2. Les fonctions membre "EN LIGNE" :

C++ permet de créer des fonctions dites "en ligne", celle-ci accroisse l'efficacité d'un programme lors de fonctions courtes(c'est à dire qu'il faut "éviter" les boucles et les conditions). Ici aussi, cela est transposable aux fonctions membre d'une classe. Il y a deux façons de rendre une fonction "en ligne" dans une class :

• Soit fournir la définition de la fonctions dans la déclaration de la classe; Alors le mot clé inline n'a pas à etre utiliser.

• Soit procédé comme pour une fonctions ordinaire et faire précédé la déclaration(dans la classe!) et la définition(en dehors de la classe!) de la fonction membre du mot clé inline.

Nous allons rendre "en ligne" nos trois constructeurs de la classe point avec la première manière :

#include iostream.h

class point
	{
	 int x,y;

  public:
	 point(){x=0;y=0;}      //les 3 constructeur sont 
	 point(int abs){x=y=abs;}       // "en ligne"
	 point(int abs,int ord){x=abs;y=ord;}

	 void affiche(char *="");
	};
void point::affiche(char* message)
	{
	 cout<<message<<"je suis en "<<x<<" "<<y<<endl;
	}

void main()
 {
  point a;
  a.affiche;
  
  point b(5);
  b.affiche("point b ");

  point c(4,6);
  c.affiche("hello world ");
 }

je suis en 0 0
point b je suis 5 5
hello world je suis en 4,6

Si nous avions déclaré nos constructeurs de la même manière que pour une fonction normale cela aurait donné ceci :

class point
	{
	 ...
  public:
	 inline point();
	 .....
	
	};

inline point::point()
	{
	 x=0;y=0;
	}
	.....

De part sa nature la définition de la fonction "en ligne" doit être connut du compilateur, pour la première démarche cela est automatiquement réalisé mais pour la deuxième. Pour cela on métra à la suite de la déclaration de la classe, les définitions des fonctions "en ligne" dans le fichier "en-tête". Attention les fonctions deviennent alors visible et modifiable par un utilisateur.