Re: The merits of dynamic_cast<>()
* Leslaw Bieniasz:
If neither approach seems feasible then consider the knowledge
distribution of your design. The need for casting arises because the
knowledge needed for some action isn't present where the
responsibility for carrying out the action has been assigned. The
trick is then to make the knowledge available where it's needed, by
moving or referencing the knowledge and/or the action responsibility.
Alf,
I like the above idea, but can't you be more specific?
If we take the example of the drawing shapes problem,
mentioned by someone, with additional feature "radius"
of the "circle" object, then how would this redistribution
of knowledge would look like, if the task is to retrieve
the radii from all circle objects present in a list
together with other objects?
Oh.
First, you should consider what you're trying to retrieve those radius values
*for*. It's likely to be some generic action, like drawing, that simply
corresponds to a virtual routine in a base class. This is shown below:
<code>
#include <stddef.h>
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
class S
{
private:
ostringstream stream;
public:
template< typename T >
S& operator<<( T const& v )
{
stream << v;
return *this;
}
operator string() const { return stream.str(); }
};
template< typename T, ptrdiff_t N >
ptrdiff_t nElements( T const (&)[N] ) { return N; }
class Canvas
{
public:
void draw( string const& s )
{
cout << "Drawing a " << s << endl;
}
};
class Shape
{
protected:
virtual ~Shape() {}
public:
virtual void displayOn( Canvas& aCanvas ) {}
virtual void destroy() { delete this; }
};
class Rectangle
: public Shape
{
private:
int myWidth, myHeight;
protected:
virtual ~Rectangle() {}
public:
Rectangle( int w, int h ): myWidth( w ), myHeight( h ) {}
int w() const { return myWidth; }
int h() const { return myHeight; }
virtual void displayOn( Canvas& aCanvas )
{
aCanvas.draw( S() << "Rectangle(" << w() << "," << h() << ")" );
}
};
class Circle
: public Shape
{
private:
int myRadius;
protected:
virtual ~Circle() {}
public:
Circle( int r ): myRadius( r ) {}
int radius() const { return myRadius; }
virtual void displayOn( Canvas& aCanvas )
{
aCanvas.draw( S() << "Circle(" << radius() << ")" );
}
};
int main()
{
Shape* shapes[] = {new Rectangle(1,2), new Circle(3), new Circle(4)};
for( int i = 0; i < nElements( shapes ); ++i )
{
Canvas canvas;
shapes[i]->displayOn( canvas );
}
for( int i = 0; i < nElements( shapes ); ++i ) { shapes[i]->destroy(); }
}
</code>
But if you're really interested in just the radius values, perhaps to generate
statistics (!) (I can't come up with anything better!), then this is a typical
visitor pattern.
Generally use of the visitor pattern involves dynamic casting but *centralized*
at a single point. However, when you know all possible classes up front then you
can completely avoid casting. This is shown below.
<code>
#include <stddef.h>
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
template< typename T, ptrdiff_t N >
ptrdiff_t nElements( T const (&)[N] ) { return N; }
class Rectangle;
class Circle;
class Shape
{
protected:
virtual ~Shape() {}
public:
struct Visitor
{
virtual ~Visitor() {};
virtual void process( Shape& ) {}
virtual void process( Rectangle& r ) { process( (Shape&)r ); }
virtual void process( Circle& r ) { process( (Shape&)r ); }
};
virtual void accept( Visitor& visitor ) { visitor.process( *this ); }
virtual void destroy() { delete this; }
};
class Rectangle
: public Shape
{
private:
int myWidth, myHeight;
protected:
virtual ~Rectangle() {}
public:
virtual void accept( Visitor& visitor )
{
visitor.process( *this );
}
Rectangle( int w, int h ): myWidth( w ), myHeight( h ) {}
int w() const { return myWidth; }
int h() const { return myHeight; }
};
class Circle
: public Shape
{
private:
int myRadius;
protected:
virtual ~Circle() {}
public:
virtual void accept( Visitor& visitor )
{
visitor.process( *this );
}
Circle( int r ): myRadius( r ) {}
int radius() const { return myRadius; }
};
int main()
{
Shape* shapes[] = {new Rectangle(1,2), new Circle(3), new Circle(4)};
struct RadiiCollector: Shape::Visitor
{
virtual void process( Circle& c )
{
cout << "Circle with radius " << c.radius() << endl;
}
};
RadiiCollector rc;
for( int i = 0; i < nElements( shapes ); ++i )
{
shapes[i]->accept( rc );
}
for( int i = 0; i < nElements( shapes ); ++i ) { shapes[i]->destroy(); }
}
</code>
Look ma, no casts. :-)
Cheers & hth.,
- Alf
PS: Please don't mail me your Usenet group replies, as you did. I could
mistakenly have responded to the mail before discovering the article in the
group. TIA.