Problem koncepcyjny - jak zrobić wstawianie i pobieranie róznych typów

potrzebuję takiej hierahii klass

 
 Class ProcessItem
{
public:
virtual void  SetItem(/*TYP*/) = 0;
virtual void /*LUB TYP*/  SetItem(/*bez argumentów lub referencja*/) = 0;
};
 Class ProcessItem_Number : ProcessItem
{
   void  SetItem(long Number)
  {
      m_long = Number;
  }

   void  /*LUB TYP*/ GetItem(long &Number /*lub bez argumentów*/)
  {
      m_long = Number;
  }

private:
long m_long;
};

 Class ProcessItem_Bool : ProcessItem
{
//tak jak klasa wyżej
};
 Class ProcessItem_String : ProcessItem
{
//tak jak klasa wyżej
};

// dzięki temu mogę miec mapę obiektów dziedziczących po ProcessItem i sobie ustawiać i pobierać co tam chce
Class Process
{
private:
std::map<CString, ProcessItem> m_ProcessItems

};

czyli aby metoda była i wirtualna i abstrakcyjna zarazem - czy i jak można cos takiego osiągnąć

Ale jaki jest problem? Odpowiedź brzmi: tak, możesz tak zrobić. Co jest nie tak z dołączonym kodem?

No i zrobilem

dla zainteresowanych - kod w QT - nie jest doskonały (nie czyszcze wskaźników) - ale jest

#include <QtCore/QCoreApplication>
#include <QMap>

class TProcessItem_Base
{
public:
  virtual ~TProcessItem_Base() {}
};

template <class T>
class TProcessItem : public TProcessItem_Base
{
public:
  TProcessItem(T A_ProcessItem)
  {
     m_member =  A_ProcessItem;
  }

  virtual ~TProcessItem() {}

  void get(T &A_ProcessItem)
  {
    A_ProcessItem = m_member;
  }

private:
    T m_member;
};

class TProcessItemManager
{
public:
    TProcessItemManager()
    {
       m_pProcessItem = NULL;
    }

    ~TProcessItemManager()
    {
        if(m_pProcessItem)
            delete m_pProcessItem;
        m_pProcessItem = NULL;
    }

    template <class T> void set(T A_param)
    {
        m_pProcessItem = new TProcessItem<T>(A_param);
    }

    template <class T>
    void get(T &A_param)
    {
        if(m_pProcessItem && dynamic_cast<TProcessItem<T> *>(m_pProcessItem))
            dynamic_cast<TProcessItem<T> *>(m_pProcessItem)->get(A_param);
    }

private:
  TProcessItem_Base *m_pProcessItem;
};


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QMap<int, TProcessItemManager *> asa;
    asa[0] = new TProcessItemManager();
    asa[1] = new TProcessItemManager();

    QString dupa = "dupa";

    asa[0]->set(1);
    asa[1]->set(dupa);

    int set1;
    QString set2;

    asa[0]->get(set1);
    asa[1]->get(set2);



    return a.exec();
}

 

Jakby ktos miał uwagi pomysły itd - chętnie posłucham