Nun ist es so, dass die Methode diese Zeiger auch löscht bzw. den reservierten Platz wieder freigibt. Beim int klappt das, wenn ich jedoch einen CString übergebe bekomme ich "Dumping objects ->" :(.

Der Code sieht zusammengefasst so aus:

void CListe::Add(void* pZeiger) {
  // Hier wird der Zeiger in eine Liste hinzugefügt
  m_Liste.insert(m_Liste->begin(), pZeiger);
}

CListe::~CListe() {
  // Alle Elemente in der Liste zerstören
  ...
    delete m_Liste[i];
  ...
}

// So klappt es
int* pInt = new int(5);
Add(pInt);

// Das klappt nicht bzw. führt zu "Dumping objects ->"
CString* pString = new CString("Test");
Add(pString);

Geht das nicht mit Objekten, weil der Voidzeiger nicht die nötigen Informationen hat, wie er den CString zu zerstören hat? Oder geht das irgendwie bzw. mach ich etwas falsch?

Pseudocode:

if (isteinint)
    delete (int*)pInt;
if (istCString)
    delete (CString*)pString;

Davon abgesehen ist das design-technisch totaler Quatsch...

Ich bin für jegliche design-technische Ideen offen

Also:

cont.Add(3);
cont.Add("lalala");

Ich habs jetzt ein wenig anders gelöst und es funktioniert :). Ich hab einfach eine Klasse definiert die ich CDaten genannt habe. Nun muss jedes Objekt - welches in den Container soll - von einer Klasse sein, die von CDaten geerbt hat. Der Destruktor von CDaten ist natürlich virtual :).

Für CString hab ich dann gleich ne Klasse geschrieben

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

class CSTRDaten : public CDaten
{
public:
	CSTRDaten (CString sVal) { m_sVal = sVal; };
	~CSTRDaten () {};
	CString m_sVal;
};

Die lesende Schnittstelle liest nun die Daten aus dem "zentralen Lager" aus und castet diese mit einem dynamic_cast. Der Lesende weiß ja was für Daten er von dem Lager erwartet :).

Ich weiß nicht ob die Lösung jetzt besser ist, aber ich hoffe es doch :). Ich hoffe ich habe euch mit meiner Idee nicht zu lange aufgehalten :).

Und so funktioniert auch das erwähnte CObArray...

... da frag ich mich jetzt: Ist das gut oder schlecht?

Nur für den Fall, dass du das Rad nicht neu erfinden willst/sollst, solltest du dich damit genauer beschäftigen.

Nur für den Fall, dass du das Rad nicht neu erfinden willst/sollst, solltest du dich damit genauer beschäftigen.

Werde ich auch machen :). Danke auf jedenfall für den Hinweis das es das schon gibt ;).

Oder aber stecke deine Objekte in einen selbst geschriebenen Wrapper, ala so:

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

template <class T> class Thing : public AnyThing
{
public:
    Thing(T const& t)
        : m_t(t)
    {}

    T& Get() { return m_t; }
    T const& Get() const { return m_t; }

private:
    T m_t;
};