Creation d'un std::function

Bonjour,

J'aurais aime savoir pourquoi nous n'avons pas a notre disposition une fonction std::make_function a l'effigie de std::make_shared, std::make_pair ou encore std::make_tuple (pas sur pour ce dernier).

Merci d'avance!

Bonjour,
Je ne sais pas précisément ce que vous voulez faire, mais je pence que std::bind devrais répondre a vos besoin. (ou les expressions lambda)

Imaginons le code suivante :

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

#include <functional> #include <iostream>   template<typename Res, typename... Args> void foo(const std::function<Res(Args...)> &f) { /* Some code */ }   struct A { void bar() {} };   int main() {   //foo( []() {std::cout << std::endl;} );   std::function<void()> f = []() {std::cout << std::endl;}; foo( f );         A a; //foo( std::bind(&A::bar, &a) );   std::function<void()> g = std::bind(&A::bar, &a); foo(g);   return 0; }

---

Les deux commentaires provoquent une erreur de compil, alors qu'en passant par des fonctions temporaire pas de soucis en utilisant les même mécanisme (lambda et std::bind).

Je ne vais pas grappiller sur çà :aie: c'est surtout une question de reflexion!

Bonsoir,

Prenons le problème sous un autre angle :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include<iostream> #include<functional>   struct Func { void operator()(int) const { std::cout << 0; } void operator()(int,int) const { std::cout << 1; } };   int main() { std::function<void(int)> f1 = Func(); std::function<void(int,int)> f2 = Func(); f1(0); f2(0,0); };

---

Ce code fonctionne parfaitement, maintenant imagines qu'il existe une fonction tel que tu le proposes :

Code:

---

1 2 3 4 5 6 7

template<class F> std::functor</*déterminer par F*/> make_functor(F f) { /*code*/ }   //avec le code précédent auto f = make_functor(Func());

---

Quel va être le type déterminé par auto ? std::function<void(int)> ou std::function<void(int,int)> ?

Cependant on pourrait le faire en partant d'un pointeur de fonction, c'est un peu ce que fait bind (ca retourne une classe du genre BindHelper, qui est un foncteur dont les paramètres de l'opérateur () sont déterminé pas le pointeur de fonction).

Pour les lambdas, le type est spécifique et je ne connais pas assez ces spécificités pour en dire plus. Et si on utilisait les lambda de boost le problème est tout autre : ils sont polymorphiques, ainsi les types sont non déterminé.

Pour ton problème, il faut que tu fasses comme pour les algorithmes de la bibliothèque standard :

Code:

---

1 2 3 4 5 6

template<class F> void foo(F f) { /*code*/ }   template<class F> void foo(F&& f) { /*code*/ }

---

Le but de std/boost::function c'est de proposer un wrapper pour la notion de foncteur, ce n'est pas les foncteur en eux-même, un foncteur étant n'importe quelle classe proposant un opérateur (). L'utilité de std/boost::function est ainsi de pouvoir récupérer ces différents types foncteurs et de les traiter de manière identique (typiquement : les stocker).

D'accord je vais m'orienter de ce côté là. Par contre tu peux me dire la différence entre ces deux fonctions :

Code:

---

1 2 3 4 5

template<class F> void foo(F f) { /*code*/ }   template<class F> void foo(F&& f) { /*code*/ }

---

Merci beaucoup!

Salut,
Le premier utilisera une copie du paramètre, le second un déplacement. Si le callable est trivial, une copie devrait suffire. Si des ressources couteuses sont utilisées, alors le déplacement devrait être préférable.

Merci!

P.S. Sur le post suivant on traite des rref et std::forward pour ceux intéressés. http://www.developpez.net/forums/d11...e/#post6326012