[std::function] fonction .target<Type>()

Bonjour,

J'ai crée une fonction qui en génère une autre de la manière suivante :

Code:

---

1 2 3 4 5

std::function<double (const t_vector &)> get_fun(double c) { return [c](const t_vector & x) { return c*x; }; }

---

À partir de cela, je souhaiterais obtenir un pointeur sur fonction double (*ptr) (const t_vector &).

Pour se faire, j'ai fait :

Code:

---

1 2 3 4 5 6 7 8

std::function<double (const t_vector &)> f = get_fun(c);   typedef double (*MyFun) (const t_vector &);   MyFun * ptr = f.target<MyFun>();   cout << (*ptr)(vec) << endl;

---

Malheureusement, j'obtiens l'erreur : erreur de segmentation (core dumped).

De toute évidence, les types ne doivent pas correspondrent...

Help ! :roll:

En vous remerciant d'avance,

Nicolas.

Bonjour,
L'erreur de segmentation vient du fait que f.target<MyFun>() renvoie un pointeur nul. Et c'est parce que dans ce cas le type sous-jacent à la std::function n'est pas un pointeur de fonction mais une fonction-objet. Ça aurait été un pointeur de fonction si la lambda ne capturait aucune variable.

Cela s'explique par le fait que :

Code:

---

[](const t_vector &)->double{/*...*/}

---

Peut être implémenté par le compilateur comme :

Code:

---

double foo(const t_vector &){/*...*/}

---

Le standard nous autorise donc à prendre un pointeur de fonction sur une lambda sans capture.
Alors que :

Code:

---

[c](const t_vector &)->double{return c*x;}

---

Ne peut pas être implémenté comme une fonction, mais sera une sorte de fonction-objet par exemple comme ceci :

Code:

---

1 2 3 4 5 6

struct foo { double c; foo(double c):c(c){} void operator()(const t_vector &){return c*x;} };

---

D'accord! :)

Malheureusement, je suis obligé de capturer ces variables. :?

Toutefois, il n'y a a priori rien de contraignant à travailler avec un objet de type std::function.

Merci beaucoup! :D