Passer une fonction en paramètre

**PilloBuenaGente** · 12/12/2013, 17h43

Bonjour à vous !

Suite à ce post et à l'aide de celui-ci, j'ai souhaité améliorer la simplicité d'ajout de nouvelles "pages" à mon programme.

Page.h

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
30
31
32
33
34
35
36
#include <vector>
#include <string>
#include <functional>
#include "Model.h"
 
class Page
{
//Définit le type à stocker
    enum CallType
    {
        INFO,
        ACTION
    };
//Pour stocker à la fois la fonction et sa définition
    struct TxtAndFun
    {
        TxtAndFun( const std::string& txt, std::function< void() > fun ) : txt( txt ), fun( fun ) {}
        std::string txt;
        std::function< void() > fun;
    };
 
public:
    virtual ~Page() {}
    void display();
    void work();
//Ajouter une fonction ou simplement une information
protected:
    void add( const std::string& txt, std::function< void() > fun );
    void add( const std::string& txt );
 
private:
    std::vector< TxtAndFun >   actions_;
    std::vector< std::string >  infos_;
//Pour garder l'ordre des informations entrées
    std::vector< CallType > call_order_;
};

PageSummary.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include "Page.h"
//Creation d'une nouvelle page
class Summary : public Page
{
public:
    Summary( Model& model )
    {
        add( "Titre" );
        add( "Make Job", std::bind( &Model::change_page, &model, PageType::MAKE_JOB ));
        add( "Quit", std::bind( &Model::prog_quit, &model ));
    }
};

J'ai pour but de n'avoir pas à me préoccuper de la réponse attendue par l'utilisateur. Ce qui permettrait de changer l'interface en modifiant seulement l'ordre de mes fonctions "add".

Console

Code :

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

1
2
3
Titre
1 - Make Job
0 - Quit

Ceci fonctionne bien, cependant je n'arrive pas a passer directement une fonction en paramètre pour la "binder" dans la classe Page.

Je suis contraint de le faire avant de l'envoyer en paramètre. Ni aurait t'il pas un moyen d'avoir simplement ce qui suis en fonction ?

Code :

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

1
2
3
4
5
6
7
8
9
10
class Summary : public Page
{
public:
    Summary( Model& model )
    {
        add( "Titre" );
        add( "Add Job", model.change_page( PageType::ADD_JOB ));
        add( "Quit", model.prog_quit );
    }
};

De plus je ne comprends pas bien le fait de devoir écrire "&Model::change_page, &model" pour enregistrer cette fonction "model.prog_quit()" (Que j'ai obtenue en tâtonnant

)

Merci d'avance.

**Médinoc** · 12/12/2013, 18h54

C'est une fonction membre que tu bindes ici.
Pour pouvoir l'appeler sans lui re-passer un "this" à chaque fois, il faut le mémoriser avec dans le binding.

**Iradrille** · 12/12/2013, 19h06

Envoyé par PilloBuenaGente

De plus je ne comprends pas bien le fait de devoir écrire "&Model::change_page, &model" pour enregistrer cette fonction "model.prog_quit()" (Que j'ai obtenue en tâtonnant

)

Merci d'avance.

Hello,

Tu as plusieurs possibilités, soit un std::bind (boost::bind si pas de C++11), soit passer une lambda, soit un foncteur (plus lourd à déclarer mais en général plus facilement réutilisable)

Code :

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

1
2
add( "Make Job", std::bind( &Model::change_page, &model, PageType::MAKE_JOB ));
add( "Make Job", [&model]() { model.change_page(PageType::MAKE_JOB));

un std::function est l'équivalent d'un foncteur : un pointeur de fonction avec un contexte

Code :

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

std::bind( &Model::change_page, &model, PageType::MAKE_JOB )

Tu stockes des fonctions de prenant aucun paramètres, std::bind permet de prendre une fonction, de fixer un contexte et retourne un std::function.
Ici tu fixes deux les paramètres de change_page : this et un paramètre de type PageType.
std::bind te retourne ici un objet utilisable comme une fonction libre ne prenant aucun argument.

Une fonction membre est identique à une fonction libre, elle prend juste this en premier paramètre, mais c'est caché par la syntaxe.

Code :

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

1
2
3
obj.foo();
// est équivalent à 
foo(obj);

(La convention d'appel est différente, et il est interdit de remplacer l'un par l'autre directement, mais dans le fond, c'est équivalent).

**Flob90** · 12/12/2013, 19h10

Non, certain langages, Haskell par exemple, permette ce que tu veux faire, mais en C++ le plus simple et proche de ce que tu veux que tu pourras avoir est d'utiliser une lambda, C++11 donc (ou boost.phoenix en C++03 mais ça reste lourd en un sens).

**Neckara** · 13/12/2013, 06h48

Bonjour,

J'ai moi aussi implémenté un système de "page" dans un de mes projets.

En gros chaque "page" détermine la manière dont les événements seront traités et l'affichage sur l'écran.

Je ne sais pas si utiliser/binder un langage de script pourrait te simplifier la tâche.

Par exemple, j'ai un code en Lua qui est appelé par mon programme C++ et qui détermine ce qui doit être fait lors d'événements :
ex : "entrer" (quand on "entre" dans la page), "quit", "draw" (quand on souhaite dessiner la page, etc...

Ceci m'évite d'avoir un nombre très important de pointeurs sur fonctions ou d'avoir de multiples classes pour les pages.

**PilloBuenaGente** · 13/02/2014, 18h34

Merci à vous !

Lua n'aurait pas tendance à compliquer les choses pour un petit projet ?

Les lambdas semblent correspondre à mes besoins.

Je ne sais pas si cette portion est aux normes, mais elle semble faciliter la conception des pages.

Program.h

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include "Page.cpp"
 
enum Id : char//Nom des pages
{
    SUMMARY,
    NEW_JOB,
    NEW_INTERIM
};
 
void Program::load( const char id )//Lancer une page
{
    Page< Data > p( data_ );//Déclaration d'une nouvelle page
 
    switch( id )//Afficher la page et enregistrer les liens
    {
    case SUMMARY:
        p.title( "Summary" );//Créer une entête pour le titre
        p.link( []( Data& data )->void{ data.page_id_ = NEW_JOB; }, "1", "New worked day" );//Executer la fonction avec l'entrée "1"
        p.last_line();//Ecrire sur la dernière ligne
        p.link( []( Data& data )->void{ data.program_run_ = false; }, "0", "Quit" );
        break;
 
    case NEW_JOB:
        p.title( "New Job" );
        p.print( "Enter job's name" );
        p.last_line();
        p.link( []( Data& data )->void{ data.page_id_ = SUMMARY; }, "0", "Summary" );
        p.shift( 20 );
        p.link( []( Data& data )->void{ data.program_run_= false; }, "00", "Quit" );
        p.name( []( Data& data )->void{ data.temp_name = data.input_; data.page_id_ = NEW_INTERIM; } );//Si l'on saisi un nom
        break;
 
    case NEW_Date:
        p.title( "New Date" );
        p.print( "Enter date worked with", data_.temp_name );
        p.last_line();
        p.link( []( Data& data )->void{ data.page_id_ = SUMMARY; }, "0", "Summary" );
    }
 
    p.execute( data_.input_ );//Executer le lien choisi
}
 
void Program::execute()
{
    data_.program_run_ = true;
    data_.page_id_ = Id::SUMMARY;
 
    while( data_.program_run_ )
    {
        load( data_.page_id_ );
    }
}

Passer une fonction en paramètre

Langage C++

Discussions similaires

Partager

Partager