C ++: Fonction wrapper qui se comporte comme la fonction elle-même

Fondamentalement, ce que vous voulez faire est impossible dans le courant de C++. Pour un certain nombre d'arité de la fonction que vous souhaitez envelopper, vous avez besoin de surcharger par

const reference
non-const reference

Mais alors c'est pas encore parfaitement forwarding (certains cas limites sont toujours là), mais il devrait fonctionner raisonnable. Si vous vous limitez à const références, vous pouvez aller avec celui-ci (pas testé):

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_;
};

Noter que pour le type de retour, vous pouvez utiliser du coup de pouce des types de fonction de bibliothèque. Puis

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

Vous pouvez aussi surcharger l'aide de la pure valeur des paramètres, et puis si vous voulez passer quelque chose par référence, utilisez boost::ref. C'est en fait une jolie commune de la technique, en particulier lorsque ces paramètres sont sauvegardés (cette technique est également utilisée pour boost::bind):

//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);

Ou vous pouvez aller et ajouter les surcharges pour les deux const et non const versions comme expliqué ci-dessus. Regarder dans Coup de pouce.Préprocesseur pour savoir comment écrire le bon macros.

Vous devez être conscient que tout cela va devenir plus difficile si vous voulez être en mesure de passer arbitraire callables (pas seulement des fonctions), car vous aurez besoin d'un moyen d'obtenir ensuite leur type de résultat (qui n'est pas du tout facile). C++1x, fera de ce genre de choses beaucoup plus facile.

Stroustrup a démontré une fonction wrapper(injaction) compétence avec la surcharge de l' operator->. L'idée clé est: operator-> sera repeatly appelé jusqu'à ce qu'il rencontre un natif de type pointeur, alors laissez - Timer::operator-> retour un temp de l'objet, et la temp de l'objet de retour de son pointeur. Alors la suite va se passer:

1. temp obj créé (ctor).
2. cible de la fonction appelée.
3. temp obj détruits (dtor appelé).

Et vous pouvez injecter le code dans le ctor et la dtor. Comme cette.

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) ;
}

La mise en œuvre et l'utilisation sont à la fois faciles.

Vous vous absentez pour un grand défi si vous cherchez à créer une classe générique qui peut s'enrouler et appel d'une fonction arbitraire. Dans ce cas, vous auriez à faire le foncteur (l'opérateur()) retour double et de prendre un int en paramètre. Ensuite, vous avez créé une famille de classes que l'on peut appeler toutes les fonctions avec la même signature. Dès que vous voulez ajouter d'autres types de fonctions, vous avez besoin de plus foncteurs de cette signature, par exemple

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

template<class Function>
class Timer {

public:

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

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

  }

};

EDIT: Quelques fautes d'orthographe

Si votre compilateur prend en charge variadic macros, je voudrais essayer ceci:

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_); } 

Donc, pour l'utiliser, vous devrez faire cela:

void test_me(int a, float b);

TIME_MACRO(test_me(a,b));

Large que le brassard, et vous auriez besoin de jouer pour obtenir des types de retour au travail (je pense que tu aurais à ajouter un nom de type à la TIME_MACRO appel et puis de générer une variable temp).

Voici comment je le ferais, à l'aide d'un pointeur de fonction au lieu d'un modèle:

//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;
};

Je l'ai changé pour ne pas prendre une référence à la fonction, mais juste un simple pointeur de fonction. L'utilisation reste la même:

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