C++Talk.NET

gof77 · Guest

Bonjour ,

Je souhaiterais utiliser le pattern visitor mais en l'adaptant légèrement.
Au lieu de :

class Visiteur {
visit(ClasseAbstraite *);
visit(ClasseConcreteA *);
visit(ClasseConcreteB *);
}

je voudrais avoir une classe abstraite Visiteur qui spécifierai seulement à
quelle hiérarchie la visite s'applique
(par exemple en donnant la classe abstraite) sans avoir à spécifier
l'ensemble des classes concrètes dérivées de la classe abstraite afin de
pouvoir faire évoluer ma hiérarchie sans remettre à jour ma classe Visiteur.

J'ai réfléchi en essayant de passer par des templates mais apparament ce
n'est pas si trivial que ca.

Donc si vous avez un moyen merci par avance

Cédric

gof77 · Guest

Précisions :

J'ai déjà essayé :

//====================

#include <iostream>

template<class T>
class Visitor
{
public:
virtual void process()
{
cout<<"Visitor"<
}

};

template class Visitable
{
public :
virtual void accept(Visitor<T> &) = 0;

};
class Vegetable;

class VegetableVisitor : public Visitor<Vegetable>
{
public :
void process()
{
cout<<"Vegetable visitor"< }
};

class Vegetable : public Visitable {
public :
void accept(Visitor<Vegetable> & vis){
vis.process();
};

};

int main()
{
VegetableVisitor visitor;
Vegetable potatoe;
cout<<"START"< visitor.accept(visitor);
cout<<"END"< return 0;

}

//===================
Resultat :
START
Visitor
END

//============

Pourquoi je ne passe pas dans le process de VegetableVisitor ??

"gof77" 406da2f5$0$31109$636a15ce (AT) news (DOT) free.fr...

Franck Branjonneau · Guest

"gof77" <ced1977__No__sPaM__ (AT) free (DOT) fr> écrivait:

Sous reserve de

gof77 · Guest

Comment passer outre cette liaison statique ?

Franck Branjonneau · Guest

"gof77" <ced1977__No__sPaM__ (AT) free (DOT) fr> écrivait:

gof77 · Guest

J'ai trouvé une nouvelle version mais je voudrais savoir si elle fonctionne
chez vous ?
Car chez moi au niveau du dynamic_cast elle plante !!
Je ne comprends pas pourquoi d'ailleurs

//=========================
#include <iostream>

using namespace std;
//======================
//
//======================
class BaseVisitor
{
public:
virtual ~BaseVisitor(){}
};
//======================
//
//======================
template <class T>
class Visitor
{
public:
virtual void Visit(T&) = 0;
};

//======================
//
//======================
class BaseVisitable
{
public:
virtual ~BaseVisitable(){}
virtual void Accept(BaseVisitor &) = 0;
protected:
template<class T>
static void AcceptImpl(T& visited,BaseVisitor& guest)
{

if(Visitor<T>* p = dynamic_cast<Visitor(&guest))
{
p->Visit(visited);
}

}

};

#define DEFINE_VISITABLE()
virtual void Accept(BaseVisitor & guest)
{ AcceptImpl(*this,guest);}

//======================
// START OF THE IMP
//======================
class Vegetable : public BaseVisitable
{
public:
DEFINE_VISITABLE()
};

//======================
//
//======================
class Tomatoe : public Vegetable
{
public:
DEFINE_VISITABLE()
};

//======================
//
//======================
class Potatoe : public Vegetable
{
public:
DEFINE_VISITABLE()
};

//======================
//
//======================
class VegetableVisitor :
public BaseVisitor,
public Visitor<Vegetable>,
public Visitor<Potatoe>
{
public:
void Visit(Vegetable&){std::cout<<"Visit(Vegetable&)n";}
void Visit(Potatoe&){std::cout<<"Visit(Potatoe&)n";}

};

//======================
//
//======================
int main()
{
VegetableVisitor unJardinier;
Potatoe unePatate;
Vegetable* unLegume = &unePatate;
unLegume->Accept(unJardinier);

}

//======================
//
//======================

Franck Branjonneau · Guest

"gof77" <ced1977__No__sPaM__ (AT) free (DOT) fr> écrivait: