Discussion :

[Lawyer666]

Bonjour à tous,

J’aimerais utiliser pour mon code du polymorphisme statique.
En effet, nous voulons absolument éviter tout ce qui est méthode virtuelle pour éviter de gréver les perfs (le profiler de Visual nous a indiqué que l'introspection nous faisait perdre beaucoup de temps, nous sommes sur un logiciel où le besoin de perf est très important).

J'ai donc pensé à une architecture classique, du type :

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
<class T> Base
{
   void f()
   {
      (static_cast<T*>this)->f() ;
   }
}
 
Class DerivedA : public Base<DerivedA>
{
   void f()
   {
      //Des trucs à faire
   }
}
 
Class DerivedB : public Base<DerivedB>
{
   void f()
   {
      //D’autres trucs à faire
   }
}

Et pour savoir quel objet je dois instancier, j'ai en entrée, à l'exécution, un char qui m'indique quel type d'objet je dois utiliser.

Je voudrais donc utiliser une sorte de Factory pour créer mes objets. Quelque chose de ce style :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Base* Factory(char code)
{
       Base* obj = NULL;
       if (code == ‘a’)
       {
             obj = new DerivedA();
       }
       else if (code == ‘b’)
       {
             obj = new DerivedB();
       }
       return obj;
}

Ainsi je pourrais avoir un code générique dans le main sans avoir de méthode virtuelle, le rêve

Code :

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

1
2
3
4
5
6
void caller(char c)
{
   Base* obj = Factory(c);
   obj->f();
   delete obj;
}

Seulement voilà, je ne peux pas renvoyer de Base* étant donné que Base est templaté, il faut donc que je spécialise…, ce que je ne veux pas faire puisque je veux avoir du code générique. oO

Et j’aimerais en plus éviter l’allocation mémoire (me passer des pointeurs et du new quoi !). En fait je voudrais faire du polymorphisme mais sans pointeur, ce qui semble difficile !

Si vous avez des suggestions à me faire pour ce petit problème d'architecture, je suis preneur Merci.

[ptyxs]

In Bjarne Stroustrup Programming Principles and Practise Using C++, section 14.3.1 :

We have met people who were terrified of virtual functions "because they were expensive." Why? How expensive? Compared to what? Where would the cost matter? We explain the implementation model for virtual functions so that you won't have such fears. If you need a virtual function call (to select among alternatives at run time) you can't code the functionality to be any faster or to use less memory using other language features.

[3DArchi]

Salut,
Je peux me tromper, mais je ne vois pas beaucoup de possibilité : soit tu manipules en permanence des génériques, soit tu utilises des abstractions et des fonctions virtuelles. Si tu fais du type erasure, d'une façon ou d'une autre, tu auras probablement au mieux le même coût qu'une fonction virtuelle.

En revanche, on peut faire du polymorphisme sans allocation dynamique. Tes objets peuvent être créer sur la pile (ou dans les données) et ensuite transmis avec un pointeur (ou une référence) vers leur classe de base. Bien sur il faut veiller à ce que l'objet ne soit pas détruit.

Pour les problèmes de perfs, êtes vous sur que l'appel à la fonction virtuelle est vraiment le point qui grève les perfs ? Une solution est peut être de retravailler l'algo pour introduire la variation du comportement autrement. Mais là, ça ne peut pas être une solution en dehors de ton contexte. Il faut connaître ton algo.

[Flob90]

Le CRTP est une technique qui peut en effet permet d'éviter l'utilisation de fonctions virtuelles, mais ca ne simule qu'un polymorphisme statique, c'est à dire que tout doit pouvoir être déterminé à la compilation.

Et quand on utilise une factory, c'est justement pour créer des objet dont le type ne sera déterminé qu'à l'execution, il faudrait faire une sorte de "Static_Factory", mais ce n'est pas le même but ...

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
 
template<class D>
struct B
{ void foo() { static_cast<D*>(this)-> foo(); } };
 
struct E : B<E>
{ void foo() {} };
 
struct F : B<F>
{ void foo() {} };
 
template<size_t>
struct Static_Factory;
 
template<>
struct Static_Factory<0>
{ static B<E> create() { return E(); } };
 
template<>
struct Static_Factory<1>
{ static B<F> create() { return F(); } };
 
int main()
{
  auto b = Static_Factory<0>::create();
  b.foo();
  return EXIT_SUCCESS;
}

Quelque chose dans ce gout là. A regarder dans les bibliothèque de méta-prog, il doit y avoir des outils pour faire ce genre de chose.