C++: Funktionswrapper, der sich genau wie die Funktion selbst verhält

Question

Wie kann ich einen Wrapper schreiben, der jede Funktion umbrechen kann und genau wie die Funktion selbst aufgerufen werden kann?

Der Grund, warum ich das brauche: Ich möchte ein Timer-Objekt, das eine Funktion umhüllen und sich genau wie die Funktion selbst verhalten kann, und es protokolliert die akkumulierte Zeit aller seiner Aufrufe.

würde das Szenario wie folgt aussehen:

// a function whose runtime should be logged 
double foo(int x) { 
    // do something that takes some time ... 
} 

Timer timed_foo(&foo); // timed_foo is a wrapping fct obj 
double a = timed_foo(3); 
double b = timed_foo(2); 
double c = timed_foo(5); 
std::cout << "Elapsed: " << timed_foo.GetElapsedTime(); 

Wie kann ich diese Timer Klasse schreiben?

Ich versuche, so etwas wie dieses:

#include <tr1/functional> 
using std::tr1::function; 

template<class Function> 
class Timer { 

public: 

    Timer(Function& fct) 
    : fct_(fct) {} 

    ??? operator()(???){ 
    // call the fct_, 
    // measure runtime and add to elapsed_time_ 
    } 

    long GetElapsedTime() { return elapsed_time_; } 

private: 
    Function& fct_; 
    long elapsed_time_; 
}; 

int main(int argc, char** argv){ 
    typedef function<double(int)> MyFct; 
    MyFct fct = &foo; 
    Timer<MyFct> timed_foo(fct); 
    double a = timed_foo(3); 
    double b = timed_foo(2); 
    double c = timed_foo(5); 
    std::cout << "Elapsed: " << timed_foo.GetElapsedTime(); 
} 

(BTW, ich kenne gprof und andere Werkzeuge zur Laufzeitprofilierung, sondern eine solche mit Timer Objekt die Laufzeit von wenigen ausgewählten Funktionen zu protokollieren ist bequemer . für meine Zwecke)

Answer 1

Hier ist ein leicht Weise Funktionen zu wickeln.

template<typename T> 
class Functor { 
    T f; 
public: 
    Functor(T t){ 
     f = t; 
    } 
    T& operator()(){ 
    return f; 
    } 
}; 


int add(int a, int b) 
{ 
    return a+b; 
} 

void testing() 
{ 
    Functor<int (*)(int, int)> f(add); 
    cout << f()(2,3); 
} 

Answer 2

es ist nicht wirklich klar, mich für das, was Sie .. Allerdings suchen, für das gegebene Beispiel, dann ist es einfach:

void operator() (int x) 
{ 
    clock_t start_time = ::clock(); // time before calling 
    fct_(x);       // call function 
    clock_t end_time = ::clock();  // time when done 

    elapsed_time_ += (end_time - start_time)/CLOCKS_PER_SEC; 
} 

Hinweis: Damit wird die Zeit in Sekunden gemessen. Wenn Sie hochpräzise Timer benötigen, müssen Sie wahrscheinlich die betriebssystemspezifische Funktionalität überprüfen (z. B. GetTickCount oder QueryPerformanceCounter unter Windows).

Wenn Sie einen generischen Funktionswrapper haben wollen, sollten Sie einen Blick auf Boost.Bind werfen, der sehr hilfreich sein wird.

Answer 3

In C++ Funktionen sind Bürger der ersten Klasse, können Sie buchstäblich eine Funktion als Wert übergeben.

Da Sie wollen, dass es einen int nehmen und eine doppelte Rückkehr:

Timer(double (*pt2Function)(int input)) {... 

Answer 4

Sie sind für eine große Herausforderung, wenn Sie eine generische Klasse zu schaffen suchen, und rufen Sie eine beliebige Funktion wickeln kann. In diesem Fall müssten Sie den Funktor (den Operator()) dazu veranlassen, double zurückzugeben und einen int als Parameter zu verwenden. Dann haben Sie eine Familie von Klassen erstellt, die alle Funktionen mit derselben Signatur aufrufen können. Sobald Sie weitere Arten von Funktionen hinzufügen möchten, benötigen Sie mehr Funktoren dieser Signatur, z.

MyClass goo(double a, double b) 
{ 
    // .. 
} 

template<class Function> 
class Timer { 

public: 

    Timer(Function& fct) 
    : fct_(fct) {} 

    MyClass operator()(double a, double b){ 

    } 

}; 

EDIT: Einige Rechtschreibfehler

Answer 5

Grundsätzlich, was Sie tun möchten, ist in C++ derzeit unmöglich. Für eine beliebige Anzahl von arity der Funktion, die Sie wickeln möchten, müssen Sie durch

Überlastung

const reference 
non-const reference 

Aber dann noch, es ist nicht perfekt Weiterleitung (einige Grenzfälle noch stehen), aber es sollte auch vernünftig arbeiten.Wenn Sie sich auf const Referenzen begrenzen, können Sie mit diesem gehen (nicht getestet):

template<class Function> 
class Timer { 
    typedef typename boost::function_types 
     ::result_type<Function>::type return_type; 

public: 

    Timer(Function fct) 
    : fct_(fct) {} 

// macro generating one overload 
#define FN(Z, N, D) \ 
    BOOST_PP_EXPR_IF(N, template<BOOST_PP_ENUM_PARAMS(N, typename T)>) \ 
    return_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& t)) { \ 
     /* some stuff here */ \ 
     fct_(ENUM_PARAMS(N, t)); \ 
    } 

// generate overloads for up to 10 parameters 
BOOST_PP_REPEAT(10, FN, ~) 
#undef FN 

    long GetElapsedTime() { return elapsed_time_; } 

private: 
    // void() -> void(*)() 
    typename boost::decay<Function>::type fct_; 
    long elapsed_time_; 
}; 

Beachten Sie, dass für den Rückgabetyp, können Sie boost die Funktionstypen Bibliothek verwenden. Dann

Timer<void(int)> t(&foo); 
t(10); 

Sie können auch reine Wertparameter Überlastung verwenden, und dann, wenn Sie etwas durch Verweis übergeben möchten, verwenden Sie boost::ref. Das ist eigentlich eine ziemlich verbreitete Technik, vor allem, wenn solche Parameter gespeichert werden werden (diese Technik auch für boost::bind verwendet wird):

// if you want to have reference parameters: 
void bar(int &i) { i = 10; } 

Timer<void(int&)> f(&bar); 
int a; 
f(boost::ref(a)); 
assert(a == 10); 

Oder Sie können diese Überlastungen sowohl const und nicht-const Versionen gehen und fügen Sie als oben erklärt. Sehen Sie in Boost.Preprocessor nach, wie Sie die richtigen Makros schreiben.

Sie sollten sich bewusst sein, dass das Ganze schwieriger wird, wenn Sie beliebige Callables (nicht nur Funktionen) übergeben wollen, da Sie einen Weg brauchen, um ihren Ergebnistyp zu erhalten (das ist gar nicht so einfach)). C++ 1x wird diese Art von Dingen einfacher machen.

Answer 6

Hier ist, wie ich es tun würde, einen Funktionszeiger anstelle einer Vorlage:

// pointer to a function of the form: double foo(int x); 
typedef double (*MyFunc) (int); 


// your function 
double foo (int x) { 
    // do something 
    return 1.5 * x; 
} 


class Timer { 
public: 

    Timer (MyFunc ptr) 
    : m_ptr (ptr) 
    { } 

    double operator() (int x) { 
    return m_ptr (x); 
    } 

private: 
    MyFunc m_ptr; 
}; 

Habe ich es nicht einen Verweis auf die Funktion übernehmen, sondern nur einen einfacher Funktionszeiger. Verbrauch bleibt gleich:

Timer t(&foo); 
    // call function directly 
    foo(i); 
    // call it through the wrapper 
    t(i); 

Answer 7

Wenn Ihr Compiler variadische Makros unterstützt, würde ich versuchen Sie dies:

class Timer { 
    Timer();// when created notes start time 
    ~ Timer();// when destroyed notes end time, computes elapsed time 
} 

#define TIME_MACRO(fn, ...) { Timer t; fn(_VA_ARGS_); } 

Also, es zu benutzen, würden Sie dies tun:

void test_me(int a, float b); 

TIME_MACRO(test_me(a,b)); 

Das ist aus dem Stegreif, und Sie müssten herumspielen, um Rückgabetypen zum Arbeiten zu bringen (ich denke, dass Sie dem TIME_MACRO-Aufruf einen Typnamen hinzufügen und dann eine temporäre Variable generieren lassen müssen).

Answer 8

Ich nehme an, dass Sie dies für Testzwecke brauchen und sie nicht als echte Proxies oder Dekorateure verwenden werden. Sie müssen also nicht operator() verwenden und können eine andere, weniger bequeme Methode verwenden.

template <typename TFunction> 
class TimerWrapper 
{ 
public: 
    TimerWrapper(TFunction function, clock_t& elapsedTime): 
     call(function), 
     startTime_(::clock()), 
     elapsedTime_(elapsedTime) 
    { 
    } 

    ~TimerWrapper() 
    { 
     const clock_t endTime_ = ::clock(); 
     const clock_t diff = (endTime_ - startTime_); 
     elapsedTime_ += diff; 
    } 

    TFunction call; 
private: 
    const clock_t startTime_; 
    clock_t& elapsedTime_; 
}; 


template <typename TFunction> 
TimerWrapper<TFunction> test_time(TFunction function, clock_t& elapsedTime) 
{ 
    return TimerWrapper<TFunction>(function, elapsedTime); 
} 

So funktionieren einige von Ihnen testen Sie nur test_time Funktion und nicht die direkte TimerWrapper Struktur

int test1() 
{ 
    std::cout << "test1\n"; 
    return 0; 
} 

void test2(int parameter) 
{ 
    std::cout << "test2 with parameter " << parameter << "\n"; 
} 

int main() 
{ 
    clock_t elapsedTime = 0; 
    test_time(test1, elapsedTime).call(); 
    test_time(test2, elapsedTime).call(20); 
    double result = test_time(sqrt, elapsedTime).call(9.0); 

    std::cout << "result = " << result << std::endl; 
    std::cout << elapsedTime << std::endl; 

    return 0; 
} 

Answer 9

Stroustrup mit Überlastung verwenden sollte die operator-> eine Funktion Wrapper (injaction) Fähigkeit bewiesen hatte. Die Schlüsselidee ist: operator-> wird wiederholt aufgerufen, bis es einen systemeigenen Zeigertyp trifft, also lassen Sie Timer::operator-> ein temporäres Objekt zurückgeben, und das temporäre Objekt gibt seinen Zeiger zurück. Dann wird folgendes passieren:

1. temp obj erstellt (ctor genannt).
2. Zielfunktion aufgerufen.
3. temp obj zerstört (dtor genannt).

Und Sie können jeden Code innerhalb der CTor und der dtor injizieren. So was.

template < class F > 
class Holder { 
public: 
    Holder (F v) : f(v) { std::cout << "Start!" << std::endl ; } 
    ~Holder()   { std::cout << "Stop!" << std::endl ; } 
    Holder* operator->() { return this ; } 
    F f ; 
} ; 

template < class F > 
class Timer { 
public: 
    Timer (F v) : f(v) {} 
    Holder<F> operator->() { Holder<F> h(f) ; return h ; } 
    F f ; 
} ; 

int foo (int a, int b) { std::cout << "foo()" << std::endl ; } 

int main() 
{ 
    Timer<int(*)(int,int)> timer(foo) ; 
    timer->f(1,2) ; 
} 

Die Implementierung und die Verwendung sind beide einfach.

Answer 10

Sie können wahrscheinlich eine Antwort finden, wenn Sie die Implementierung der std :: tr1 :: Funktion betrachten, die Sie einschließen.

In C++ 11 ist Std :: Funktion mit Variadic Vorlagen implementiert. Unter Verwendung eines solchen Vorlagen können Sie Ihre Timer-Klasse aussehen

template<typename> 
class Timer; 

template<typename R, typename... T> 
class Timer<R(T...)> 
{ 
    typedef R (*function_type)(T...); 

    function_type function; 
public: 
    Timer(function_type f) 
    { 
     function = f; 
    } 

    R operator() (T&&... a) 
    { 
     // timer starts here 
     R r = function(std::forward<T>(a)...); 
     // timer ends here 
     return r; 
    } 
}; 

float some_function(int x, double y) 
{ 
    return static_cast<float>(static_cast<double>(x) * y); 
} 


Timer<float(int,double)> timed_function(some_function); // create a timed function 

float r = timed_function(3,6.0); // call the timed function 

Answer 11

Eine Lösung Makros und Vorlagen: Sie können beispielsweise

double foo(double i) { printf("foo %f\n",i); return i; } 
double r = WRAP(foo(10.1)); 

Vor und nach dem Aufruf von foo() der Wrapper-Funktionen beginWrap() wickeln wollen und endWrap() sollte aufgerufen werden. (Mit endWrap() eine Template-Funktion.)

void beginWrap() { printf("beginWrap()\n"); } 
template <class T> T endWrap(const T& t) { printf("endWrap()\n"); return t; } 

Das Makro

#define WRAP(f) endWrap((beginWrap(), f)); 

verwendet den Vorrang des Komma-Operator beginWrap() wird zuerst genannt zu gewährleisten. Das Ergebnis von f wird an endWrap() übergeben, das es nur zurückgibt. So ist die Ausgabe:

beginWrap() 
foo 10.100000 
endWrap() 

Und das Ergebnis r enthält 10.1.