Is there a possibility to make a function wrapper that runs the injected code and returns the same data as the injected function?

Question

I am toying with this idea for a while but cant seem to wrap my head around it.

Basically what I want to do is create a general Timer class that times all the functions that are passed to it. Averaging it when the same function is called multiple times so it has to store it somehow. It should therefore use the function name to store the task and average it when it occurs more than once.

Pseudoish code of what it should look like.

Class FunctionTaks
{
    std::string d_name;
    double d_execution_time;
}

Class Timer
{
    private:
        std::vector<FunctionTask> d_tasks;

    public:
        template <typename Function, typename ReturnType>
        ReturnType time(Function f)
        {
            // check if function f is timed for first time
            // start timer             
            // run function f
            auto r = f.invoke();
            // stop timer  
            // store function name and time, average if more than once
            // return whatever f should return
            return r;
        }

        void report() const;
}

I dont really know how to do this, especially when Function f has a different amount of arguments.

Timer t;

t.time(foo());
t.time(bar());
t.time(foo());

t.report();

I basically have a few core issues.

1. How to let a function wrapper return the same type that the injected code is suppose to return.
2. How to obtain the function name that is being injected.
3. The wrapper should not be limited by arguments passed on to the injected function. How to give the injected function the freedom of arguments.

On the other hand I dont really care about the arguments and return type, the wrapper should simply run the injected function as is and perform some timings and then return whatever the injected function is suppose to return.

Answer 1

With C++11 you can use variable template parameters:

class TimerFoo {
public:
   template <class Foo, class... Args> TimerFoo(Foo foo, Args... args) {
      // ... start timer
      foo(args...);
      // ... stop timer
   }
};

And use e.g.:

TimerFoo tf = TimerFoo(foo, 1, 2, 3);

Ofcourse you need some field in TimerFoo that will store the measured time...

Edit:

To be able to return a value of your function using this approach you could change the above code to:

#include <iostream>

using namespace std;

class TimerFoo {
public:
   template <class Foo, class... Args> auto run(Foo foo, Args... args) -> decltype(foo(args...)) {
      // ... start timer
      auto result = foo(args...);
      // ... stop timer
      return result;
   }
};


int foo(int a, int b) {
   return 2;
}

int main() {
   TimerFoo tf;
   cout << tf.run(foo, 1, 2) << endl; // output: 2
}

Answer 2

C++11 but why templates? You need lambda expressions:

typedef void(*TimerFunction)();

void time(TimerFunction fun) {
    // start timer
    fun();
    // stop timer
}

int fun1() { return 1; }

int fun2() { return 2; }

string fun3() { return string("Test"); }

main() {
    int ret1, ret2;
    string ret3;
    t.time([&ret1]() { ret1 = fun1(); });
    t.time([&ret2]() { ret2 = fun2(); });
    t.time([&ret3]() { ret3 = fun3(); });

}

That's the concept. For details: C++ lambda with captures as a function pointer