Re: How can I remove dynamic_cast and if statements from this code snippet?
On 16 Nov, 19:37, Chris Stankevitz <chrisstankev...@gmail.com> wrote:
Hello,
I would like to remove the "dynamic_cast" and "if" statements from the
code below. I believe some people would describe this as making the
code "polymorphic". Can you recommend a way to do this without
modifying the original classes in "Library A"?
My intention is to create an "XML Writer" class(es) for shapes without
putting "XML code" in the base classes. I plan to use a similar
pattern for drawing and other tasks my application has to perform on
Shape objects.
Thank you,
Chris
// Library A
struct Shape { virtual ~Shape() {} };
struct Circle : public Shape { float radius; };
struct Square : public Shape { float edge; };
// Library B
#include <iostream>
class XmlWriter
{
static void write(Shape* shape)
{
if (Circle* circle = dynamic_cast<Circle*>(shape))
{
std::cout << "<Circle Radius=" << circle->radius << "/>";
}
else if (Square* square = dynamic_cast<Square*>(shape))
{
std::cout << "<Square Edge=" << square->edge << "/>";
}
}
};
Hi,
IMHO you can try one of the following approaches:
- map the type_info of the classes to some function that does the
actual work, any map will give you on the average better than linear
behavior (cascade of ifs). This applies only if you have lots of
classes, if you have only a handful it will be worse (probably).
- create a mirror hierarchy of classes (deriving or composing). Add
the virtual write method on those classes and just use those instead
of the original ones...
Obviously if you could modify the original classes, that would be the
way to go...
Bye,
Francesco
// CODE
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Library A
struct Shape { virtual ~Shape() {} };
struct Circle : public Shape { float radius; };
struct Square : public Shape { float edge; };
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Library B
#include <iostream>
#include <cassert>
#define USE_UNORDERED_MAP
#ifdef USE_UNORDERED_MAP
#include <tr1/unordered_map>
#else
#include <map>
#endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Type unsafe functions!!
void WriteCircle( Shape * shape )
{
Circle * circle = static_cast< Circle * >( shape );
std::cout << "<Circle Radius=" << circle->radius << "/>";
}
void WriteSquare( Shape * shape )
{
Square * square = static_cast< Square * >( shape );
std::cout << "<Square Edge=" << square->edge << "/>";
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// TypeInfo class for map key
class CTypeInfo
{
public:
CTypeInfo( std::type_info const & inTypeInfo )
: mTypeInfoPtr( &inTypeInfo )
#ifdef USE_UNORDERED_MAP
, mHash( std::tr1::hash< std::string >()
( inTypeInfo.name() ) )
#endif
{ }
bool operator<( CTypeInfo const & inTypeInfo ) const
{ return mTypeInfoPtr->before( *inTypeInfo.mTypeInfoPtr ); }
bool operator==( CTypeInfo const & inTypeInfo ) const
{ return *mTypeInfoPtr == *inTypeInfo.mTypeInfoPtr; }
#ifdef USE_UNORDERED_MAP
size_t GetHash( void ) const
{ return mHash; }
#endif
private:
std::type_info const * mTypeInfoPtr;
#ifdef USE_UNORDERED_MAP
size_t mHash;
#endif
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Map stuff
#ifdef USE_UNORDERED_MAP
struct CTypeInfoHash
{
size_t operator()( CTypeInfo const & inTypeInfo ) const
{ return inTypeInfo.GetHash(); }
};
#endif
typedef void (*tFuncPtr)( Shape * );
#ifdef USE_UNORDERED_MAP
typedef std::tr1::unordered_map< CTypeInfo, tFuncPtr, CTypeInfoHash >
CMap;
#else
typedef std::map< CTypeInfo, tFuncPtr > CMap;
#endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// XmlWriter
class XmlWriter
{
private:
// this is all thread unsafe!!!
static CMap & GetMap()
{
static CMap sMap;
return sMap;
}
static void Init()
{
static bool sInit = false;
if( !sInit )
{
CMap & map = GetMap();
map.insert( CMap::value_type( typeid( Circle ),
&WriteCircle ) );
map.insert( CMap::value_type( typeid( Square ),
&WriteSquare ) );
sInit = true;
}
}
public:
void write(Shape* shape)
{
Init();
CMap & map = GetMap();
CMap::const_iterator iter = map.find( typeid( *shape ) );
assert( iter != map.end() );
iter->second( shape );
}
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// augmenting classes
// WARNING: quick example, many things to look after...
struct CShapePlus
{
virtual ~CShapePlus() {}
virtual void Write() const = 0;
};
// composition
struct CCirclePlus : public CShapePlus
{
Circle mCircle;
virtual void Write() const
{ std::cout << "<Circle Radius=" << mCircle.radius << "/>"; }
};
struct CSquarePlus : public CShapePlus
{
Square mSquare;
virtual void Write() const
{ std::cout << "<Square Edge=" << mSquare.edge << "/>"; }
};
// inheritance
struct CCirclePlus2 : public Circle, public CShapePlus
{
virtual void Write() const
{ std::cout << "<Circle Radius=" << this->radius << "/>"; }
};
struct CSquarePlus2 : public Square, public CShapePlus
{
virtual void Write() const
{ std::cout << "<Square Edge=" << this->edge << "/>"; }
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// main
int main()
{
Shape * shape1 = new Circle;
Shape * shape2 = new Square;
XmlWriter writer;
writer.write( shape1 ); std::cout << '\n';
writer.write( shape2 ); std::cout << '\n';
CShapePlus * shape3 = new CCirclePlus;
CShapePlus * shape4 = new CSquarePlus;
CShapePlus * shape5 = new CCirclePlus2;
CShapePlus * shape6 = new CSquarePlus2;
shape3->Write(); std::cout << '\n';
shape4->Write(); std::cout << '\n';
shape5->Write(); std::cout << '\n';
shape6->Write(); std::cout << '\n';
}
// END CODE