===== Couplage entre classes =====

L'idée de base de la programmation objet est de créer des objets. Quand on fait cela, c'est déjà un bon début. Cependant, ce n'est généralement pas suffisant. Il faut également que les objets communiquent entre eux.

Lorsque qu'un objet-enfant est créé dans un objet-parent, il n'y a pas de problème pour que le parent puisse communiquer avec l'enfant. Comme le parent a créé l'enfant, il le connait bien. En particulier, il connait les fonctions publiques de l'objet-enfant et peut donc les appeler directement.

<code cpp>
class Enfant {
public:
    void une_fonction() const {}
};

class Parent {
    Enfant mon_enfant;
public:
    void autre_fonction() const {
        mon_enfant.une_fonction(); // Ok
    }
};
</code>

Lorsque deux classes communiquent entre elles, on dit qu'elles sont couplées. Ici, le couplage est dit fort, puisque la classe ''Parent'' doit absolument connaitre la classe ''Enfant''. Si ces deux classes sont déclarées dans des fichiers différents (''parent.h'' et ''enfant.h'' par exemple), il sera nécessaire d'inclure le fichier ''enfant.h'' dans le fichier ''parent.h''.

<code cpp>
// dans parent.h
#include "enfant.h"
</code>

Ce couplage n'est pas symétrique. En effet, la classe ''Enfant'' ne connait pas (et n'a pas besoin de connaitre) la classe ''Parent''. En revanche, si on souhaite appeler une fonction de ''Parent'' dans ''Enfant'', on est face à deux difficultés.

Premièrement, il faut appeler la fonction sur un objet en particulier. Comme l'objet ''Enfant'' est déjà un membre de la classe ''Parent'', il ne serait pas possible de créer un nouvel objet ''Parent'' dans ''Enfant'', puisque dans cette situation, l'objet Parent contiendrait un objet ''Enfant'', qui contient à son tour un autre objet ''Parent'', lui-même contenant un objet ''Enfant'' et ainsi de suite. On se retrouve dans une boucle infinie, cela n'a pas de sens.

<code cpp>
class Enfant {
    Parent mon_parent;
};
</code>

Cette situation est résolue en ne créant pas un objet de type ''Parent'' dans la classe ''Enfant'', mais créant simplement un "lien" vers un objet de type ''Parent'' existant (par exemple, l'objet de type ''Parent'' qui a créé l'objet de type ''Enfant'' comme variable membre). Ce type de "lien" est réalisé en C++ en utilisant une référence ou un pointeur. Il sera alors possible d'appeler une fonction de l'objet de type ''Parent'' dans l'objet de type ''Enfant''.

<code cpp>
// dans enfant.h
class Enfant {
    Parent const& mon_parent; // référence
public:
    void une_fonction() const {
        mon_parent.encore_une_fonction();
    }
};

// dans parent.h
#include "enfant.h"
class Parent {
    Enfant mon_enfant;
public:
    Parent() : mon_enfant(*this) { // beurk
    }

    void autre_fonction() const {
        mon_enfant.une_fonction(); // Ok
    }

    void encore_une_fonction() const {
    }
};
</code>

Si vous essayez de compiler ce code, vous obtiendrez une erreur dans la classe ''Enfant'' : "le type Parent n'est pas connu". La raison est que le compilateur ne connait pas encore la classe ''Parent'', il ne peut pas savoir à quoi correspond le terme "Parent" dans votre code. La solution est alors d'indiquer au compilateur que ce terme existe et qu'il correspond à une classe. Dans cette situation, on parle de "déclaration anticipée" de la classe ''Parent''.

<code cpp>
// dans enfant.h
class Parent; // on indique au compilateur que le terme "Parent" existe et que c'est une classe
class Enfant {
    Parent const& mon_parent; // référence
public:
    Enfant(Parent const& p) : mon_parent(p) {
    }

    void une_fonction() const {
        mon_parent.encore_une_fonction();
    }
};

// dans parent.h
#include "enfant.h"
class Parent {
    Enfant mon_enfant;
public:
    Parent() : mon_enfant(*this) { // beurk
    }

    void autre_fonction() const {
        mon_enfant.une_fonction(); // Ok
    }

    void encore_une_fonction() const {
    }
};
</code>

Cependant, cela ne fonctionne toujours pas. En effet, trois lignes en dessous, on essaie d'appeler la fonction ''encore_une_fonction'' de la classe ''Parent''. Or, pour le moment, le compilateur sait simplement qu'il existe une classe ''Parent'', il ne sait pas encore ce qu'elle contient. Pour résoudre ce second problème, on va donc séparer la déclaration des classes de leur implémentation en les mettant dans des fichiers séparés (par exemple ''enfant.cpp'' et ''parent.cpp'') :

<code cpp>
// dans enfant.h
class Parent; // déclaration anticipée
class Enfant {
    Parent const& mon_parent; // référence
public:
    Enfant(Parent const& p);
    void une_fonction() const;
};

// dans enfant.cpp
#include "enfant.h"
#include "parent.h"
Enfant::Enfant(Parent const& p) : mon_parent(p) {
}
void Enfant::une_fonction() const {
    mon_parent.encore_une_fonction();
}

// dans parent.h
#include "enfant.h"
class Parent {
    Enfant mon_enfant;
public:
    Parent() : mon_enfant(*this);
    void autre_fonction() const;
    void encore_une_fonction() const;
};

// dans parent.cpp
#include "parent.h"
#include "enfant.h"
Parent::Parent() : mon_enfant(*this) { // beurk
}
void Parent::autre_fonction() const {
    mon_enfant.une_fonction(); // Ok
}
void Parent::encore_une_fonction() const {
}
</code>

Ce type de code est très classique en C++, on le retrouve partout. Mais cela pose un problème majeur : ce code n'est pas évolutif. Les classes et les fonctions appelées sont figées, si on souhaite appeler une autre fonction ou une autre classe, il faudra modifier le code existant de ces classes et ajouter toutes les déclarations de classes et de fonctions (imaginez le résultat sur un projet contenant plusieurs centaines de classes...) Il est possible d'améliorer la situation en mettant les fonctions et les objets comme paramètres des classes et fonctions (utilisation des templates, fonctions callback, etc), mais cela donne un code relativement lourd à maintenir et à faire évoluer.

Qt implémente également le système parent-enfant, avec les fonctions suivantes. Il est en particulier utilisé pour les destructions automatiques des hiérarchies d'objets. Voir : [[http://doc-snapshot.qt-project.org/qt5-dev/objecttrees.html|Object Trees & Ownership]].

<code cpp-qt>
QObject * QObject::parent() const;
void setParent(QObject * parent);

const QObjectList & QObject::children() const;
T QObject::findChild(const QString & name = QString(), 
    Qt::FindChildOptions options = Qt::FindChildrenRecursively) const;
QList<T> QObject::findChildren(const QString & name = QString(), 
    Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
</code>