Re: Creating object of a class from its name?

On Thu, 15 Feb 2007 02:43:12 -0800, Kenn
<Kenn@discussions.microsoft.com> wrote:


I think this would be "out-of-the-box" in C# or Java, because these
languages have a built-in so called "Reflection" feature.

C++ has not a built-in feature like this, but it is possible to write
some code to solve this problem.

My idea is to define a base class (BaseObject): all classes that you
want to create by name must derive from BaseObject class.
Moreover, for each class that you want to create by name, you provide
a class factory. Class factories are derived from a common base, too
(ObjectFactory).

To simplify code writing, it is possible to provide a template
definition for object factories (ObjectFactoryT). The template is then
specialized for each specific class.

Then, there is an "object manager" (ObjectFactoryManager), which
purpose is to create a class instance given the class name string.
This object stores a map of:

  class names (string) --> object factory (ObjectFactory *)

When you provide class name, the object factory for that class is
fetched from the map, and the object factory is then used to build the
instance of the class.

You may consider the following C++ code I wrote.
(You may consider also start reading the main() function.)
It compiles fine with Visual C++ 6.
Feel free to update and improve it.

BTW: I edited my original code to try to respect the 60 columns
limitation of newsgroups netiquette :-)

<CODE>
///////////////////////////////////////////////////////////
// Implement Object Creation by Class Name
// By Mr.Asm
///////////////////////////////////////////////////////////

#include <iostream>
#include <string>
#include <map>
#include <cassert>

#pragma warning( disable: 4786 )

using std::cout;
using std::endl;

#ifdef _DEBUG
#define ASSERT(expr) assert(expr);
#else
#define ASSERT(expr) ;
#endif

#ifdef _DEBUG
#define TRACE(msg) cout << "[TRACE] " << msg << endl;
#else
#define TRACE(msg) ;
#endif

//=========================================================

//---------------------------------------------------------
// Base Class - Derive your own class from this one
//---------------------------------------------------------
class BaseObject
{
public:
    BaseObject() {}
    virtual ~BaseObject() {}

    virtual std::string GetClassName() const
    {
        return "BaseObject";
    }
};

//---------------------------------------------------------
// This is the base class for factory objects.
// Factory object's purpose is to create a new instance
// of an object giving its class name.
//---------------------------------------------------------
class ObjectFactory
{
public:
    ObjectFactory() {}
    virtual ~ObjectFactory() {}

    // Return object class name
    virtual std::string GetClassName() const = 0;

    // Create new instance of object
    virtual BaseObject * CreateObject() = 0;
};

//---------------------------------------------------------
// This is the object factory manager.
// It is responsible to build objects given their
// class names.
//---------------------------------------------------------
class ObjectFactoryManager
{
public:
    ObjectFactoryManager()
    {
        TRACE("ObjectFactoryManager Constructor.")
    }

    ~ObjectFactoryManager()
    {
        Clear();
        TRACE("ObjectFactoryManager Destructor.")
    }

    // Register a new class
    //
    // (The input pointer is acquired by this object,
    // so the ownership is transferred from the caller
    // to this object.
    // This object's Clear method will cleanup the pointer.)
    void Add( ObjectFactory * objFactory )
    {
        // Check input pointer
        ASSERT( objFactory != NULL );

        // The object must not be in map
        ASSERT(
            ! IsNamePresent( objFactory->GetClassName() )
        );

        // Store in our (name, class factory) map
        m_factoryMap[ objFactory->GetClassName() ] = objFactory;

        TRACE("Added new object type: ")
        TRACE(objFactory->GetClassName() )
    }

    // Build an object of given class name
    BaseObject * BuildObject( const std::string & className )
    {
        ObjFactoryMap::iterator it =
            m_factoryMap.find( className );

        ASSERT( it != m_factoryMap.end() );
        if ( it == m_factoryMap.end() )
            return NULL;

        TRACE( "Building new object: " )
        TRACE( className)

        return it->second->CreateObject();
    }

    // Return number of registered classes
    size_t GetCount() const
    {
        return m_factoryMap.size();
    }

    // No class registered?
    bool IsEmpty() const
    {
        return m_factoryMap.empty();
    }

    // Cleanup everything
    void Clear()
    {
        TRACE( "Clearing object factories.")

        ObjFactoryMap::iterator it;
        for ( it = m_factoryMap.begin();
              it != m_factoryMap.end();
              ++it )
        {
            delete it->second;
        }
        m_factoryMap.clear();
    }

    //
    // IMPLEMENTATION
    //
private:

    // Map of ClassName -> ClassFactory
    typedef std::map<
                std::string,
                ObjectFactory *
                > ObjFactoryMap;

    ObjFactoryMap m_factoryMap;

    // Is the given (class) name present in the map?
    bool IsNamePresent( const std::string & name ) const
    {
        ObjFactoryMap::const_iterator it;
        it = m_factoryMap.find( name );
        if ( it != m_factoryMap.end() )
            return true;
        else
            return false;
    }
};

// This is the object used to create other objects given
// their class name
ObjectFactoryManager g_objFactory;

//=========================================================

//
// Define some classes, that can be created "by name"
//

//
// A simple demo class - CDemo1
//
class CDemo1 : public BaseObject
{
public:
    CDemo1() { TRACE("CDemo1::CDemo1") }
    ~CDemo1() { TRACE("CDemo1::~CDemo1") }

    //
    // Requirements for BaseObject
    //

    static const std::string ClassName;

    std::string GetClassName() const
    {
        return ClassName;
    }

    //
    // CDemo1 specific stuff
    //

    void SayHello()
    {
        cout << "I'm CDemo1 instance." << endl;
    }
};

const std::string CDemo1::ClassName = "CDemo1";

// class CDemo1Factory : public ObjectFactory
// {
// public:
// CDemo1Factory() {}
// ~CDemo1Factory() {}
//
// std::string GetClassName() const
// {
// return "CDemo1";
// }
//
// BaseObject * CreateObject()
// {
// return new CDemo1();
// }
// };

//
// Use a template to simplify things.
//
// The requirement on ClassType is that it has a
// public static std::string member called "ClassName",
// which stores the class name used for object creation.
//

template <typename ClassType >
class ObjectFactoryT : public ObjectFactory
{
public:

    ObjectFactoryT() {}
    ~ObjectFactoryT() {}

    std::string GetClassName() const
    {
        return ClassType::ClassName;
    }

    BaseObject * CreateObject()
    {
        return new ClassType();
    }
};

//
// A simple demo class - CDemo2
//
class CDemo2 : public BaseObject
{
public:
    CDemo2() { TRACE("CDemo2::CDemo2") }
    ~CDemo2() { TRACE("CDemo2::~CDemo2") }

    //
    // Requirements for BaseObject
    //

    static const std::string ClassName;

    std::string GetClassName() const
    {
        return "CDemo2";
    }

    //
    // CDemo2 specific stuff
    //

    void DoSomething()
    {
        std::cout << "CDemo2 is doing something..." << std::endl;
    }
};

const std::string CDemo2::ClassName = "CDemo2";

//=========================================================

using std::cout;
using std::endl;

//---------------------------------------------------------
// *** TEST ***
//---------------------------------------------------------
int main( int argc, char * argv[] )
{
    cout << "*** Testing Class Creation By Name ***"
         << endl << endl;

    ASSERT( g_objFactory.GetCount() == 0 );

    //
    // Register classes that implement the
    // "creatable by name" feature
    //

    // Register class CDemo1
    g_objFactory.Add( new ObjectFactoryT< CDemo1 >() );

    // Register class CDemo2
    g_objFactory.Add( new ObjectFactoryT< CDemo2 >() );

    //
    // Try building some objects given their class name
    //

    CDemo1 * demo1 = static_cast< CDemo1 * >(
        g_objFactory.BuildObject( "CDemo1" ) );
    ASSERT( demo1 != NULL );

    CDemo2 * demo2 = static_cast< CDemo2 * >(
        g_objFactory.BuildObject( "CDemo2" ) );
    ASSERT( demo2 != NULL );

    //
    // Test the created objects
    //

    demo1->SayHello();
    demo2->DoSomething();

    //
    // Cleanup
    //

    delete demo1;
    demo1 = NULL;

    delete demo2;
    demo2 = NULL;

    g_objFactory.Clear();

    system("PAUSE");

    return 0;
}

///////////////////////////////////////////////////////////

</CODE>

Mr.Asm