appel dynamique de fonction avec ou sans argument

Version imprimable

19/01/2017, 16h27
orilion

appel dynamique de fonction avec ou sans argument

Bonjour,

Pour un programme j'ai besoin de créer une classe qui exécute une de ses méthode dans un thread. Cette méthode doit appeler une fonction passé par l'utilisateur à la classe avec un certain temps d'intervalle.

Pour ceux qui on pas compris, ma classe consiste a pratiquement recrée la classe QTimer que je ne peut pas l'utilisé. La seule chose ou je bloque c'est sur cette appel dynamique d'une fonction qui peut avoir des arguments.
19/01/2017, 16h32
ternel

Les arguments, il faut les wrapper dans l'objet-fonction (appelé aussi foncteur).

La classe devrait avoir pour membre un std::function<void(void)>, et l'utilisateur n'a qu'a utiliser une lambda, une classe dédiée, bind, ou toute solution similaire, pour créer un Bidule© appelable.
19/01/2017, 16h58
orilion

Je veux un fonctionnement plus simple pour l'utilisateur. Du même type que pour thread.

Par ternel, peut tu donner un exemple s'il te plais
19/01/2017, 17h21
Bousk

std::thread utilise des variadic template pour ça. Rien ne t'empêche de faire ça via std::thread justement. :calim2:

Salut,

Citation:

Envoyé par orilion

Je veux un fonctionnement plus simple pour l'utilisateur. Du même type que pour thread.

Par ternel, peut tu donner un exemple s'il te plais

Un foncteur est une structure qui n'expose qu'un seul comportement (hormis celui d'être constructible) : l'opérateur (), qui est utilisé pour l'appel de fonction.

En simplifiant au maximum, un foncteur aura toujours une tronche proche de
Code:

1 2 3 struct MonFoncteur{ TypeDeRetour operator()(/* paramètres éventuels à fournir lors de l'appel */) const; };
et sera toujours utilisé sous une forme proche de
Code:

1 2 3 4 int main(){ MonFoncteur f; f(/* arguments nécessaires*//); }
A partir de là, tu peux à peu près tout faire :

Si la fonction appelante dispose de données qui devront être transmises lors de l'appel, tu peux décider de fournir autant de paramètres que tu veux à ton opérateur (), exactement comme tu le ferais pour n'importe quelle autre fonction, par exemple, sous une forme proche de
Code:

1 2 3 4 5 6 7 8 9 /* ce foncteur permettra de trier les personnes en fonction de leur nom puis en fonction de leur prénom */ struct LessByNameThenFirstName{ /* les opérateurs de comparaisons renvoient toujours un booléen */ bool operator()(Personne const & a, Personne const & b) const{ return a.nom() < b.nom() || // OK pour "Alcazar" et "Dupond" (a.nom() == b.nom() && a.prenom() < b.prenom()) ; // OK pour Durand Albert et Durant Josephine } };
Mais, si, pour une raison ou une autre, la fonction qui devra se charger de faire appel à l'opérateur () devait ne pas disposer des données qui doivent être utilisées comme argument, tu pourrais toujours envisager quelque chose comme
Code:

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 /* Le même avec plusieurs fonctions... * considérons que celles qui doit effectivement faire appel à l'opérateur() ne connaisse pas les personnes en question */ struct LessByNameThenFirstName{ LessByNameThenFirstName(Personne const & a, Personne const & b): a_{a},b_{b}{} Personne /* const & */ a_; Personne /* const & */ b_; /* les opérateurs de comparaisons renvoient toujours un booléen * Il n'y a plus besoin de fournir les personnes en paramètre, vu qu'on les connait * déjà (en tant que données membres */ bool operator()() const{ return a_.nom() < b_.nom() || /* OK pour "Alcazar" et "Dupond" (a_.nom() == b_.nom() && a_.prenom() < b_.prenom()) ; // OK pour Durand Albert et Durant Josephine } }; void foo(LessByNameThenFirstName const & functor){ /* ... */ if(functor() ) { /* ... */ } } int main(){ Personne a; Personne b; /* nous pouvons instancier notre foncteur comme n'importe quel autre structure classique */ LessByNameThenFirstName functor{a,b}; /* puis nous pouvons l'utiliser comme n'importe variable, par exemple, en le transmettant à foo */ foo(functor)); return 0; }
pour std::bind, le mieux est sans doute encore de suivre la doc... C'est particulièrement long et fastidieux à expliquer ;)

Les expressions lambda poursuivent le même objectif que les foncteurs, mais avec un écriture simplifiée. Elle prennent généralement la forme de
Code:

1 2 3 [<capture du contexte>](<capture de variable>){ /* ce qui doit être effectué*/ }
Pour reprendre le même exemple, nous pourrions envisager de trier un tableau de personnes à l'aide de la fonction std::sort. Si notre but est de trier ces personnes d'abord par leur nom et ensuite par leur prénom, le code ressemblerait à
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int main(){ std::vector<Personne> tab; /* il est rempli d'une manière ou d'une autre*/ std::sort(tab.begin(), tab.end(), [/* y a pas de contexte à capturer*/] ( Personne const & a, Personne const & b /* on compare les personnes deux à deux*/){ // ce qui doit être fait : on a déjà vu cette logique ;) return a.nom() < b.nom() || (a.nom() == b.nom() && a.prenom() < b.prenom()); }); /* le tableau est maintenant trié selon nos souhaits */ }
L'avantage, c'est que ce genre d'expression lambda peut être utilisé là où on s'attend à recevoir un paramètre de type std::function (tu devrais t'y intéresser ;) )

PS : oui, tous les liens sont en anglais... j'aurais pu les donner en francais, mais, comme la plupart des ressources concernant le développement sont en anglais, autant t'y habituer rapidement :D

19/01/2017, 18h10
orilion

La classe utilise thread pour exécuté une méthode run.

Dans cette méthode run, il y a ce qui faut pou exécute en boucle certaine instruction avec intervalle de temps que l'utilisateur rentre quand il crée la classe.

Appelé un thread dans un autre juste pour faire sa n'est pas correcte.

J'ai donc deux problème :
- comment je stock les "Args...args" de mon template dans ma classe
- comment j'appel ma fonction avec ses arguments.

Ps: même dans la littérature anglaise je n'arrive pas a trouvé ces réponses.
19/01/2017, 22h02
Bousk

Pourrait-on avoir enfin un peu de code ?
Ce que tu demandes à faire est plutôt commun je ne vois pas ce qui te bloques.

Citation:

Envoyé par orilion

J'ai donc deux problème :
- comment je stock les "Args...args" de mon template dans ma classe
- comment j'appel ma fonction avec ses arguments..

Les 2 problèmes se solutionnent avec std::function et une lambda.
Code:

1 2 3 4 5 6 7 8 template<class F, class... T> void foo(F && f, T && ... args) { std::function<void()> func([f = std::forward<F>(f), args = std::forward<T>(args)...]{ // c++14. simplement `[=]` si on se fiche du perfect forwarding f(args...); }); func(); }

Dans l'état actuelle il ne compile pas, par contre on enlève le template et je qui va avec, la fonction qu'on met en dure sera exécuté sur un intervalle de temps qu'on veux.

C'est du c++11

- timer.h :

Code:

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
 
#ifndef TIMER_H
#define TIMER_H
 
#include <atomic>
#include <thread>
#include <chrono>
#include <iostream>
#include <list>
 
using namespace std;
 
class Timer {
private:
    std::atomic_bool done_ {};
    thread worker_{};
    chrono::milliseconds time;
    void run_();
    Fn** fn; //Fonction à exécuté
    Args** args; // Argument de la fonction
public:
   template <class Fn, class... Args>
    Timer(chrono::milliseconds time, Fn&& fn, Args&&... args);
    ~Timer();
};
 
#endif // TIMER_H

- timer.cpp :

Code:

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
 
#include "timer.h"
 
template <class Fn, class... Args>
Timer::Timer(chrono::milliseconds time,Fn&& fn, Args&&... args){
    this->time = time;
    this->fn = fn;
    this->args = args;
    worker_ = thread(&Timer::run_,this);
}
 
void Timer::run_(){
    while(!this->done_.load()){
        //fonction a exécuté
        this_thread::sleep_for(time);
    }
}
 
Timer::~Timer(){
    done_.store(true);
    if(worker_.joinable())
        worker_.join();
    else
       cout << "thread termined" << endl;
 
}

Un moment donné il faudrait lire et essayer de comprendre ce qu'on te raconte, sinon préviens-nous qu'on perd du temps. :calim2:
Il t'a été dit 100 fois d'utiliser une lambda et std::function, et tu nous inventes des syntaxes... sans compter l'écriture d'une implémentation de template dans un cpp... Peut-être que revoir un peu les bases ne ferait pas de mal. :weird:
Code:

1 2 3 4 5 6 template< class Fn, class... Args> class Toto { std::function<void(void)> mFunc; public: Toto(Fn&& fn, Args&&... args) : mFunc([]() { Fn(args...); }) {} void AppelleCaRunSiCaTamuse() { while(!done) { mFunc(); } }
Si ton utilisateur est assez intelligent pour savoir ce qu'est une lambda et en fournir une lui-même tu peux te contenter de
Code:

1 2 3 4 5 class Toto { std::function<void(void)> mFunc; public: Toto(std::function<void(void)> func) : mFunc(func) {} void AppelleCaRunSiCaTamuse() { while(!done) { mFunc(); } }
Ou directement plus proche de ton truc
Code:

1 2 3 worker_ = thread([this]() { run(); }); ... void Toto::run(std::function<void(void)> func) { ... func(); ... }
A la louche.