Voila. Je cherche à faire un truc simple (pour ensuite l'intégrer dans un truc plus gros) :
 
Appeler une méthode C++ en C. J'ai trouvé un truc qui le fait. Mais ca correspond pas à ce dont j'ai besoin. Puisque le prototype en C est figé (pointeur de fonction utilisant une callback dans Win32).
 
Voici un exemple de code qui marche pas :
 
class tstCPP {
public:
 inline tstCPP() {}
 inline ~tstCPP() {}
 
 void setValue(const int i_val);
 
 int getValue(void);
 
private:
 int val;
};
 
void test(int (*i_func)(void)) {
 printf("%d\n",i_func());
}
 
void main(void) {
 tstCPP c1,c2;
 
 c1.setValue(10);
 c2.setValue(23);
 
 test(c1.getValue);
 test(c2.getValue);
}
 
En gros le prototype de la fonction test est figé, et j'aimerai arriver à lui donner qqchose (comme pointeur de fonction) qui corresponde bien à un truc différent suivant l'instance de l'objet...

Désolé pour l'indentation...

Un début de réponse à cette adresse (en anglais) :
 
http://www.mvps.org/windev/cpp/class.html

comprends rien....
c quel prototype est figé????
c'est lequel que tu voudrais changer???
pas claire, ta question...

Désolé?
En fait le type de la fonction C "test" est figé (dans cet example non, mais en fait mon but est de faire des callback pour Windows). Donc j'essaie de passer une méthode en pointeur de fonction.
 
Après diverses recherches, il semble que ce soit impossible, parce qu'en fait le compilateur (tous?) ajoute dans la liste des paramètres "this" pour une méthode C++. En C il est donc impossible de passer cette méthode comme Callback. J'ai lu ca sur plusieurs sites différents...
 
Pour mon pb sous Windows, une solution peut-être d'utiliser la classe CWinApp des MFC. Mais comme je veux pas utiliser les MFC, je vais essayer de me débrouiller autrement... Déjà la classe CWindow (pas MFC je pense) m'aidera bien à rendre du code C++ mélangé avec du C (MeuhMeuhTV) en un meilleur code C++.
 

Les fonctions membres statiques n'ont pas besoin de "this".

Bon, alors sous windows il est impossible qu'une fonction membre soit une callback car elle ne respecte pas la convention d'appel.
 
Sous win, la convention d'appel d'une call back est:
 
type_retour (__stdcall *)( int toto1, etc...)
 
donc le type de retour est celui que tu veux, les arguments sont ceux que tu veux...
 
Ce qu'il est possible de faire, et c'est ce que moi je fais, c'est que tu déclare une fonction externe ( qui a cette convention d'appel ) comme amie de la classe. Et tu passes à cette fonction un pointeur sur l'objet.
Un exemple pour être plus clair:
 
 
//header: toto.h
 
 
class toto
{
//....
    int a;
 
private:
    maFonction1(int i);
    friend void __stdcall myCallBack( void * data, void * ptr );
};
 
// dans le fichier toto.cpp
 
 void __stdcall myCallBack( void * data, void * ptr )
{
//....
    (toto *) ptr->maFonction1(  (toto *) ptr->a );
//....
}
 
 
 
// et dans ton programme principal:
typedef void (__stdcall * CALLBACK_TYPE) ( void * data, void * ptr )
 
void main(void)
{
toto * t;
 
t=new toto();
 
CALLBACK_TYPE callback = tu_te_debrouille_pour_recupperer_laddresse_de_la_callback;
 
callback( NULL, t);
 
}

Et comment tu fais si tu dois utiliser une fonction callback procedure de fenetre (type WndProc)???  
Je veux dire :  
tu fais un createwindow() dans une classe (ex: classe de creation de fenetre), tu dois lui passer le nom d'une fonction callback. Si tu veux que cette callback soit une fonction de cette classe, tu fais comment ???

Pour le WinProc, je dirais
 
class toto {
//...
private :
  friend WNDPROC myCallBack;
//...
}

M'enfin cette solution ne fonctionne pas, puisque dans le cas de Windows, je ne maitrise pas les prototypes des callback !
 
M'enfin il y a une bidouille qui consiste à passer en lParam un pointeur sur l'objet. Et dans ce cas (callback Windows) ca fonctionne !

PS: J'ai testé WNDPROC myCallBack, ca marche po...

> Et comment tu fais si tu dois utiliser une fonction callback procedure de fenetre (type WndProc)???  
 
Dans le cas de cette callback, tu es obligé d'envoyer un message windows (avec les LParam etc...)
 
Normalement, tu as une callback par default, mais tu peux faire un mapping de la tienne...
J'ai pas d'exemple sous la main, mais c sur que ca fonctionne puisque je l'ai deja fais.

moi aussi j'ai ce pb !!
 
mais j'utilise la fonction SetWindowsHookEx();
 
et je peux pas rajouter de parametre suplémentaire en LPARAM