Hello,

je cherche a réduire l overhead du au polymorphisme tout en le conservant. Je m'explique :

J'ai une classe qui sert d'interface :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
 
class A 
{
public :
 
    virtual void f(const B&) = 0;
};
J'ai un code de ce style :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
std::vector<A*> myVectorAptr;
std::vector<B> myVectorB;
 
// ...
 
for (int i = 0; i < myVectorB.size(); ++i)
    for (int j = 0; j < myVectorAptr.size(); ++j)
        myVectorAptr[j]->f(myVectorB[i]);
Dans ce code il y a appel a une méthode virtuelle myVectorB.size() * myVectorAptr.size() fois.

Je pourrais changer le code en :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
 
class A 
{
public :
 
    virtual void f(const std::vector<B>&) = 0;
};
 
// ...
 
for (int j = 0; j < myVectorAptr.size(); ++j)
     myVectorAptr[j]->f(myVectorB);
et faire la boucle sur les B directement dans les fonctions virtuelles et n'avoir plus que myVectorAptr.size() appels a des méthodes virtuelles mais cela impose de changer l'ordre de mes boucles. Or je ne souhaite pas le faire.

DOnc, y a t'il moyen de faire avant les double boucles imbriquées, une premiere boucle sur myVectorAptr pour récupérer l'addresse de la méthode virtuelle a appelé en fonction du type dynamique de A, de stocker ces adresses dans un tableaux puis ainsi d'appeler les bonnes méthodes dans la double boucle sans avoir a résoudre le type dynamique de chaque A pour chaque B. Faire une sorte de vtable optimisée quoi.

Est ce qu un mécanisme de ce genre est possible ?
Est ce que ca réduirai l'overhead de facon significative sachant que j'ai peu de A pour beaucoup de B ?

Je ne sais pas si je suis très clair et ma question n a peut etre pas de sens.
Merci pour vos réponses.