#include <iostream>
#include <vector>

enum types
{
    type_normal = 0,
    type_special = 1
};

class base
{
    public:
        virtual types getType() = 0;
        void mach_was()
        {
            std::cout << "Ich hab was gemacht...";
        }
};

class normal : public base
{
    private:
        int irgendwas;

    public:
        virtual types getType()
        {
            return type_normal;
        }
};

class special : public base
{
    private:
        int noch_was;

    public:
        virtual types getType()
        {
            return type_special;
        }
};

std::vector<base *> vPointers;
std::vector<normal> vNormal;
std::vector<special> vSpecial;

void add(base &b)
{
    switch (b.getType())
    {
        case type_normal:
            vNormal.push_back(dynamic_cast<normal &>(b));
            break;

        case type_special:
            vSpecial.push_back(dynamic_cast<special &>(b));
            break;
    }

    vPointers.push_back(&b);
}

int main()
{
    normal n;
    special s;

    add(n);
    add(s);

    std::vector<base *>::const_iterator it;

    for (it = vPointers.begin(); it != vPointers.end(); it++)
    {
        (*it)->mach_was();
    }

    std::cin.get();
}

Im Endeffekt geht es mir darum, Objekte der Klassen normal und special und die dazugehörigen Pointer irgendwo zu speichern. Die Pointer speichere ich in einer einzigen Liste, damit ich hinterher bequem drüber iterieren kann, um bestimmte Methoden aufzurufen, die alle von der Basisklasse geerbt haben (z. B. mach_was()).
Jetz kommen aber immer neue Typen hinzu und ich will bei der add-Funktion net jedes mal getType() abfragen, um dann den entsprechenden Vektor für die Objekte rauszufinden. Mit Templates hab ichs schon probiert, aber des geht net an allen Stellen. Beispielsweise empfang ich manchmal Informationen über Objekte per Netzwerk und muss dann da auch entscheiden, in welchen Vektor ich sie abspeicher.

Hat jemand ne Idee?

Warum musst du denn die Zeiger auch noch in einem seperatem Container halten?

Bei dem Design wirst du um so etwas nicht herum kommen.

Das klingt ja so wie "bei der besch... Programmierung wundert mich gar nix mehr"

drakon schrieb:

Warum musst du denn die Zeiger auch noch in einem seperatem Container halten?

Weil ich wie gesagt gerne über alle Objekte drüber iterieren möchte und dazu net jeden Vektor einzeln durchgehen will.

drakon schrieb:

Bei dem Design wirst du um so etwas nicht herum kommen.

Das klingt ja so wie "bei der besch... Programmierung wundert mich gar nix mehr"

Wenn du wirklich diese Anforderungen hast, dann finde ich das gar keine so schlechte Lösung. Ich würde halt schauen, dass das doch einigermassen gut wartbar ist, damit du nicht viel Code ändern musst, aber ich denke nicht, dass da so viele neue unerwartete Klassen ständig dazu kommen.

drakon schrieb:

Warum musst du denn die Zeiger auch noch in einem seperatem Container halten?

Weil ich wie gesagt gerne über alle Objekte drüber iterieren möchte und dazu net jeden Vektor einzeln durchgehen will.

Nein nicht den, sondern die speziellen. Also vNormal und vSpecial. Üblicherweise schaut man dazu, dass die Sachen, die die machen halt polymorph geschehen können und dann wird dein seperates halten überflüssig.

Nein nicht den, sondern die speziellen. Also vNormal und vSpecial. Üblicherweise schaut man dazu, dass die Sachen, die die machen halt polymorph geschehen können und dann wird dein seperates halten überflüssig.

Dazu müsste ich aber mit new arbeiten, das wollte ich verhindern. RAII finde ich da schöner.

Du speicherst da Kopien von den Instanzen in vNormal und vSpecial und Zeiger auf andere Objekte in vPointers.
Das musst du so sowieso mit Zeiger machen, aber new brauchst du wegen dem troztdem nicht.

std::vector<base *> vPointers;
std::vector<normal*> vNormal;
std::vector<special*> vSpecial;

void add(base* b)
{
    switch (b.getType())
    {
        case type_normal:
            vNormal.push_back(dynamic_cast<normal*>(b));
            break;

        case type_special:
            vSpecial.push_back(dynamic_cast<special*>(b));
            break;
    }

    vPointers.push_back(b);
}

int main()
{
    normal n;
    special s;

    add(&n);
    add(&s);

    std::vector<base *>::const_iterator it;

    for (it = vPointers.begin(); it != vPointers.end(); it++)
    {
        (*it)->mach_was();
    }

    std::cin.get();
}

Das überprüfen des castest auf Erfolg (und sonst schmeissen einer Exception) wäre sicher etwas, was du noch verbessern kannst.
Aber nochmal: Wozu brauchst du die speziellen Container?

Jetzt machst du aber ein durcheinander.
Ich habe den Code vorhin nicht genau angeschaut, aber das geht so sowieso nicht.

Du speicherst da Kopien von den Instanzen in vNormal und vSpecial und Zeiger auf andere Objekte in vPointers.
Das musst du so sowieso mit Zeiger machen, aber new brauchst du wegen dem troztdem nicht.

Upsala, in meinem eigentlichen Code speicher ich schon die richtige Adresse von der Kopie. Hab ich dem Beispiel vergessen/falsch gemacht, da hast du recht.

drakon schrieb:

Das überprüfen des castest auf Erfolg (und sonst schmeissen einer Exception) wäre sicher etwas, was du noch verbessern kannst.

Da stimm ich dir zu, aber das hab ich bewusst weggelassen, da es für mein Beispiel nicht relevant is.

drakon schrieb:

Aber nochmal: Wozu brauchst du die speziellen Container?

Um die Objekte bzw. deren Kopien zu speichern. Du speicherst jetzt die Adressen der lokalen Objekte aus main(). Das geht ja noch, weil main() bis zum Programmende nicht verlassen wird. Ich ruf add() aber nicht in main() auf, deswegen kann ich net die Adressen der jeweiligen lokalen Objekte nehmen (die sind ja nach Verlassen der Funktion nimmer gültig).

Du willst RAII? Da hast du RAII:
http://www.boost.org/doc/libs/1_43_0/libs/ptr_container/doc/ptr_container.html

Du kannst jetzt darauf beharren, dass du da die Objekte so erstellen willst und musst dich eben um das obige Problem kümmern, oder du machst es dir einfacher und benutzt einen solchen Pointer Container.