class ITopic
{
public:
    virtual ~ITopic(){};
    virtual _bstr_t GetValue() = 0;
};
class CTopicVector
{
private:
    //I would use a smart pointer 
    //example:
    //map<int , smart_ptr<ITopic> > m_TopicData
    map<int , ITopic*> m_TopicData;
    CRITICAL_SECTION m_cs;
    
public:
    CTopicVector()
    {
        InitializeCriticalSection(&m_cs);
    };
    virtual ~CTopicVector()
    {
        ClearVector();
        DeleteCriticalSection(&m_cs);
    };
    
    void ClearVector()
    {
        map<int , ITopic*>::iterator it;
        EnterCriticalSection(&m_cs);
        try
        {
            for(it = m_TopicData.begin();it != m_TopicData.end();++it)
            {
                delete (*it).second;
            }
            m_TopicData.clear();
        }catch(...){};
        LeaveCriticalSection(&m_cs);
    }

    int GetSize()
    {
        return (int)m_TopicData.size();
    }
    int AddTopic(ITopic* pTopic)
    {
        int iId = (int)m_TopicData.size();
        EnterCriticalSection(&m_cs);
        try
        {
            m_TopicData[iId] = pTopic;
        }catch(...){}
        LeaveCriticalSection(&m_cs);
        return iId;
    };
    //unsafe reference to an object 
    ITopic* GetUnsafeTopic(int iId)
    {
        ITopic *pTopic = NULL;
        EnterCriticalSection(&m_cs);
        try
        {
            pTopic = m_TopicData[iId];
        }catch(...){}
        LeaveCriticalSection(&m_cs);
        return pTopic;
    }

};

class CTopic1: public ITopic
{
private:
    _bstr_t m_bstrVal;
    int     m_iVal;
public:
    CTopic1(_bstr_t bstrVal, int iVal)
        :m_bstrVal(bstrVal),m_iVal(iVal){}

    _bstr_t GetValue()
    {
        return m_bstrVal + L":" + _bstr_t(_variant_t(m_iVal)) + L"\n";
    }
};

class CTopic2: public ITopic
{
private:
    double  m_dVal;
    bool    m_bVal;
public:
    CTopic2(double dVal, bool bVal)
        :m_dVal(dVal),m_bVal(bVal){}

    _bstr_t GetValue()
    {
        return _bstr_t(_variant_t(m_dVal)) + L":" + (m_bVal?L"true\n":L"false\n");
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    CTopicVector TopicVector;
    TopicVector.AddTopic(new CTopic1(L"Topic1",1));
    TopicVector.AddTopic(new CTopic1(L"Topic1",2));
    TopicVector.AddTopic(new CTopic1(L"Topic1",3));
    TopicVector.AddTopic(new CTopic2(3.14,true));
    int size = TopicVector.GetSize();
    for(int i = 0; i < size; ++i)
    {
        ITopic* pTopic = TopicVector.GetUnsafeTopic(i);
        if(pTopic)
        {
            OutputDebugString(pTopic->GetValue());
        }
    }
    return 0;
}