Hello everyone,
I've been trying to work with the visitor design pattern, and it works
fine except for the following.
Let's suppose that we have a fixed hierarchy of classes (many of them)
which I cannot modify. I decided to use the visitor design pattern
depending on the actual type of the classes because those classes
already support the loki visitor.
[...]
Now, what GenScatterHierarchy does, is to derive from
ClassComputerUnit<Class> where Class is each of those classes in the
ClassList. So now I'm supposed to have all 20 Visit functions in the
VisitorImpl class overide the one of the Visitor. However, this is not
the case and I cannot compile my code because there are pure virtual
functions. So in a sense the GenScatterHierarchy did not overide the
Visit function from the visitor as I thought it would.
Does anyone have a clue why is this happening? I'm using GCC4.3.
Thanks in advance for the time reading such a long post.
This is rather beyond the scope of this group, IMHO (cf.
http://www.parashift.com/c++-faq-lite/how-to-post.html#faq-5.9). Have
you asked on the Loki help forum on Sourceforge? Or can you boil it
down to a standard C++ question?
Cheers! --M
It is a standard C++ question. It does not matter which kind of
visitor you use, all of them boil down to having a pure virtual
function in a base class, and have all subclasses override that
function. The GenScatterHiearchy class template is basically a
metaprogram, so it is a shorthand version of public Class1, public
Class2, and so on.
MFC, Qt, and many other libraries would also qualify under such a
definition of standard C++. Can you rephrase the question so that we
can answer it by looking at the C++ standard? One way to do that is to
boil it down to a minimal but complete program that demonstrates your
problem. (Note, you'll likely get more help if it doesn't require
downloading Loki.)
Cheers! --M
Ok, here we go, I thought that it was straightforward enough so it
would save me some coding. For simplicity let's assume that the return
type is void and that we only have three classes. Here it is:
#include <iostream>
using std::cout;
using std::endl;
class Base;
class Class1;
class Class2;
class Class3;
class ClassVisitor {
public:
void visit(Class1& ) {
cout<<"inside Class1"<<endl;
}
void visit(Class2& ) {
cout<<"inside Class2"<<endl;
}
void visit(Class3& ) {
cout<<"inside Class3"<<endl;
}
};
struct Base {
virtual void accept(ClassVisitor& vis) = 0;
virtual ~Base() {}
};
struct Class1 : public Base {
virtual void accept(ClassVisitor& vis) {
vis.visit(*this);
}};
struct Class2 : public Base {
virtual void accept(ClassVisitor& vis) {
vis.visit(*this);
}};
struct Class3 : public Base {
virtual void accept(ClassVisitor& vis) {
vis.visit(*this);
}
};
int main(int argc, char* argv[]) {
Class1 c1;
Class2 c2;
Class3 c3;
ClassVisitor vis;
c1.accept(vis);
c2.accept(vis);
c3.accept(vis);
return 0;
}
This prints:
inside Class1
inside Class2
inside Class3
Now, I want to change this in order to avoid having all those
declarations in the visitor class. So instead of having
class ClassVisitor {
public:
void visit(Class1& ) {
cout<<"inside Class1"<<endl;
}
void visit(Class2& ) {
cout<<"inside Class2"<<endl;
}
void visit(Class3& ) {
cout<<"inside Class3"<<endl;
}
};
I would like to have
template <class Class>
struct GenClass {
virtual void visit(Class& ) {
cout<<"inside class defined by template"<<endl;
}
};
class ClassVisitor :
public GenClass<Class1>, public GenClass<Class2>, public
GenClass<Class3> {
};
but when I try to compile this code I get ambiguous calls because of
course in the concrete classes, vis.visit(*this); this can be either
Class1, Class2 or Class3.
Now, I would like to solve this problem so I'm asking if anyone knows
how to do it. Thanks,
Now I see the problem. It's the one described in this FAQ:
http://www.parashift.com/c++-faq-lite/templates.html#faq-35.19
You can either modify ClassVisitor:
struct ClassVisitor
: public GenClass<Class1>
, public GenClass<Class2>
, public GenClass<Class3>
{
using GenClass<Class1>::visit;
using GenClass<Class2>::visit;
using GenClass<Class3>::visit;
};
Or you can change the classes themselves:
struct Class1 : Base
{
virtual void accept( ClassVisitor& vis )
{
vis.GenClass<Class1>::visit( *this );
}
};
Neither of these are ideal, but perhaps Loki has solved (or could
solve) this problem with macros and type lists so that ClassVisitor
looks something like:
typedef TypeList<Class1, Class2, Class3> MyTypeList;
struct ClassVisitor
: GenHierarchy< MyTypeList >
{
GEN_USINGS( MyTypeList, visit );
};
Cheers! --M
Thanks mlimber for replying. Indeed that is what is happening, and as
mentioned in the faq it is giving me a headache. I tried the "using"
way before posting and it didn't work. I cannot refer to those
functions defined in the base class with the "this" pointer because
the idea was to eliminate all code from the derived classes. Maybe it
is because of the way the visitor class in the loki library is defined
so I guess I have to come up with my own visitor class.
I'll keep trying and I will post my solution eventually. Thank you,
The two solutions I mentioned (using and explicit qualification)
worked for me just fine, and they should work for you. The using
solution is probably what you'll need to use.
Cheers! --M
Well, I mentioned that I was going to post my solution so here it is.
I took loki's cyclic visitor implementation and I changed so that I
can define visitors with non-strict visit behavior in a very nice
customizable way. So the solution was to implement a visitor that
falls back to another virtual function when the Visit(T&) is not
implemented instead of having the compiler complaint because of pure
virtual functions. This is called non-strict visit.
Here is the message that I put on the loki developer's forum:
Hello everyone,
I just got what I really wanted with the cyclic visitor. The cyclic
visitor class template takes now four template parameters: the return
type, the type list of objects to be visited, a mutable (immutable)
flag for non-const (const) objects and a template template parameter
indicating the default behavior when a function is not defined in the
visitor. In this way you can create a cyclic visitor as follows:
// defaults to mutable (non-const), do-nothing nonstrict visitor
typedef visitor::Visitor<ReturnType, ClassList> ClassVisitor1;
// do-nothing non-strict visitor for immutable objects (const)
typedef visitor::Visitor<ReturnType, ClassList, Immutable>
ClassVisitor2;
// personalize the behavior of the non-strict visitor
template <class R>
struct Functor1 {
template <class T>
R operator()(T&) {
// do whatever with T, when the function is not implemented
// in the visitor
}
};
typedef visitor::Visitor<ReturnType, ClassList, Immutable, Functor1>
ClassVisitor3;
// use strict visitor (compiler errors when R Visit(T&) not defined
// mutable
typedef visitor::Visitor<ReturnType, ClassList, Mutable, Strict>
ClassVisitor4;
// immutable
typedef visitor::Visitor<ReturnType, ClassList, Immutable, Strict>
ClassVisitor5;
I think this is much better than my previous post, even though I don't
think anyone has read that yet. The code is given below.
Best regards,
Alejandro M. Aragón
#ifndef VISITOR_HPP_
#define VISITOR_HPP_
#include <Loki/Typelist.h>
namespace visitor {
using Loki::NullType;
using Loki::Typelist;
// visitor class template, adapted from the Andrei Alexandrescu's
"Modern C++ Design"
enum Visit_type { Mutable, Immutable };
template <class T, typename R = void, Visit_type = Mutable>
class StrictVisitor;
template <class T, typename R>
class StrictVisitor<T, R, Mutable>
{
public:
typedef R ReturnType;
typedef T ParamType;
virtual ~StrictVisitor() {}
virtual ReturnType Visit(ParamType&) = 0;
};
template <class T, typename R>
class StrictVisitor<T, R, Immutable>
{
public:
typedef R ReturnType;
typedef const T ParamType;
virtual ~StrictVisitor() {}
virtual ReturnType Visit(ParamType&) = 0;
};
/// class template StrictVisitor (specialization)
template <class Head, class Tail, typename R>
class StrictVisitor<Typelist<Head, Tail>, R, Mutable>
: public StrictVisitor<Head, R, Mutable>, public StrictVisitor<Tail,
R, Mutable>
{
public:
typedef R ReturnType;
typedef Head ParamType;
// using StrictVisitor<Head, R>::Visit;
// using StrictVisitor<Tail, R>::Visit;
};
template <class Head, typename R>
class StrictVisitor<Typelist<Head, NullType>, R, Mutable> : public
StrictVisitor<Head, R, Mutable>
{
public:
typedef R ReturnType;
typedef Head ParamType;
using StrictVisitor<Head, R, Mutable>::Visit;
};
template <class Head, class Tail, typename R>
class StrictVisitor<Typelist<Head, Tail>, R, Immutable>
: public StrictVisitor<Head, R, Immutable>, public StrictVisitor<Tail,
R, Immutable>
{
public:
typedef R ReturnType;
typedef Head ParamType;
// using StrictVisitor<Head, R>::Visit;
// using StrictVisitor<Tail, R>::Visit;
};
template <class Head, typename R>
class StrictVisitor<Typelist<Head, NullType>, R, Immutable> : public
StrictVisitor<Head, R, Immutable>
{
public:
typedef R ReturnType;
typedef Head ParamType;
using StrictVisitor<Head, R, Immutable>::Visit;
};
////////////////////////////////////////////////////////////////////////////////
// class template NonStrictVisitor
// Implements non-strict visitation (you can implement only part of
the Visit
// functions)
////////////////////////////////////////////////////////////////////////////////
template <class R>
struct DefaultFunctor {
template <class T>
R operator()(T&) { return R(); }
};
template <class T, typename R = void, Visit_type V = Mutable, class F
= DefaultFunctor<R> > class BaseVisitorImpl;
template <class Head, class Tail, typename R, Visit_type V, class F>
class BaseVisitorImpl<Typelist<Head, Tail>, R, V, F>
: public StrictVisitor<Head, R, V>, public BaseVisitorImpl<Tail, R, V,
F> {
public:
typedef typename StrictVisitor<Head, R, V>:
aramType ParamType;
virtual R Visit(ParamType& h)
{ return F()(h); }
};
template <class Head, typename R, Visit_type V, class F >
class BaseVisitorImpl<Typelist<Head, NullType>, R, V, F> : public
StrictVisitor<Head, R, V>
{
public:
typedef typename StrictVisitor<Head, R, V>:
aramType ParamType;
virtual R Visit(ParamType& h)
{ return F()(h); }
};
/// Visitor
template <class R>
struct Strict {};
template <typename R, class TList, Visit_type V = Mutable, template
<class> class FunctorPolicy = DefaultFunctor>
class Visitor : public BaseVisitorImpl<TList, R, V, FunctorPolicy<R> >
{
public:
typedef R ReturnType;
template <class Visited>
ReturnType GenericVisit(Visited& host) {
StrictVisitor<Visited, ReturnType, V>& subObj = *this;
return subObj.Visit(host);
}
};
template <typename R, class TList, Visit_type V>
class Visitor<R, TList, V, Strict> : public StrictVisitor<TList, R, V>
{
public:
typedef R ReturnType;
template <class Visited>
ReturnType GenericVisit(Visited& host) {
StrictVisitor<Visited, ReturnType, V>& subObj = *this;
return subObj.Visit(host);
}
};
} // namespace visitor
#endif /* VISITOR_HPP_ */
