Passer un méthode en paramètre d'une autre méthode

Bonjour à toutes et à tous,

Les pointeurs en C++ : ça me traumatise :?

Je voudrais passer en paramètre d'une méthode una autre méthode. Je n'arrive pas à imaginer la syntaxe à employer.

Soit le code suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

void a() {} void b() {}   void c(// Qu'écrire ici pour utiliser a ou b) { // Qu'écrire ici pour que a ou b soit exécutée; }   ...   // appel de c pour utiliser a ou b   c(// Qu'écrire ici pour utiliser a); c(// Qu'écrire ici pour utiliser b);

---

Je suppose que a et b doivent avoir le même prototype.

Merci pour votre aide.

Pierre

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

void a() {} void b() {}   // Grosso modo void c(std::function<void()> f) { f(); }   ...   // appel de c pour utiliser a ou b   c(&a); c(&b);

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

void a() {} void b() {}   void c(void (*f)()) { f(); }   ...   // appel de c pour utiliser a ou b   c(&a); c(&b);

---

Bonjour,

Laisse le compilateur te déterminer les types :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

template<class F> void foo(F&& fun) { //ici tu utilises fun comme une fonction : fun(0,1); }   void bar(int,int){}   //Pour passer bar à foo : foo(bar);

---

C++11, en C++03 enlève juste la &&.

Si tu n'as pas C++11, seule la seconde solution marche, mais pour elle je conseille d'y ajouter un typedef pour manipuler le pointeur de fonction plus facilement:

Code:

---

1 2 3 4 5

typedef void (*void_func_ptr)();   void c(void_func_ptr f) { f(); }

---

Note que cela marche pour les fonctions libres, ou les fonctions statiques d'une classe. Pour les fonctions membres non-statiques, c'est plus compliqué et je ne me souviens jamais de la syntaxe appropriée par cœur, obligé de chercher sur le net à chaque fois.

Merci beaucoup the Hound

Gela se compile très bien.

Maintenant, je mets des variables dans a et b tel que :

Code:

---

1 2 3 4 5 6

void a(int x) {} void b(int x) {}   void c(void (*f)(int x)) { f(x); }

---

mais j'obtiens une erreur :

error: 'x' was not declared in this scope

Désolé, je suis vraiment lourd.

Cordialement.

Pierre

Citation:

---

Envoyé par Médinoc

Pour les fonctions membres non-statiques, c'est plus compliqué et je ne me souviens jamais de la syntaxe appropriée par cœur, obligé de chercher sur le net à chaque fois.

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class T { public: void toto(int); };   void foo(void (T::*f)(int)) { T instance; (instance.*f)(42); // Pas sûr de mon coup }   foo(&T::toto);

---

Citation:

---

Envoyé par ChPr

mais j'obtiens une erreur :

error: 'x' was not declared in this scope

---

C'est parce que ... tu n'as pas déclaré de x.
Dans void c(void (*f)(int x)), le nom x est donné à titre indicatif mais le compilo n'y prête aucune attention.
Tout ce qu'il sait et a besoin de savoir c'est que f renvoie void et prend un int.
La seule variable qui est déclarée dans ta fonction c'est donc f, x n'existe pas.

Il faut donc que j'écrive quelque chose dans le genre :

Code:

---

1 2 3 4 5 6 7 8

void a(int x) { } void b(int x) { }   void c(int v, void (*f)(int x)) { f(v); }

---

v sera la valeur passée aux fonctions a ou b ?

(je commence à y voir un peu plus clair, mais qu'est ce que j'ai du mal avec la syntaxe du C :( . Faut que je m'y mette)

Cordialement.

Pierre

Oui, c'est exactement ça.

Bonjour,

Citation:

---

Envoyé par Flob90

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

template<class F> void foo(F&& fun) { //ici tu utilises fun comme une fonction : fun(0,1); }   void bar(int,int){}   //Pour passer bar à foo : foo(bar);

---

---

Pourquoi utiliser la move semantic et pas une référence ?

Citation:

---

Envoyé par Neckara

Pourquoi utiliser la move semantic et pas une référence ?

---

J'imagine que ça permet d'utiliser des foncteurs créés temporairement.
Remarque au passage, la solution à base de template ne peut fonctionner que si l'appel de fonction se fait dans la même unité de compilation que celle où le template est défini.

Citation:

---

Envoyé par the Hound

J'imagine que ça permet d'utiliser des foncteurs créés temporairement.

---

Le problème c'est qu'on ne pourra pas utiliser une std::function plusieurs fois.

Est-ce qu'une référence constante ne marche pas pour les objets temporaires ?

Citation:

---

Envoyé par the Hound

Remarque au passage, la solution à base de template ne peut fonctionner que si l'appel de fonction se fait dans la même unité de compilation que celle où le template est défini.

---

J'ai du mal à voir le souci. Peux-tu donner un exemple où cela ne fonctionne pas ?

Citation:

---

Envoyé par Neckara

Est-ce qu'une référence constante ne marche pas pour les objets temporaires ?

---

Si, mais une référence sur membre constant t'interdit d'utiliser un foncteur avec l'opérateur () non const.
Dans ce cas, il faut la move semantique ou faire une copie.

Citation:

---

Envoyé par Ehonn

Si, mais une référence sur membre constant t'interdit d'utiliser un foncteur avec l'opérateur () const.

---

Tu ne veux pas plutôt dire qu'il interdit d'utiliser : operator(); vu qu'il attend un operator() const; ?

Mais dans ce cas, là, pourquoi passer par la move semantic (C++11) des foncteurs alors qu'en C++11 on utilise des std::function ?

Citation:

---

Envoyé par Neckara

Tu ne veux pas plutôt dire qu'il interdit d'utiliser : operator(); vu qu'il attend un operator() const; ?

---

Déjà corrigé avant ton message ;)

Les foncteurs ne sont-ils pas généralement passés par valeur, dans la STL?

Avec la solution template, on pourra passer une lvalue car le template sera remplacé par T &.
Et du coup, le compilateur passera une sorte de T & && (en pratique il passera T &) et il n'y aura pas de véritable déplacement. (Je veux bien de vrais explications là-dessus :))

Voici un exemple :

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 34 35

// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main   #include <iostream> #include <type_traits>     class A { public:   void operator()() { std::cout << "A::()()" << std::endl; } };   template <class func_t> void call(func_t && f) { std::cout << "func_t is a & = " << std::is_reference<func_t>::value << std::endl; std::cout << "func_t is a && = " << std::is_rvalue_reference<func_t>::value << std::endl; std::cout << " f is a & = " << std::is_reference<decltype(f)>::value << std::endl; std::cout << " f is a && = " << std::is_rvalue_reference<decltype(f)>::value << std::endl; f(); }     int main() { A a; call(a); std::cout << std::endl;   call(A()); std::cout << std::endl;   return 0; }

---

Et voici la sortie :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

$ g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main func_t is a & = 1 func_t is a && = 0 f is a & = 1 f is a && = 0 A::()()   func_t is a & = 0 func_t is a && = 0 f is a & = 1 f is a && = 1 A::()()

---

Si on n'avait pas de template mais directement ce code là :

Code:

---

1 2 3 4 5 6

void call(A && f) { std::cout << "& = " << std::is_reference<decltype(f)>::value << std::endl; std::cout << "&& = " << std::is_rvalue_reference<decltype(f)>::value << std::endl; f(); }

---

On aurait eu une erreur de compilation car la fonction prend uniquement une rvalue et non une lvalue.

Code:

---

error: cannot bind ‘A’ lvalue to ‘A&&’

---

@Neckara: Avant le C++11 la manière de prendre un foncteur en paramètre c'était par copie, pour permettre la prise de temporaire et de foncteurs non constants. Le C++11 nous apporte de quoi faire la même chose sans payer la copie, je l'utilise.

@The Hound: Je ne comprends pas ce que tu veux dire avec ton histoire d'unité de compilation ? Une fonction template n'est pas nécessairement définit dans une seule unité de compilation. Tu parles de l'appel de quelle fonction ? De la template ou du foncteur que l'on passe ?

@Médinoc: Ça dépend des éléments, la partie algorithme de la bibliothèque standard utilise des passages par copie, mais bind/thread utilise ce que je propose. Je ne sais pas si le passage par copie dans les algorithmes a été conservé pour des raisons propres ou juste pour éviter de les modifier.

@Ehonn: C'est le fonctionnement de la déduction des paramètres template. Quand tu as template<class T> void foo(T&&); lors d'un appel foo(i) un ensemble de règles conduit à la déduction du type T dans ce cas la présence de && conduit à :

• T=decltype(a)& si a est une lvalue, l'appel est donc foo<decltype(a)&>(i);.
• T=decltype(a) si a est une rvalue, l'appel est donc foo<decltype(a)>(i);.

Ensuite une dernière règle entre en jeux. Il est interdit de former des références de références, mais quand cella se produit dans ce cas (c'est plus général, ça inclut la situation où ça se produirait avec typedef ou decltype aussi), alors :

• T rq & = T&
• T rq && = T rq

où rq est soit & soit &&. On obtient donc :

• void foo(declatyp(a)&); si a est une lvalue.
• void foo(decltype(a)&&); si a est une rvalue.

(Normes : 8.3.2 et 14.8.2.1)