les functors ou function objet en c++

Version imprimable

salut à tous,
est ce que quelqu'un pourrait m'aider svp ?
en ce qui concerne les functors ou bien les functions objets.
j'ai la classe functor 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
template <class EOT>
class eoWeakElitistReplacement : public eoReplacement<EOT>
{
public :
  typedef typename EOT::Fitness Fitness;
 
  // Ctor, takes an eoReplacement
  eoWeakElitistReplacement(eoReplacement<EOT> & _replace) :
    replace(_replace) {}
 
  /// do replacement
  void operator()(eoPop<EOT>& _pop, eoPop<EOT>& _offspring)
  {
    const EOT oldChamp = _pop.best_element();
    replace(_pop, _offspring);	   // "normal" replacement, parents are the new
    if (_pop.best_element() < oldChamp) // need to do something
      {
	typename eoPop<EOT>::iterator itPoorGuy = _pop.it_worse_element();
	(*itPoorGuy) = oldChamp;
      }
  }
private:
  eoReplacement<EOT> & replace;
};

je voudrais utiliser ce functor est ce que ce code est correcte:

Code:

1
2
3
4
5
 eoReplacement <Indi>& _repl;
  eoWeakElitistReplacement <Indi>(_repl);// instanciation
eoPop<Indi>& _pop1;
eoPop<Indi>& _pop2;
 eoWeakElitistReplacement (pop1,pop2); // pour utiliser la function operator

Merci pour votre aide.

14/10/2009, 18h28
Lavock

Mis a part un pb de référence nul, je pense bien (tu a des Class<Type>& non-instanciés).

Citation:
Envoyé par annesophiedecar
Code:

1 2 3 4 5 eoReplacement <Indi>& _repl; eoWeakElitistReplacement <Indi>(_repl);// instanciation eoPop<Indi>& _pop1; eoPop<Indi>& _pop2; eoWeakElitistReplacement (pop1,pop2); // pour utiliser la function operator
Probablement une erreur de copier/coller, mais tu ne peux définir une référence sans l'initialiser. Donc _repl, _pop1 et _pop2 sont probablement des valeurs et non des références. Et tu n'as pas nommé ton instance de eoWeakElitistReplacement :
Code:

1 2 3 4 5 eoReplacement <Indi> _repl; eoWeakElitistReplacement <Indi> mon_foncteur(_repl);// instanciation eoPop<Indi> _pop1; eoPop<Indi>_pop2; mon_foncteur(pop1,pop2); // pour utiliser la function operator

15/10/2009, 15h19
annesophiedecar

Merci pour votre aide.

svp si vous me permettez j'ai une autre question sur les functors.
j'ai la classe functor 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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
#ifndef eoFeatureSelectionClone_H
#define eoFeatureSelectionClone_H
#include <math.h>
#include <float.h>
#include <eoGenOp.h>
#include <eoOp.h>
#include <eoPopulator.h>
#include <eoPop.h>
 
template<class GenotypeT> 
 
class eoFeatureSelectionClone: public eoGenOp<GenotypeT>
{
public:
  /**
   * (Default) Constructor.
   */
  eoFeatureSelectionClone(){}
 
  /// The class name. Used to display statistics
  string className() const { return "eoFeatureSelectionClone"; }
 
  /// The TOTAL number of offspring (including modified parents)
  unsigned max_production(void) { return 1000;}//(popSize*beta)*popSize; }
void operator()(eoSeqPopulator<GenotypeT>& _pop)
    {
    _pop.reserve(max_production());
      apply(_pop);
    }
void apply(eoPopulator<GenotypeT>&_pop) 
{  ;
_pop.reserve(1000);
 
int j=0;
while (j!=100)
    {GenotypeT offsprings=_pop.select();
 
for(unsigned i=0;i<10;i++)
{_pop.insert(offsprings);
offsprings.invalidate();
//_pop.insert(const EOT& _eo);}
//return oneAtLeastIsModified;
*++_pop;}
j++;}}
};
 
#endif

je veux utiliser cette classe functor j 'écrit ceci:

Code:

1
2
3
4
5
 eoPop<Indi> destination  (1000,_init); 
eoSeqPopulator <Indi> populator(_pop,destination);
eoGenOp<Indi> *clone = new eoFeatureSelectionClone<Indi>();//(popSize, beta,eoPop<EOT>& _pop);
 
clone(populator);

mais ceci me génére les erreurs suivantes:

Code:

1
2
3
4
5
6
7
/home/anne/Bureau/paradiseo-1.2.1/paradiseo-eo/tutorial/FeatureSelection2/make_op_FeatureSelection.h: In function «eoGenOp<EOT>& do_make_op(eoParameterLoader&, eoState&, eoInit<EOT>&, eoPop<EOT>, EOT)":
/home/anne/Bureau/paradiseo-1.2.1/paradiseo-eo/tutorial/FeatureSelection2/make_op_FeatureSelection.h:133: erreur: «clone" cannot be used as a function
/home/anne/Bureau/paradiseo-1.2.1/paradiseo-eo/tutorial/FeatureSelection2/make_op_FeatureSelection.h: In function «eoGenOp<EOT>& do_make_op(eoParameterLoader&, eoState&, eoInit<EOT>&, eoPop<EOT>, EOT) [with EOT = eoFeatureSelection<eoScalarFitness<double, std::less<double> > >]":
/home/anne/Bureau/paradiseo-1.2.1/paradiseo-eo/tutorial/FeatureSelection2/FeatureSelectionEA.cpp:60:   instantiated from here
/home/anne/Bureau/paradiseo-1.2.1/paradiseo-eo/tutorial/FeatureSelection2/make_op_FeatureSelection.h:133: erreur: «clone" cannot be used as a function
make[2]: *** [tutorial/FeatureSelection2/CMakeFiles/FeatureSelectionEA.dir/FeatureSelectionEA.cpp.o] Erreur 1
make[1]: *** [tutorial/FeatureSelection2/CMakeFiles/FeatureSelectionEA.dir/all] Erreur 2

Merci pour votre aide.

15/10/2009, 18h04
3DArchi
Code:

1 2 3 4 (*clone)(populator); // ou beaucoup moins intéressant comme écriture : clone->operator()(populator);
Pourquoi allouer dynamiquement ton foncteur ? Les foncteurs ont souvent une logique de copie par valeur.
15/10/2009, 18h23
annesophiedecar

Merci beaucoup 3DArchi pour votre réponse! ça marche! j'ai utilisé votre premiere proposition puisque vous m'aviez dit que c'est plus intéressant!
Mais j'ai pas vraiment compris ce que vous voulez dire par "Pourquoi allouer dynamiquement ton foncteur ? Les foncteurs ont souvent une logique de copie par valeur" si vous avez une proposition c'est vraiment avec joie parce que franchement j'arrive pas à très bien comprendre les functors :(

Tu alloues ton foncteur dynamiquement, c'est à dire sur le tas via le new :

Code:

eoGenOp<Indi> *clone = new eoFeatureSelectionClone<Indi>();

Je dit que les foncteurs s'utilisent souvent par valeur, c'est à dire qu'on les transmet ni par pointeur ni par référence :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 struct mon_foncteur { void operator()(A const&a_)const { a_.do_it(); } }; void invoke( mon_foncteur foncteur_ // passage par valeur ni par référence (mon_foncteur const &) ni par pointeur (mon_foncteur const *) , A const &a_ ) { foncteur_(a); }
Le passage par valeur car :
-> ce sont généralement des objets sans (ou presque) état - cad avec pas ou peu de variables internes -
-> ils est rare de les utiliser de façon polymorphe (héritage)
Il n'y a donc pas de surcoût de copie à les passer par valeur.

15/10/2009, 22h14
annesophiedecar

:ccool: merci pour votre réponse 3DArchi je comprend beaucoup mieux!