Programmer en C++
Les classes : Transmission d'objets

1. Objets transmis par argument

Comment écrire une fonction membre qui soit capable d'identifier si deux points sont identique ou non ?
La première idée serait de transmettre les deux points p1 et p2 en argument. On aurait alors une déclaration ressemblant à ceci :

bool identique(Point, Point);

Mais n'oublions pas qu'une fonction membre s'appelle à partir d'une instance existante. ça pourrait être le point p1, ou le point p2. Prenons par exemple le premier. Celà donnerait :

p1.identique(p1, p2);

Ce qui saute aux yeux immédiatement c'est la redondance du point p1. La fonction membre appelée par p1 connait déjà les variables membres de p1. Lui transmettre ce point en argument devient alors inutile. La déclaration de la fonction peut alors se simplifier :

bool identique(Point);

Ecrivons maintenant sa définition :

bool Point::identique(Point p2)
{
    if ((p2.x == x) && (p2.y == y))
    {
        return true;
    }
    else
    {
        return false;
    }
}

2. Objet renvoyé par une fonction

Imaginons cette fois que nous désirions obtenir un point qui soit l'homothétie d'une autre. Pour faire simple c'est un point à une autre échelle. Ainsi nous fournissons l'échelle à la fonction membre, et en appelant la fonction à partir d'un point, on obtient le nouveau point que la fonction nous renvoie. La déclaration de cette fonction pourrait être :

Point homothetie(int);

et sa définition :

Point Point::homothetie(int k)
{
    Point pt;     // Creation d'un point temporaire
    // Multiplication des coordonnees du point appelant, par k
    pt.x = x * k;
    pt.y = y * k;
    return pt;
}

3. Exemple complet

#include <iostream>

using namespace std;

// Déclaration de la classe Point
class Point
{
private:
    int x;
    int y;
public:
    Point(int x = 0, int y = 0);     // Constructeur avec arguments par défaut
    void afficher();
    bool identique(Point);
    Point homothetie(int);
};

int main()
{
    Point a(2, -4);
    a.afficher();
    Point b(2, -4);
    b.afficher();
    if (a.identique(b))
    {
        cout << "Les points ont les memes coordonnees" << endl;
    }
    Point c = a.homothetie(2);
    c.afficher();
    return 0;
}

Point::Point(int abscisse, int ordonnee)     // Constructeur
{
    x = abscisse;
    y = ordonnee;
}

void Point::afficher()
{
    cout << "Les coordonnees du point sont (" << x << ", " << y << ")" << endl;
}

bool Point::identique(Point p2)
{
    if ((p2.x == x) && (p2.y == y))
    {
        return true;
    }
    else
    {
        return false;
    }
}

Point Point::homothetie(int k)
{
    Point pt;     // Creation d'un point temporaire
    // Multiplication des coordonnees du point appelant, par k
    pt.x = x * k;
    pt.y = y * k;
    return pt;
}

Si nous lançons le programme, voici ce que nous obtenons :

Les coordonnees du point sont (2, -4)
Les coordonnees du point sont (2, -4)
Les points ont les memes coordonnees
Les coordonnees du point sont (4, -8)

Nous créons 2 points identiques. Nous comparons ensuite ces deux points, ce qui affiche le message : "Les points ont les memes coordonnees". Puis nous multiplions les coordonnées du premier point par deux pour créer un autre point qui est ensuite affiché.