Discussion :

[ailonn]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

et utilisée ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

main.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
   Function(int (*n)(P1)) : _o(n)
   {
   }

Soit tu coupe en initialisation par défaut puis affectation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
   Function<int (char)> f;
   f = &funct1;

Pour le reste, il s'agit d'un exercice je suppose.

[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 !

[ailonn]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
};

[ailonn]

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


Bonne soirée !

[3DArchi]

(re)salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[ailonn]

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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