Petit problème de classe foncteur template

Version imprimable

Bonjour,

Je travaille sous fedora R.13 avec g++ 4.4.5-2.

Je souhaite réaliser une classe qui supporte une initialisation comme suit :

Code:

1
2
3
 
Function<int(char)> f = &function;
Function<int(char)> f = boost::bind(&function, _1);

et utilisée ainsi :

Code:

1
2
 
f('c');

J'ai commencé à dèvelopper la classe Function, son code se trouve plus bas, mais je bloque sur une erreur. Pourriez vous m'aider s'il vous plait ?

Voici l'erreur :

Code:

1
2
 
main.cpp:26: error: conversion from ‘int (*)(char)’ to non-scalar type ‘Function<int(char)>’ requested

main.cpp:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
#include "Function.hpp"
int funct1(char c)
{
  std::cout << c << std::endl;
   return 0;
 }
 
 int main()
 {
  Function<int (char)> f = &funct1;
  f('c');
  return 0;
 }

Function.hpp:

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
#ifndef __ETAPE2_FUNCTION__
 #define __ETAPE2_FUNCTION__
 
 template <typename T>
class Function;
 
 template <typename T, typename P1>
class Function<T(P1)>
 {
   typedef int (*ptr)(P1);
 public:
   Function() : _o()
  {
   }
 
   int           operator()(P1 const& p)
  {
     return _o(p);
   }
 
   Function<T(P1)>&      operator=(int (*n)(P1))
   {
    _o =  n;
    return *this;
  }
 
 private:
 ptr           _o;
};
 
#endif

18/06/2011, 11h18
3DArchi
Salut,

Petit piège : Function<int (char)> f = &funct1; est équivalent à Function<int (char)> f(&funct1); et tu n'as pas de constructeur correspondant. Ce que te dis le compilateur => toujours croire son fidèle compilateur.

Donc, tu dois soit rajouter un constructeur dédié :
Code:

1 2 3 Function(int (*n)(P1)) : _o(n) { }
Soit tu coupe en initialisation par défaut puis affectation :
Code:

1 2 Function<int (char)> f; f = &funct1;
Pour le reste, il s'agit d'un exercice je suppose.
18/06/2011, 11h28
ailonn

Merci Archi pour ta réponse !

Oui il s'agit effectivement d'un exercice, en réalite la première étape d'une longue série à clôturer pour demain matin c'est pourquoi je me suis permis de poser la question.

Merci encore !

Maintenant je passe à la doc de boost sur les bind !

Bonne journée ! :)

Re-bonjour !

En me basant sur la reponse de 3D Archi j'ai corrigé mon code et tenté de faire fonctionner la seconde instanciation, avec boost::bind.

Je tombe sur l'erreur déjà vue et resolue précédement :

Code:

1
2
 
main.cpp:36: error: conversion from ‘boost::_bi::bind_t<int, int (*)(char), boost::_bi::list1<boost::arg<1> > >’ to non-scalar type ‘Function<int(char)>’ requested

Alors ni une ni deux je me dis facile je crée un constructeur adapté et là ça compile.
Tout heureux je lance l'exécution, et là... Segfault!

Pourriez vous m'aider, síl vous plait ?

main up :

Code:

1
2
3
4
5
6
7
8
9
10
 
int main()
 {
   Function<int (char)> f = &funct1;
   Function<int (char)> b = boost::bind(&funct1, _1);
 
   f('f');
  b('b');
  return 0;
 }

Function.hpp up :

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
 
 template <typename T>
class Function;
 template <typename T, typename P1>
 class Function<T(P1)>
{
  typedef T (*ptr)(P1);
   typedef boost::_bi::bind_t<T, T (*)(P1), boost::_bi::list1<boost::arg<1> > > B;
 
 public:
   Function() : _o(0), _b(0)
   {
    std::cerr << "Function()" << std::endl;
   }
 
   Function(B p) : _o(0), _b(&p)
   {
     std::cerr << "Function(B)" << std::endl;
   }
 
   Function(ptr p) : _o(p), _b(0)
   {
   }
 
   Function(Function<T(P1)> const& f) : _o(f._o), _b(f._b)
   {
    std::cerr << "Function(Func)" << std::endl;
  }
 
   T                     operator()(P1 const& p)
   {
    if (_b)
       {
         std::cerr << "operator() -- B " << typeid(_b).name() << std::endl;
        return _b->operator()(p);
       }
     return _o(p);
   }
 
   Function<T(P1)>&      operator=(ptr p)
   {
    std::cerr << "operator= = -- ptr" << std::endl;
     _o =  p;
    _b = 0;
    return *this;
   }
 
   Function<T(P1)>&      operator=(B b)
   {
     std::cerr << "operator= -- B" << std::endl;
     _o = 0;
     _b = b;
     return *this;
   }
 
 template <typename S, typename A1>
  Function<S(A1)>&      operator=(Function<S(A1)> const& f)
  {
    _o = f._o;
   _b = f._b;
   return *this;
  }
 private:
  ptr           _o;
  B             *_b;
};

18/06/2011, 18h32
ailonn

J'ai trouvé une solution a mon problème via un const reference en paramètre du constructeur.

Bonne soirée !
:)
18/06/2011, 21h13
3DArchi

(re)salut,

Code:

Function(B p) : _o(0), _b(&p)

tu récupères l'@ d'une variable temporaire (le paramètre p) dans la variable _b. Quand tu l'utilises, cette variable n'existe plus. Donc normale que cela explose ensuite.
En changeant pour une référence constante, tu prends toujours une adresse sur une variable avec une durée de vie plus courte que celle du pointeur. Mais ça ne plante pas car tu es sur un main simple. La logique est probablement de faire une copie par valeur de l'objet retourné par boost::bind. Bref, tu crois que tu as corrigé mais ça tombe tout simplement en marche. Le code reste buggé.

Je pense que tu as mal emmanché le problème. Quel est l'énoncé ? S'agit-il de faire du type erasure (comme un std/boost/tr1::function) ?

P.S. : on évite les variables commençant par un souligné '_'. C'est en général réservé pour les variables compilateurs. Ca évite donc un conflit (ou pire un masquage) d'un symbole du compilo.

Bonsoir,
L'énonce est tel que je l'ai écrite dans mon premier post.
Le fait que ma variable subsiste après le

Citation:

main

ne mínteresse pas trop étend donné que la fin du main equivaut a la fin du programme.

Voici mon main en face final : 1| #include <iostream>

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
#include <string>
 #include "Function.hpp"
 
class Name
{
public:
  Name(){}
 
   char  operator()(char c1)
   {
     return c1;
   }
 
   virtual ~Name(){}
 };
 
 int funct()
 {
   return 54;
 }
 
 
 int funct1(char c)
 {
   std::cout << c << std::endl;
   return 0;
 }
 
 int main()
 {
   Function<int (char)> f = &funct1;
   Function<int (char)> b = boost::bind(&funct1, _1);
    Name n;
   Function<char (char)> c = n;
 
  f('f');
   b('b');
  std::cout << c('o') << std::endl;
   return 0;
 }

et ma classe :

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
95
96
97
98
99
100
101
 #include <boost/bind.hpp>
 
 template <typename T>
 class Function;
 
 template <typename T, typename P1>
 class Function<T(P1)>
 {
   typedef Function<T(P1)>& retour;
   typedef T (*ptr)(P1);
 
   class Holder
   {
   public:
     virtual T  operator()(P1 const&) = 0;
    virtual ~Holder(){};
   };
 
  template <typename C>
   class PlaceHolder : public Holder
   {
     C           *_b;
 
   public:
     PlaceHolder() : _b(0)
     {}
     PlaceHolder(C const& p) : _b(new C(p))
     {}
     PlaceHolder(PlaceHolder<C> const& f) : _b(f._b)
     {}
     PlaceHolder(PlaceHolder<T(P1)> const& f) : _b(f._b)
     {}
 
     T                   operator()(P1 const& p)
    {
       if (_b)
         return _b->operator()(p);
       return T(p);
     }
     virtual ~PlaceHolder()
    {delete _b;}
   };
 
   template <typename PTR, typename A1>
   class PlaceHolder<PTR(A1)> : public Holder
  {
     ptr         _o;
 
   public:
     PlaceHolder() : _o(0)
     {}
 
     PlaceHolder(ptr p) : _o(p)
     {}
 
     PlaceHolder(PlaceHolder<T(P1)> const& f) : _o(f._o)
     {}
 
    T                   operator()(P1 const& p)
     { return _o(p); }
     virtual ~PlaceHolder() {}
   };
 
 public:
  Function() : _hold(0)
  {}
 
 template <typename C>
  Function(C const& p) : _hold(new PlaceHolder<C>(p))
  {}
 
   Function(ptr p) : _hold(new PlaceHolder<T(P1)>(p))
   { }
 
   Function(Function<T(P1)> const& f) : _hold(f._hold)
   {
   }
 
   T                     operator()(P1 const& p)
   {
     if (_hold)
       return _hold->operator()(p);
     return T();
   }
   retour                operator=(ptr p)
   {
     delete _hold;
     _hold = new PlaceHolder<T(P1)>(p);
     return *this;
   }
 
   template <typename B>
   retour                operator=(B const&b)
   {
     delete _hold;
   _hold = new PlaceHolder<B>(b);
     return *this;
   }
 private:
  Holder *      _hold;
 };

EDIT: Mince je ne savais pas pour les variable avec ´_' je m'en sers pour signaler un attribut privé dans les classe. Il va falloir que je trouve autre chose. =D