Re: Class hierarchy on visitor side of visitor pattern
On 27 July, 03:36, Rune Allnor <all...@tele.ntnu.no> wrote:
Hi all.
Below is a code snippet that sketches two class hierarchies,
on both sides of the visitor pattern.
The visitor pattern is used to handle objects in the Base/derived_n
hierarch according to type. The visitors are also organized in
a class hierarchy, since the pattern will be used in many different
contexts. So all the visitee objects need to know, is the interface
against the BaseVistor class, and one can let DerivedVisitor
classes handle the specifics.
The DerivedClass sets an internal state depending on the type of
object it encounters.
This works in its basic form, where all the functions in the
double dispatch return void.
So to make life as user easy (see the desired syntax as pointed
out in function main()), I want to have the double dispatch methods
return references.
This doesn't work, as the compiler isues an error in the indicated
function DerivedVisitor::visit(): "Cannot convert from BaseVisitor to
DerivedVistor &."
So I am a bit lost. I always thought one could 'generalize' references
and pointer on functon. As far as I can tell, it is the methods
derived_n::dispatchType(BaseVisitor*) that 'peels off' the
information
concerning the derived classes.
Is it at all possible to obtain what I want while leaving the
Base/ derived_n visitee classes with knowledge only about the
BaseVisitor class?
In short - No.
You have maybe confused yourself by departing from "standard" pattern
naming for your methods.
Rune
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
class BaseVisitor;
class derived1;
class derived2;
class Base{
public:
virtual BaseVisitor& dispatchType(BaseVisitor*) = 0;
This method is traditionally called "accept" because its job is to
Accept visitors and do the double dispatch.
It is the key method, It doesn't and cannot know derived vistors and
so can't return them and this is the crux of your problem.
Since it will normally just return its argument there is no value in
returning anything other than void.
};
class BaseVisitor{
public:
virtual BaseVisitor& visit(Base*) = 0;
Here you have confused things a bit.
ALL these methods should be named "visit".
visit(Base*) should be the default/fallback visit for visiting Base
nodes OR derived nodes or nodes not derived from derived1 or derived2
(This will either throw a not_supported exception or do nothing). It
will usually NOT be pure because this default can be implemented by
this class.
You have made it into an extra convenience wrapper layer that isn't in
the GoF pattern book. This is OK except that the naming prevents the
proper use of the method with this signature. The functionality that
you have in visit(Base*) should be in a method called something like
"beginVisiting" maybe.
virtual BaseVisitor& display(derived1*) = 0;
It is perfetctly legitimate to have:
virtual derived1& display(derived1*) = 0;
Which is (I think) what you were meaning with "generalized
references".
But trying to return DerivedVisitor& makes no sense: How will you
implement it in a visitor that isn't derived from DerivedVisitor? and
if all visitors are DerivedVisitors then the DerivedVisitor stuff
should be in BaseVisitor.
virtual BaseVisitor& display(derived2*) = 0;
};
class DerivedVisitor : public BaseVisitor {
public:
DerivedVisitor& visit(Base* b)
{
////////////////////////////////
return (b->dispatchType(this)); // <<<<< Compiler error
How can the compilet know whether or not the return BaseVisitor& is
really a DerivedVisitor&????
It can't.
////////////////////////////////
};
DerivedVisitor& display(derived1*)
{
std::cout << "Derived 1" << std::endl;
state_ =1;
return *this;
};
DerivedVisitor& display(derived2*)
{
std::cout << "derived 2" << std::endl;
state_ = 2;
return *this;
};
size_t getState() const {return state_;};
private:
size_t state_;
};
class derived1 : public Base{
public:
BaseVisitor& dispatchType(BaseVisitor* b)
{
return b->display(this);
}
};
class derived2 : public Base{
public:
BaseVisitor& dispatchType(BaseVisitor* b)
{
return b->display(this);
}
};
int main()
{
DerivedVisitor v;
derived1 d1;
derived2 d2;
size_t s = v.visit(&d1).getState(); // <<<< I want this syntax,
You can't have it.
not
// v.visit(&d1);
// s = v.getState();
std::cout << s << std::endl;
return 0;
}
If you really want neat client syntax then:
size_t DerivedVisitor::getState(Base& b)
{
visit(&b);
return getState();
}
size_t s = v.getState(d1);
or perhaps go for a static method and have
size_t s = DerivedVisitor::getState(d1);
Note the use of references - You are not going to be visiting null I
hope.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]