Cet appel à un objet fonction est-il en ligne?

Question

Dans le code suivant, Foo::add appelle une fonction via un objet de fonction:

struct Plus { 
    inline int operator()(int x, int y) const { 
    return x + y; 
    } 
}; 

template<class Fct> 
struct Foo { 
    Fct fct; 
    Foo(Fct f) : fct(f) {} 
    inline int add(int x, int y) { 
    return fct(x,y); // same efficiency adding directly? 
    } 
}; 

Est-ce la même efficacité que d'appeler x+y directement Foo::add? En d'autres termes, le compilateur remplace-t-il généralement fct(x,y) par l'appel réel, en insérant le code, lors de la compilation avec les optimisations activées?

Answer 1

Pour g ++ 4.4.1, il sera aligné à -O1 ou supérieur.

J'ai utilisé le programme (ainsi que votre code):

int main() 
{ 
    Foo<Plus> foo((Plus())); 
    int a, b; 
    cin >> a >> b; 
    int x = foo.add(a, b); 
    cout << x << endl; 
} 

Pour -O0, vous obtenez (g ++ -S, extrait):

main: 
.LFB960: 
     ; ... 
    call _ZN3FooI4PlusEC1ES0_ 
    ; ... 
    call _ZN3FooI4PlusE3addEii 
    ; ... 

_ZN3FooI4PlusE3addEii: 
     ; ... 
    call _ZNK4PlusclEii 
     ; ... 

ZNK4PlusclEii: 
    ; ... 
    ; This is the actual add 
    leal (%edx,%eax), %eax 
    ; ... 

A -O1 ou -O2 , Foo et Plus disparaissent entièrement de ce test.

main: 
    ; ... 
    addl 24(%esp), %eax 
    ; ... 

Answer 2

Eh bien, cela dépend de votre compilateur. Si elle décide d'intégrer, elle sera intégrée. S'il a décidé de ne pas le faire, il ne sera pas intégré. Inline est contrôlé par des heuristiques spécifiques au compilateur. Cela dépend du compilateur. Cela dépend des paramètres du compilateur. Ça dépend du contexte. La seule façon de dire avec certitude est d'essayer de voir ce qui se passe. "Typiquement", il devrait être en ligne.

P.S. Le mot clé inline est redondant lorsque la fonction est définie dans la définition de classe. De telles fonctions sont déjà intégrées. L'ajout du mot clé explicite inline ne fait absolument aucune différence.