Traits vs overhead virtuel

Question

Je suis tombé sur un tutoriel d'Alexandrescu sur les traits et j'ai quelques réflexions à partager. Voici le code:

// Example 6: Reference counting traits 
// 
template <class T> 
class RefCountingTraits 
{ 
    static void Refer(T* p) 
    { 
    p->IncRef(); // assume RefCounted interface 
    } 

    static void Unrefer(T* p) 
    { 
    p->DecRef(); // assume RefCounted interface 
    } 
}; 

template <> 
class RefCountingTraits<Widget> 
{ 
    static void Refer(Widget* p) 
    { 
    p->AddReference(); // use Widget interface 
    } 
    static void Unrefer(Widget* p) 
    { 
    // use Widget interface 
    if (p->RemoveReference() == 0) 
     delete p; 
    } 
}; 

Combien les frais généraux que nous avons dans ce cas par rapport à un membre de la fonction virtuelle cas standard? nous n'accédons pas directement à l'objet aussi dans ce cas: nous passons toujours un pointeur. Le compilateur est-il capable de l'optimiser de la même manière?

Answer 1

Aux niveaux d'optimisation de production standard (-O2 ou /O2), vous pouvez vous attendre à ce que tout le code que vous avez indiqué soit aligné et que les bits sans effets secondaires soient optimisés. Cela laisse les appels réels à IncRef ou AddReference et le chèque pour et delete -ion. Si les fonctions virtual ont été utilisées, et si le code de comptage de référence est trivial (par exemple, non thread-safe), il peut avoir été plus lent d'un ordre de grandeur en raison d'une recherche de table de répartition et d'un appel de fonction hors ligne , mais cela va varier un peu avec le compilateur, les paramètres d'optimisation exacts, le CPU, les conventions d'appel, etc.

Comme toujours, lorsque vous devez vous soucier, faire des profils et expérimenter.