Discussion :

[LinuxUser]

Je suis malheureusement contraint à resté en C++98 standard et sans possiblité d'utiliser de lib externe (donc pas de boost).

Du coup, l'idée du wrapper C-like (qui a été suggéré deux fois) consiste en quoi exactement?

A avoir d'un côté une fonction qui prend une fonction en paramètre (de type void * func(double)) et de l'autre un wrapper qui convertir une méthode membre de type void C::func(double) en void *func(double) ?

[Ehonn]

Je suis malheureusement contraint à resté en C++98 standard et sans possiblité d'utiliser de lib externe (donc pas de boost).

Regarde mon exemple (message #11) avec std::bind1st et std::mem_fun, ce n'est que du C++98

[Bousk]

Franchement je commence à avoir des doutes sur tes recherches. Voire sur la lecture des messages parfois.

Un foncteur, ça n'a rien de magique, et on en écrit depuis très longtemps. Inutile d'avoir du C++11 14 ou plus pour en écrire un.
Cas simple pour un foncteur qui ne prend pas de paramètre. A la louche de mémoire ça donne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
struct Callback
{
  virtual ~Callback() {}
  virtual void Call()=0;
  virtual void operator()()=0;
};
struct FreeCallback : Callback
{
  typedef void(*func)();
  FreeCallback(func _func) : ptr(_func) {}
  void Call() { (*ptr)(); }
  void operator()() { (*ptr)(); }
 private:
  func ptr;
};
template< class T >
struct MemberCallback : Callback
{
  typedef void(T::*ptrFct)(void);
  MemberCallback(T* object, ptrFct method) : m_obj(object), m_method(method) {}
  void Call() { m_obj->m_method(); }
  void operator()(void) { m_obj->m_method(); }
 
 private:
  T* m_obj;
  ptrFct m_method;
};

La seule chose qui est (beaucoup) mieux avec le code plus récent, c'est que les template permettent de factoriser l'écriture et te font les copier coller à ta place selon le type de retour, de chaque paramètre, du nombre de paramètre, ....
Là tu dois le faire toi-même.