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:


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