Discussion :

[3dsman]

Bonjour a tous!

Je suis entrain de développer une librairie d'interface graphique opengl opensource (https://github.com/3dsman/snice_ui) qui avance bien mais je viens de tomber sur un problème que je n'avais pas anticipé dans mon architecture...

En gros quand je rée un bouton par exemple je peut créer une fonction de callback pour exécuter différentes actions (ici je me contente d'afficher le bouton enfoncé):

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
 
// fonction de callback du bouton
void test(W_button* caller)
{
    caller->SetPressed(true);
    std::cout<<"le bouton a été appuyé";
};
 
int main(int argc, char *argv[])
{
    // creation de la fenetre avec un viewport par default
    pSnice_UI = new Snice_UI(800,600,50);
 
    // recuperaion du viewport
    pViewport = pSnice_UI->GetViewport();
 
    // creation d'un bouton
    pValid = new W_button(200,100, 120,20, "COOL");
 
    // attache du bouton au viewport
    pViewport->AddChild(pValid);
 
    //signalisation de la fonction de callback
    pValid->OnClick(test);
 
    [...]
}

Dans la classe W_button j'ai (en version tres tres epurée ):

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
 
class W_button : public UI_widget
{
protected
  void (*onClick)(W_button* caller) = NULL;
 
public:
void W_button::OnClick(void (*function)(W_button* caller))
{
    onClick = function;
}
 
UI_base* W_button::OnLButtonUp(int x, int y)
{
        if (Hittest(x,y))
        {
            if(onClick) onClick(this);
        }
    return 0;
}
}

Tout ca marche tres bien dans le ca ou je crée tous les boutons a la main mais j'aimerais bieen maintenant avoir des dialog boxes (un widget de texte et deux boutons par exemple).
Le probleme c'est que mes fonctions de callback ne pointent pas sur des fonctions de classe.
Je ne peut donc pas par exemple avoir une classe D_toto qui aurait une fonction test pour recuperer le callback du bouton...

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
 
void D_toto::D_toto()
{
    // creation d'un bouton
    pValid = new W_button(200,100, 120,20, "COOL");
 
    // attache du bouton a ma dialogbox
    AddChild(pValid);
 
    //signalisation de la fonction de callback
    pValid->OnClick(this->test);
}
 
void D_toto::test(W_button* caller)
{
    caller->SetPressed(true);
    std::cout<<"le bouton a été appuyé";
};

Je vois bien que j'ai fait une erreur d'architecture mais je ne vois pas de solution pour contourner le problème...
Comment ca se fait ce genre de trucs en général?

Merci d'avance de vos réponses.

[Senaku-seishin]

Utilise de préférence la std (http://fr.cppreference.com/w/cpp/uti...ional/function et https://isocpp.org/wiki/faq/pointers-to-members)

[3dsman]

Je ne vois pas trop ce que ca changerais dans mon cas.
Pourrais tu m'indiquer comment l'utiliser ici stp?

Dans tous les cas une fonction membre devra etre stockée dans un autre variable non?
std::function<void(const D_toto&, int)> onClick = &D_toto::OnClick;

Par contre je viens de voir dans un de tes liens l'utilisation de fonctions statiques avec un handler sur l'objet appelé:
https://isocpp.org/wiki/faq/pointers...fnptr-vs-fnptr

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
28
29
 
class D_toto : public UI_dialog
{
protected
    void OnBtnClick(W_button* caller);
    W_button pValid;
    static D_toto* handler;
public:
    static void OnBtnClickStat(W_button* caller);
}
 
void D_toto::D_toto()
{
    // creation d'un bouton
    pValid = new W_button(200,100, 120,20, "COOL");
 
    // attache du bouton a ma dialogbox
    AddChild(pValid);
 
    //signalisation de la fonction de callback
    pValid->OnClick(OnBtnClickStat);
}
 
void OnBtnClickStat(W_button* caller)
{
    // on verifie que le handler est bien remplis
    if (D_toto::handler)
        D_toto::handler->OnBtnClick(W_button* caller);
}

Sachant que je peut remplir le handler avec un pointeur sur l'objet courant (ma boite de dialogue) ca peut le faire non?

[jo_link_noir]

std::function est une classe générique qui prend n'importe quoi qui possède operator(): lambda, fonction, foncteur.
std::mem_fn est une fonction qui retourne un foncteur pour appeler une fonction membre.

Donc le type de caller devient std::function<void(W_button*)>.

Et pValid->OnClick(this->test); devient pValid->OnClick([this](W_button*){ this->test(); });.

[Senaku-seishin]

Utiliser la std est préférable car elle apporte des sécurités notamment l'exception bad_function_call. Disons que c'est plus orienté c++, c'est comme pour le cast des types. On privilégiera l'utilisation de static_cast au lieu du cast c.

Dans tous les cas une fonction membre devra etre stockée dans un autre variable non?
std::function<void(const D_toto&, int)> onClick = &D_toto::OnClick;

Tu peux utiliser le type std::function<void(const D_toto&, int)> dans l'argument.
Bien évidement dans tous les cas il y aura copie de pointeur. Je te rappelle que le c++ passe par défaut les arguments par copie.

Par contre je viens de voir dans un de tes liens l'utilisation de fonctions statiques avec un handler sur l'objet appelé:

C'est sûrement pas la meilleur solution dans ton cas... Relis les liens.

[3dsman]

La vache, je suis un peu largué :p

Quand je remplace mon pValid->OnClick(this->test); par pValid->OnClick([this]{ this->test(); }); j'ai une erreur de "no matching function for call to test()" ce qui me semble logique puisque la fonction test est declarée avec un argument:
void D_toto::test(W_button* caller)

Si je met plutot pValid->OnClick([this]{ this->test(W_button* caller); }); alors je me prends une erreur "expected primary-expresion before '*' token"

La je pige plus trop le concept

[ternel]

[this]{ this->test(); } est une expression, dont la valeur est une lambda qui prend this en référence dans son contexte de déclaration, n'a pas d'argument, et dont l'exécution consiste à l'évaluation de l'expression this->test().
C'est en gros un pointeur de fonction.

Si test est une fonction libre (non membre, donc), c'est probablement qu'il faut utiliser [this]{ test(*this); } ou [this]{ test(this); }. éventuellement, il faut rectifier la fonction.
Si elle attend un argument autre que le fameux this, il faut trouver la valeur à lui donner.

[3dsman]

Ben justement le truc c'est que ça peut être une fonction membre ou pas...

Je suis de plus en plus largué

[oodini]

Le principal, c'est de renvoyer un foncteur, c'est à dire une l'instance d'une classe proposant l'opérateur ().

[3dsman]

Je cherche a passer a un objet une fonction qui as des paramètres pour que l'objet puisse l'invoquer le cas echeant (c'est l'objet qui connais les parametres avec lesquel l'invoquer).
Le problème c'est que la fonction a passer peut etre une fonction libre ou une fonction membre.
libre dans le cas ou c'est l'utilisateur de ma lib qui l’écrit (il crée une instance de l'objet et lui passe la fonction de callback en paramètre) et membre dans le cas ou c'est un autre objet (une fenêtre de dialogue par exemple) qui crée cette instance de l'objet (un bouton dans la fenêtre par exemple)

[ternel]

Alors il faut faire deux fonctions.

[3dsman]

Et l'option fonctions statiques avec handler sur l'objet appelé du coup? non?
https://isocpp.org/wiki/faq/pointers...fnptr-vs-fnptr

[Senaku-seishin]

Et l'option fonctions statiques avec handler sur l'objet appelé du coup? non?

Don’t.

Il vaut mieux un exemple que un long discour de comment utiliser les callbacks en c++
http://pastebin.archlinux.fr/993723

[3dsman]

Dans cet exemple la classe Button a besoin de savoir que le callback doit etre transmis a un widget

Dans mon cas il faudrait ajouter une troisieme classe "dialog" qui créerais une instance de Button et lui donnerait une fonction membre de dialog comme fonction de callback

En fait mon problème ressemble a ça:
http://pastebin.archlinux.fr/993864

[Senaku-seishin]

Ton code n'a ni queue ni tête… Et je ne comprend pas ton problème.

[koala01]

Salut,

Rien qu'à voir les première lignes de ton code à savoir

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class W_button
{
    void (*onClick)(W_button* caller) = NULL;
 
    void W_button::OnClick(void (*function)(W_button* caller))
    {
        onClick = function;
    }
 
    W_button::call()
    {
        if(onClick) onClick(this);
    }
}

je me dis que tu devrais peut-être t'intéresser à la bibliothèque boost::signals2. Cette bibliothèque est en effet spécialement prévue pour générer un système de signaux (comprend: un moyen de dire "Il m'est arrivé quelque chose") et de slots (comprend un moyen de dire "Dis moi ce qui t'arrive, mon petit") qui sera beaucoup (mais alors beaucoup) plus simple pour toi à utiliser.

Car, tel qu'il est là, ton bouton ne pourra signaler qu'à un seul élément qu'il lui est arrivé quelque chose. C'est parfois suffisant, mais... Que se passera-t-il lorsque deux éléments voudront être tenus au courent

boost::signals2 fournit un tas de fonctionnalités connexes qui te seront sans doute utiles à un moment ou à un autre et, comme boost fait souvent figure de précurseur de ce que pourrait être "la prochaine norme", elle entre de toutes manières dans la catégorie des bibliothèques que tout bon développeur C++ devrait avoir en permanence dans "sa boite à outils"

Cette bibliothèque en particulier présente, de plus, un avantage certain : elle est implémentée sous la forme dite "headers only" : "YAKA" s'assurer que les fichiers d'en-tête sont accessibles pour pouvoir l'utiliser (pas besoin de se faire ch...er à trouver "comment effectuer cette p..n d'édition de liens" )

[jo_link_noir]

@3dsman: J'ai oublié le paramètre (j'ai édité).
Pour avoir plus d'explication sur les lambdas: http://en.cppreference.com/w/cpp/language/lambda.

+1 pour boost.signal2