Discussion :

[titibete]

Je vous soumets ce petit bout de code épuré pour avoir votre avis sur ma façon de faire une interface à un de mes modules.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Classes du module
struct A
{
    void f(){}
};
 
struct B
{
    void g(){}
};
 
// Classe interface
class IAB
{
    private:
        struct A& a;
        struct B& b;
 
    public:
        IAB(A& aa, B& bb) : a(aa), b(bb) {}
 
        void do_thing() { a.f(); }
        void do_another_thing() { b.g(); }
};
 
// Exemple d'utilisation
int main()
{
    A a;
    B b;
    IAB interface(a, b);
 
    interface.do_thing();
    interface.do_another_thing();
}

N'hésitez à me dire si on peut mieux faire.
Merci,

[jblecanard]

Salut

Ce n'est pas mal, mais attention avec les références membres ! Il y a des cas où elles risquent de plus t'embêter qu'autre chose.

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
 
// Classes du module
struct A
{
	A() : v(5) {}
	void f(){ std::cout << v << std::endl; }
	int v;
};
 
struct B
{
    void g(){}
};
 
// Classe interface
class IAB
{
    private:
        struct A& a;
        struct B& b;
 
    public:
        IAB(A& aa, B& bb) : a(aa), b(bb) {}
 
        void do_thing() { a.f(); }
        void do_another_thing() { b.g(); }
};
 
// Exemple d'utilisation
int main()
{
	A * pA = new A();
	IAB interface2(*pA, B());
	delete pA;
	interface2.do_thing();
 
	return 0;
}

Ce code affiche une valeur indéterminée car pA a été détruit. Une des références devient invalide, mais le code peut (c'est le cas quand j'ai testé) s'exécuter sans générer d'erreur.

Tu peux aussi utiliser :
- des copies des structs en question.
- un pointeur membre
- un boost::shared_ptr membre si tu fais une allocation dynamique

[titibete]

Merci pour ta réponse.

Tu peux aussi utiliser :
- des copies des structs en question.
- un pointeur membre
- un boost::shared_ptr membre si tu fais une allocation dynamique

Les classes du module sont un peu plus volumineuses que celles présentées (ce sont des classes complètes avec membres et fonctions membres, j'ai mis struct contenant une fonction pour simplifier), donc la première suggestion ne convient pas.

Je me méfie des pointeurs nus, et je n'utilise pas boost pour ce projet...

Ah oui, j'ai oubliais le return de main !

[Mat007]

Salut,

En général on appelle plutôt ça une façade (le design pattern).

MAT.

[titibete]

Salut,

En général on appelle plutôt ça une façade (le design pattern).

MAT.

Oui, merci pour cette précision.

Pourrait-on m'éclairer sur les classes interface du type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
class A
{
    virtual void f()=0;
};

Ce sont des classes qu'il faut dériver pour définir une implémentation ?
Un exemple d'utilisation m'aiderai certainement à mieux comprendre...

[Mat007]

Jette un oeil à l'entrée de la FAQ sur les classes abstraites puis à cette section.

MAT.

[titibete]

Merci, en fait c'est un mécanisme que j'utilise déjà.

C'était pour éclaircir le concept que Stroustrup appelle "classe interface".

[titibete]

Houlà ! C'est pas très clair ce que je raconte ! Je reformule.

Je ne vois pas l'intérêt des classes dites "interface". çà ne fait que ralentir l'exécution puisqu'il y a des fonctions virtuelles, je me trompe ?

Je suppose qu'elles permettent d'intégrer plusieurs classes dans une même hiérarchie, et c'est tout ?

[jblecanard]

Je ne vois pas l'intérêt des classes dites "interface". çà ne fait que ralentir l'exécution puisqu'il y a des fonctions virtuelles, je me trompe ?

Je suppose qu'elles permettent d'intégrer plusieurs classes dans une même hiérarchie, et c'est tout ?

Non, ça sert par exemple à faire du polymorphisme. Tu manipules la classe de base, avec les méthodes virtuelles, mais les instances peuvent être de nature différentes, sans que le code qui les manipule ne le sache.

[titibete]

Exemple à ma sauce (je mets de côté NVI pour simplifier) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Base
{
    protected:
        int n;
 
    public:
        virtual void f() {std::cout << n; }
};
 
class Derived : public Base
{
    public:
        void f() { std::cout << "N :" << n; }
        void g() {}
};

Exemple de ce que ferait Stroustrup (enfin je crois):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Interface
{
    public:
        virtual void f()=0;
};
 
class Base : public Interface
{
    private:
        int n;
 
    public:
        virtual void f() {std::cout << n; }
};
 
class Base2 : public Interface
{
    private:
        int n;
 
    public:
        void f() { std::cout << "N :" << n; }
        void g() {}
};

Je code mal ? Ca fait une classe de plus avec la méthode Stroustrup.

Edit: en plus, je dois dupliquer les membres.

[Invité]

Sauf si le type de retour n'a pas de constructeur par défaut...
Et puis il n'est pas toujours judicieux d'implémenter la fonction dans la classe de base : la classe de base ne connait pas forcément les valeur nécessaire à l'implémentation de la fonction. Par exemple voici une classe abstraite Forme, où je pense qu'il est judicieux d'utiliser une fonction virtuelle pure :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
class Forme
{
public:
      virtual unsigned aire() const = 0;
};
 
class Cercle : public Forme
{
      unsigned radius_;
public:
      virtual unsigned aire() const
      {
            return pi*radius_*radius_; // pi est une constante definie qq part
      }
};
 
class TriangleRectangle : public Forme
{
     unsigned adj1, adj2;
public:
      virtual unsigned aire() const
      {
             return adj1*adj2/2;
      }
};

On pourrait aussi mettre une implémentation triviale dans la méthode aire()(du genre return 0; ) mais mis à part le premier problème évoqué, voici un petit code illustrant un second problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
class Cercle : public Forme
{
//...
    virtual int aire() const;  // type de retour
    virtual unsigned aire(); // cv-qualifier
    virtual unsigned arie() const; // nom
};

Ce problème pourra être évité grace aux attribut de la prochaine norme, mais pour l'instant...

[Emmanuel Deloget]

Exemple à ma sauce (je mets de côté NVI pour simplifier) :

<snip>

Exemple de ce que ferait Stroustrup (enfin je crois):

<snip>

Je code mal ? Ca fait une classe de plus avec la méthode Stroustrup.

Edit: en plus, je dois dupliquer les membres.

La différence fondamentale, c'est que le code de Stroustrup ne définit aucun comportement, tandis que toi si. Conceptuellement, c'est vraiment très différent.

On ne programme pas pour éviter à tout pris d'écrire du code