Discussion :

[Ekinoks]

Salut !

J’ai encore une question sur les héritages multiples
Lorsque l’on créé un objet, les constructeur de l’objet et des class dont il hérite s’exécute !

J’aimerais savoir si il est possible de faire un truc un peu équivalant avec une fonction, je m’explique :
Disions qu’on a un class A qui hérite de la class B et de la class C
Les trois class contienne une fonction f(), et t’il possible que j’exécute toute ces fonctions f() sans donné le nom de class ?

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
class B
{
 
  public :
    void f()
    {
      printf("f() de de class B");
    }
};
 
class C
{
 
  public :
    void f()
    {
      printf("f() de de class C");
    }
};
 
...
 
class A : public B, public C, ...
{
 
  public :
    void f()
    {
      B::f();
      C::f();
      ...
 
 
      //j'aimerais ici faire appelle a toute les f() des class que A herite sans utiliser les Nom_Class::f(), car je connais pas forcement tout les class hérité... comment faire ?
    }
};

Vous avez une idée ?

Merci

[Swoög]

tu ne connais pas forcément toutes les classes héritées ? je vois mal comment ça peut être possible !?

[Ekinoks]

tu ne connais pas forcément toutes les classes héritées ? je vois mal comment ça peut être possible !?

lol oui effectivement je sais que c'est bizarre... en fait je les connais mais... pour que le code soit plus réutilisable facilement, j'aimerais ne pas prendre en compte le nom des class.
Comme ça qu’elle que soit le nom des fonctions que j'hérite, je n’est pas à modifier mon code ^^

[Luther13]

Si l'on accepte de modifier le prototype de la fonction f(),
on pourrait passer en paramètre les différentes classes (template).

[Laurent Gomila]

On peut sortir des jolis trucs de meta-programmation, mais est-ce que ça en vaut vraiment le coup ?

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
40
41
42
43
44
#include <iostream>
 
using namespace std;
 
struct A {void f() {cout << "f() de A" << endl;}};
struct B {void f() {cout << "f() de B" << endl;}};
struct C {void f() {cout << "f() de C" << endl;}};
 
struct NullList {};
 
template <typename H, typename T>
struct TypeList
{
    typedef H Head;
    typedef T Tail;
};
 
template <typename T> struct Caller;
 
template <typename T1, typename T2>
struct Caller<TypeList<T1, T2> > : public T1, public Caller<T2>
{
    void f(){Caller<T2>::f(); T1::f();}
};
 
template <>
struct Caller<NullList>
{
    void f(){}
};
 
#define TYPELIST3(C1, C2, C3) TypeList<C1, TypeList<C2, TypeList<C3, NullList> > >
 
typedef TYPELIST3(A, B, C) MesTypesDeBase;
 
struct Derived : public Caller<MesTypesDeBase> {};
 
int main()
{
    Derived d;
    d.f();
 
    return 0;
}

Après on peut aussi passer en paramètre template la fonction à appeler pour avoir un truc plus flexible.

[Ekinoks]

et que pensez vous dans le même genre d'un code style :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#define listclass B,C                      // liste des class que A herite, C'EST ICI QUE L'UTILISATION DOIT DEFINIR LES CLASS A HERITER
#define heritage(a,b) public a, public b   //il faudrais que ici le nombre d'argument de heritage ne soit pas defini ... :^/
#define appelleF(a,b) a::f(); b::f();      //ici aussi il faudrais que le nombre d'argument ne soi pas defini...
 
class A : heritage(listclass)
{
    public :
        void f()
        {
            //appelle de tout les f() des class que A herite
            appelleF(listclass);
        }
};

[Ekinoks]

non, en fait je croie que je vais laisser tomber cette idée, c'est vrai que ça rajoute beaucoup de code pour pas grand chose et la clarté du code source en prend un coup aussi ....

Merci a tousse pour votre aide !!! =)