Expliziter cast vermeidbar?



  • Hallo,

    angenommen, ich habe Basisklassen für Objekte und einer Containerklasse zum speichern dieser Objekte, z.B.:

    using namespace std;
    
    class Object {
    public:
        Object(string name_) : name(name_)
        {}
    private:
        string name;
    };
    
    class Container {
    private:
        list<Object *>   objects;
    public:
        Container() : objects(list<Object *>())
        {}
        // ...
        Object *getobject(string name) {
            Object *obj;
            // suche object
            return obj;
        }
    };
    

    und darauf aufbauend abgeleitete Objektklassen und Containerklassen mit zusätzlicher Funktionalität, z.B.:

    class MyObject : public Object {
    public:
        MyObject(string name_, int a_) : Object(name_), a(a_)
        { }
    private:
        int a;
    };
    
    class MyContainer : public Container
    {
    public:
        MyContainer(int b_) : Container(), b(b_)
        {}
    private:
        int b;
    };
    

    Beim Zugriff auf MyContainer::getobject() muss ich jetzt explizit auf die abgeleitete Klasse casten:

    MyObject *mo = static_cast<MyObject *>(myobjects.getobject("abc"));
    

    Geht das eleganter?
    Die Lösung mit einer Überladung in MyContainer für getobject() gefällt mir auch nicht besonders:

    class MyContainer : public Container
    {
    public:
        MyContainer(int b_) : Container(), b(b_)
        {}
        MyObject *getobject(string name) {
            return static_cast<MyObject *>(Container::getobject((name)));
        }
    private:
        int b;
    };
    

    Was sagen die Spezialisten dazu? 🙂



  • Du könntest aus deinem Container ein Klassentemplate machen.



  • Ich würde sagen das Problem ist hier, dass du in dem Container Basisklassenzeiger speicherst. Wieso genau ist das notwendig? Wieso kannst du nicht einfach z.B. einen std::vector<MyObject*> verwenden?


Anmelden zum Antworten