Prototype de fonction difficile à comprendre

Version imprimable

14/01/2011, 04h46
Nono Sto

Prototype de fonction difficile à comprendre

Chères amies, chers amis du forum

voici un prototype de fonction que je ne comprend pas:

Code:

void prog_dyn ( t_noeud * const arbre , double (* phi ) ( double ) , double p ) ;

Mon problème c'est l'instruction suivante:

Code:

double (* phi ) ( double )

,
avec phi une fonction de type phi(x)=(x-100). je ne comprend pas comment implémenter une telle fonction, de plus je souhaite remplacer 100 par une variable K.

Merci pour votre aide
14/01/2011, 07h30
Chatanga
Tu sembles pourtant bien avoir compris qu'il s'agit d'un pointeur sur fonction dont tu peux fournir une valeur à prog_dyn de la manière suivante.
Code:

1 2 3 4 5 6 7 8 9 10 double phiPhi(double x) { return x - 100; } int main(int, char **) { prog_dyn(0, phiPhi, 250); return 0; }
Pour remplacer 100 par K, c'est plus difficile. Je te propose ça :
Code:

1 2 3 4 5 6 7 8 9 10 template< int K > static double louLou(double x) { return x - K; } int main(int, char **) { prog_dyn(0, louLou<40>, 250); }
La curryfication a toutefois ses limites en C++...
15/01/2011, 05h46
Nono Sto

Merci
15/01/2011, 15h32
Joel F
Citation:

Envoyé par Chatanga

La curryfication a toutefois ses limites en C++...

T'as aussi le droit de faire un bind.
Code:

1 2 3 4 5 6 7 double f(double x, double factor) { return x - factor; } prog_dyn(0, boost::bind(f, _1, 40), 250);
15/01/2011, 19h16
LittleWhite

Bonjour,

J'étais en train de faire le deuxième exemple de Chatanga (juste pour entrainement) et je ne vois pas du tout pourquoi on voudrais faire en utilisant le template, à la place d'utiliser simplement un argument de plus à la fonction (plus proche du dernier exemple avec le bind (et là, je me dis ... le bind me semble totalement inutile :whistle:)).

Pouvez vous m'expliquer un peu plus en détails s'il vous plait, pourquoi chercherai t'on à passer par un template, à la place d'ajouter un argument en plus.
15/01/2011, 23h28
Chatanga

Citation:

Envoyé par LittleWhite

Pouvez vous m'expliquer un peu plus en détails s'il vous plait, pourquoi chercherai t'on à passer par un template, à la place d'ajouter un argument en plus.

Parce que prog_dyn a simplement besoin d'une fonction phi:a->b et n'a pas à gérer des passages de paramètres supplémentaires qui n'ont aucun sens pour elle. Imaginons une implémentation de phi qui irait récupérer sa valeur de retour dans un fichier quelconque ; prog_dyn devrait-elle accepter un nouvel argument filename uniquement pour ça ?

Sinon, utiliser boost::bind est assurément plus puissant que ma solution, d'autant que les paramètres autres que des entiers pourront être utilisés (dans mon exemple, K ne peut même pas être un double).

Cheres amies, chers amis du forum

J'ai toujours un peu de mal dans l'utilisation de cette fonction, je l'ai modifié un peu:
Code:

1 2 3 void noeud::pricing (noeud *const arbre ,void (*phi)(noeud,double), double p,double r );
avec phi
Code:

1 2 3 void noeud::phi (noeud *const arbre,double K);
et dans le main lorsque j'appelle cette fonction dans le main j'ai une erreur qui s'affiche:
Code:

1 2 3 node->pricing(node,(node,875),0.75,0.8);
Code:

1 2 error C2664: 'noeud::pricing' : impossible de convertir le paramètre 2 de 'int' en 'void (__cdecl *)(noeud,double)
Merci

19/01/2011, 13h16
dragonjoker59

Je ne sais pas trop ce que tu cherches à faire, là.
Ta fonction 'pricing' demande un pointeur de fonction, et apparemment tu essaies de lui passer des paramètres que tu aimerais mettre à ta fonction 'phi'. Le compilateur ne s'en sort pas, et moi non plus, d'ailleurs.
20/01/2011, 10h15
Nono Sto

Merci

je vais réfléchir à une autre solution, celle là me parait trop difficile.
20/01/2011, 10h36
LittleWhite

Citation:

Envoyé par Nono Sto

Merci

je vais réfléchir à une autre solution, celle là me parait trop difficile.

Pour ce code:

Code:

node->pricing(node,(node,875),0.75,0.8);

J'aurais mis:

Code:

node->pricing(node,node::phi(node,875),0.75,0.8);

Ou alors (dependant de ce que dit le compilateur)

Code:

node->pricing(node,&node::phi(node,875),0.75,0.8);

Citation:

Envoyé par LittleWhite

Pour ce code:

Code:

node->pricing(node,(node,875),0.75,0.8);

J'aurais mis:

Code:

node->pricing(node,node::phi(node,875),0.75,0.8);

Ca, ça évalue la fonction node::phi avec les paramètres donnés, et ça passe en paramètre à pricing le résultat de cette évaluation.

Citation:

Envoyé par LittleWhite

Ou alors (dependant de ce que dit le compilateur)

Code:

node->pricing(node,&node::phi(node,875),0.75,0.8);

Idem, sauf que tu envoie l'adresse à pricing().

Avec le prototype

Code:

1
2
 
void noeud::pricing (noeud *const arbre ,void (*phi)(noeud,double), double p,double r );

Il faut que le prototype de phi soit :

Code:

1
2
3
4
5
6
7
8
// dans une classe : 
class X
{
   static void phi(noeud* arbre, double valeur);
};
// en dehors d'une classe
void phi(noeud* arbre, double valeur);

Il est toutefois possible de faire les choses un peu différemment, en passant par les templates.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class noeud
{
public:
   template <class Functor>
   void pricing(noeud *const arbre , Functor phi, double p,double r)
   {
      // le code de procing doit être dans le fichier .h, parce que c'est une
      // fonction template
      ...
      phi(n, valeur);
      ...
   }
};

Le code suivant est alors valide :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
// cas phi1 : foncteur classique
struct phi1
{
  void operator()(noeud *const arbre, double v)
  { ... }
};

// cas phi2 : pointeur sur fonction
void phi2(noeud *const arbre, double v);

// cas phi3 et phi4 : fonctions membres d'une classe
class X
{
public:
  static void phi3(noeud *const arbre, double v);
  void phi4(noeud *const arbre, double v);
};

// cas phi5: fonction phi membre de la classe noeud
// requiert l'inclusion du header standard <functional>
class noeud
{
public:
  // prototype court, car le premier paramètre est en fait l'instance de
  // noeud qui sera utilisée pour this. 
  void phi5(double v);
};

// ATTENTION - ATTENTION - ATTENTION - ATTENTION - ATTENTION
// Le code ci-dessous est un peu compliqué pour un débutant. Il est
// utile dans le cas où l'on veut passer en paramètre à pricing() une
// fonction membre non statique d'une classe quelconque (le cas phi4).  
// J'en dit plus un peu plus bas sur ce sujet très particulier. 
// ATTENTION - ATTENTION - ATTENTION - ATTENTION - ATTENTION
template <class C>
struct phi_helper
{
private:
  C* m_instance;
  void (C::*m_membre)(noeud *const, double);

public:
  phi_helper(C* c, void (C::*m)(noeud *const, double))
  : m_instance(c)
  , m_member(m)
  { }
  void operator()(noeud *const arbre, double v)
  {
    (m_instance->*m_membre)(arbre, v);
  }
};

template <class C>
phi_helper<C> make_phi_helper(C* c, void (C::*m)(noeud *const, double))
{
  return phi_helper<C>(c, m);
}
// ATTENTION - ATTENTION - ATTENTION - ATTENTION - ATTENTION
// Fin du code compliqué
// ATTENTION - ATTENTION - ATTENTION - ATTENTION - ATTENTION

void test_pricing()
{
  noeud n;
  
  // construit un objet du type phi1. pricing l'appelera grâce à son 
  // opérateur ()
  p.pricing(..., phi1(), ...);

  // on peut tout simplement lui passer un pointeur sur une fonction
  // ou un pointeur sur une fonction membre statique
  p.pricing(..., phi2, ...);
  p.pricing(..., X::phi3, ...);

  // avec un peu de courage, on peut aussi lui passer une fonction
  // membre d'une classe, mais il faut l'associer à une instance de 
  // cette classe. Il faut s'aider d'un objet intermédiaire pour transformer
  // le couple (Classe, fonction membre non statique) en foncteur classique. 
  // malheureusement, le standard C++ ne fournit pas un tel type, donc on
  // en a développé un nous-même - c'est la classe template phi_helper<>
  // ci-dessus. Puisqu'on veut se simplifier l'écriture au maximum, on va éviter 
  // d'instancier de manière explicite cette classe, et on va passer par une
  // fonction template (make_phi_helper<>()) qui va déduire toute seule un
  // certain nombre de choses.
  X x; // il faut définir une instance de X
  p.pricing(..., make_phi_helper(&x, &x::phi4),...);

  // encore plus fort, si la fonction phi à passer en paramètre est une
  // méthode de la classe noeud. Dans ce cas, le foncteur évalué se comporte
  // ainsi : 
  // phi(node, v) --> node->mbrfun(v)
  p.pricing(..., std::mem_fun_1(&noeud::phi5), ...);
}

Citation:
Envoyé par Emmanuel Deloget
Il est toutefois possible de faire les choses un peu différemment, en passant par les templates. [...] Le code suivant est alors valide :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 // cas phi1 : foncteur classique struct phi1 { void operator()(noeud *const arbre, double v) { ... } }; // ... // construit un objet du type phi1. pricing l'appelera grâce à son // opérateur () p.pricing(..., phi1(), ...);
J'ai un peu regardé les sources de Boost (bind et function essentiellement) afin de comprendre comment ils s'en sortent pour faire la même chose sans template. Ma première conclusion, c'est que le "C++ moderne" peut être aussi hermétique que l'art moderne. 8O Il me faudra plusieurs relectures pour vraiment comprendre "le truc".

21/01/2011, 00h00
Goten

Boost.bind et boost.function sans template? hein?

sans template variadique peut être?
21/01/2011, 07h02
Chatanga

Mon précédent message était ambigu. Il y a évidemment des templates dans les modules bind & function de Boost et ils permettent, entre autres,
de passer un foncteur (tel 'phi1' au-dessus) comme paramètre d'une fonction non template requérant un simple pointeur sur fonction. Ce n'est pas simple et c'est pourquoi Emmanuel Deloget à du réécrire 'pricing' sous forme d'une fonction template pour illustrer ses propos.
21/01/2011, 09h51
Emmanuel Deloget

C'est vrai que tu peux simplifier le code ci-dessus en décidant de passer un boost::function<void(noeud* const, double)> en paramètre (ou, pour rester dans le domaine de la norme, et puisque de nombreux compilateurs récents le supporte, std::tr1::function<void(noeud* const, double)>.

De là à dire que ça ne nécessite pas de templates... Le code de boost.function est un peu plsu complexe à comprendre que celui que j'ai écrit ci-dessus :)

Citation:

Envoyé par Emmanuel Deloget

De là à dire que ça ne nécessite pas de templates... Le code de boost.function est un peu plsu complexe à comprendre que celui que j'ai écrit ci-dessus :)

Encore une fois, la seule chose que j'énonçais c'est que la méthode bind de Boost permet d'injecter un paramètre à une fonction non template. Boost et son module bind sont évidemment pleins à craquer de templates, mais pas la fonction recevant le paramètre et, ça, c'est fort.
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 36 37 38 39 40 41 typedef double (* PtrSurFonction) (double); double fonctionNonTemplate(PtrSurFonction f, double n) { return f(n); } template< T > double fonctionTemplate(T f, double n) { return f(n); } double phi(double k, double n) { return k * n; } struct < template T > struct FoncteurPhi { int k_; FoncteurPhi(int k) : k_(k) {} double operator()(double n) { return k * n; } } int main(int, char **) { // Marche. fonctionTemplate(FoncteurPhi(5), 10); // Ne compile évidemment pas ! // fonctionTemplate(phi(5), 10); // Ne compile pas non plus ! // fonctionNonTemplate(FoncteurPhi(5), 10); // Marche avec une FONCTION *NON* TEMPLATE ! fonctionNonTemplate(boost::bind(phi, _1, 5), 10); }