Session of low-level optimization of memory usage in C++ programs with total exposure

#include "cmnFastObjects.h"
#include "string"
#include "iostream"
#include "memory"
#include "windows.h"

// mega factory
struct ISomethingAbstract
{
    virtual ~ISomethingAbstract(){}
    virtual void DoIt()=0;
    virtual void Validate(int iValue)=0;
};


class CObject1:public ISomethingAbstract
{
    int m_iCount;
public:
    CObject1()
        : m_iCount(0)
    {
        //std::cout<<"CObject2:CObject2 \n"; 
    }
    CObject1(const CObject1 & obj)
        : m_iCount(obj.m_iCount)
    {
        //std::cout<<"CObject2:CObject2(const CObject2 & obj) \n"; 
    }
    ~CObject1()
    {
        //std::cout<<"CObject2:~CObject2 \n"; 
    }
    virtual void DoIt() 
    {
        ++m_iCount;
        //std::cout<<"CObject2::DoIt\n"; 
    }
    virtual void Validate(int iValue)
    {
        if (m_iCount != iValue)
            abort();
    }
};

class CObject2:public ISomethingAbstract
{
    int m_iCount;
public:
    CObject2()
        : m_iCount(0)
    {
    }
    CObject2(const CObject2 & obj)
        : m_iCount(obj.m_iCount)
    {
    }
    ~CObject2()
    {
    }
    virtual void DoIt() 
    {
        ++m_iCount;
    }
    virtual void Validate(int iValue)
    {
        if (m_iCount != iValue)
            abort();
    }
};




class CFastConcreteFactory
{
public:
    typedef utils::Node<utils::manageable<CObject1, utils::allow_copy>, 
                 utils::Node<utils::manageable<CObject2, utils::allow_copy>, 
                      utils::NullNode
                     > 
                > ObjectList;

    static const size_t MaxObjectSize = utils::GetMaxSize<ObjectList>::Result;
    typedef utils::CFastObject<MaxObjectSize, ISomethingAbstract> AnyObject;

    void CreateSmth(int iValue, AnyObject * pResult)
    {
        if (iValue<0)
        {
            pResult->CreateByCopy(utils::manageable<CObject1, utils::allow_copy>());
        }
        else
        {
            pResult->CreateByCopy(utils::manageable<CObject2, utils::allow_copy>());
        }
    }
};

class CStandardFactory
{
public:
    void CreateSmth(int iValue, std::auto_ptr<ISomethingAbstract> * pResult)
    {
        if (iValue<0)
        {
            pResult->reset(new CObject1);
        }
        else
        {
            pResult->reset(new CObject2);
        }
    }
};

void RunUnitTests()
{
    CFastConcreteFactory factory;
    CFastConcreteFactory::AnyObject object2;
    factory.CreateSmth(-1, &object2);
    object2->DoIt();
    factory.CreateSmth(1, &object2);
    object2->DoIt();
   
    utils::CFastObject<50, std::string> object;
    utils::manageable<std::string, utils::allow_all> str("hello_world");
    object.CreateByCopy(str);
    
    // test initialization
    if (*object.GetInterface<std::string>() != "hello_world")
    {
        abort();
    }

    // test copy
    {
        utils::CFastObject<50, std::string> copy_of_object;
        object.Copy( &copy_of_object );
        if (*copy_of_object.GetInterface<std::string>() != "hello_world")
        {
            abort();
        }
    }

    // test move
    {
        utils::CFastObject<50, std::string> copy_of_object;
        object.Move( &copy_of_object );
        if (*copy_of_object.GetInterface<std::string>() != "hello_world")
        {
            abort();
        }
        if (!object.IsClean())
        {
            abort();
        }
    }
}


void RunPerformanceTests()
{
    const int iIterCount = 10000000;
    { // standard way
        Sleep(0);
        DWORD dwBegin = GetTickCount();

        CStandardFactory factory;
        std::auto_ptr<ISomethingAbstract> object2;
        for(int i =0;i<iIterCount;++i)
        {
            factory.CreateSmth(-1, &object2);
            object2->DoIt();
            object2->Validate(1);
        }
        
        DWORD dwEnd = GetTickCount();
        std::cout<<"Normal time: "<<dwEnd-dwBegin<<"\n";
    }

    { // optimized way
        Sleep(0);
        DWORD dwBegin = GetTickCount();

        CFastConcreteFactory factory;
        CFastConcreteFactory::AnyObject object2;
        for(int i =0;i<iIterCount;++i)
        {
            factory.CreateSmth(-1, &object2);
            object2->DoIt();
            object2->Validate(1);
        }
        DWORD dwEnd = GetTickCount();
        std::cout<<"FastObject time: "<<dwEnd-dwBegin<<"\n";
    }
}
int main()
{
    RunUnitTests();
    RunPerformanceTests();
    return 0;
}