Wie hoch ist der Leistungsaufwand von std :: function?

Es gibt in der Tat performance-Probleme mit std:function muss berücksichtigt werden, Wann immer Sie es verwenden. Die Stärke des std::function, nämlich seine type-erasure-Mechanismus, kommt nicht für frei, und wir könnten (aber nicht zwangsläufig muss) zahlen einen Preis dafür.

std::function ist eine Vorlage-Klasse, wraps callable Typen. Es ist jedoch nicht eingestellt auf den callable type selbst, sondern nur auf seine Rückkehr und die argument-Typen. Die callable-Typ bekannt, wird nur an Bau-Zeit und damit std::function nicht eine bereits deklarierte member dieses Typs zu halten, wird eine Kopie des Objekts gegeben an seinen Konstruktor.

Grob gesprochen (tatsächlich, die Dinge sind komplizierter als das) std::function kann jeweils nur ein Zeiger auf das übergebene Objekt den Konstruktor, und dies wirft ein Leben lang Problem. Wenn der Zeiger verweist auf ein Objekt, dessen Lebensdauer ist kleiner als der der std::function Objekt, dann wird der innere Zeiger wird zu baumeln. Um dieses problem zu vermeiden std::function könnte eine Kopie des Objekts auf dem heap, durch einen Aufruf operator new (oder eine benutzerdefinierte Zuweisung). Die dynamische Speicherverwaltung ist, was die Leute beziehen, die als performance-Strafe impliziert std::function.

Ich habe vor kurzem einen Artikel geschrieben mit mehr details und, die erklärt, wie (und wo) kann man vermeiden, zahlen den Preis für einen memory allocation.

http://drdobbs.com/cpp/232500059

InformationsquelleAutor der Antwort Cassio Neri

Erstens, der overhead wird kleiner mit der Innenseite der Funktion; je höher die Arbeitsbelastung, desto kleiner der overhead.

Zweitens: g++ 4.5 zeigt keinerlei Unterschied im Vergleich zu virtuellen Funktionen:

main.cc

#include <functional>
#include <iostream>

//Interface for virtual function test.
struct Virtual {
    virtual ~Virtual() {}
    virtual int operator() () const = 0;
};

//Factory functions to steal g++ the insight and prevent some optimizations.
Virtual *create_virt();
std::function<int ()> create_fun();
std::function<int ()> create_fun_with_state();

//The test. Generates actual output to prevent some optimizations.
template <typename T>
int test (T const& fun) {
    int ret = 0;
    for (int i=0; i<1024*1024*1024; ++i) {
        ret += fun();
    }    
    return ret;
}

//Executing the tests and outputting their values to prevent some optimizations.
int main () {
    {
        const clock_t start = clock();
        std::cout << test(*create_virt()) << '\n';
        const double secs = (clock()-start) / double(CLOCKS_PER_SEC);
        std::cout << "virtual: " << secs << " secs.\n";
    }
    {
        const clock_t start = clock();
        std::cout << test(create_fun()) << '\n';
        const double secs = (clock()-start) / double(CLOCKS_PER_SEC);
        std::cout << "std::function: " << secs << " secs.\n";
    }
    {
        const clock_t start = clock();
        std::cout << test(create_fun_with_state()) << '\n';
        const double secs = (clock()-start) / double(CLOCKS_PER_SEC);
        std::cout << "std::function with bindings: " << secs << " secs.\n";
    }
}

impl.cc

#include <functional>

struct Virtual {
    virtual ~Virtual() {}
    virtual int  operator() () const = 0;
};
struct Impl : Virtual {
    virtual ~Impl() {}
    virtual int  operator() () const { return 1; }
};

Virtual *create_virt() { return new Impl; }

std::function<int ()> create_fun() { 
    return  []() { return 1; };
}

std::function<int ()> create_fun_with_state() { 
    int x,y,z;
    return  [=]() { return 1; };
}

Ausgabe von g++ --std=c++0x -O3 impl.cc main.cc && ./a.out:

1073741824
virtual: 2.9 secs.
1073741824
std::function: 2.9 secs.
1073741824
std::function with bindings: 2.9 secs.

So, keine Angst. Wenn Ihr design/Wartbarkeit verbessern können, von der Bevorzugung std::function über virtuelle Anrufe, versuchen Sie. Ich persönlich mag die Idee nicht zwingen, Schnittstellen und Vererbung auf den clients meiner Klassen.

InformationsquelleAutor der Antwort Sebastian Mach