vererbungsfrage



  • hallo zusammen,

    ich habe mal wieder eine einfache frage. 🙂

    Ich habe eine Klasse A,B,C:

    class A{
    protected:
    
    std::map<std::string, int> storage;
    }
    
    class B: public A{
    }
    
    class C: public B{
    int get(std::string key){
     return A::storage["key"];
    }
    }
    

    Kann man es hinbekommen, dass C direkt storage aufrufen kann? weil wenn ich aus A::storage[] nur storage[] mache, bekomme ich:

    error: ‘storage’ was not declared in this scope
    error: expected primary-expression before ‘>’ token
    

    Vielen Dank schon einmal, und ich hoffe die Problembeschreibung ist diesmal besser. 🙂



  • sven_ schrieb:

    weil wenn ich aus A::storage[] nur storage[] mache, bekomme ich:

    error: ‘storage’ was not declared in this scope
    error: expected primary-expression before ‘>’ token
    

    Aber nicht mit dem gezeigten Code. Da hast du etliche andere Fehler eingebaut.

    Wenn du Beispielcode zeigst, dann stell sicher, dass der Code auch dasselbe Fehlverhalten zeigt.



  • ok, hats noch ein wenig gekürzt und verheimlicht das templates mitspielen. war wohl zuviel des guten. 😞

    #include <map>
    #include <string>
    
            class A {
            public:
                A(){};
                ~A(){};
    
            protected:
                std::map<std::string, int> storage;
            };
    
    //------
            template <typename T>
            class B : public A {
            public:
    
                B();
                B(const B<T>& orig);
    
                virtual ~B();
            };
    
            template <typename T>
            B<T>::B() : A() {
    
            }
    
            template <typename T>
            B<T>::B(const B<T> & orig) : A(orig) {
                operator=(orig);
            }
    
            template <typename T>
            B<T>::~B() {
            }
    
    //---------
            template <typename T>
            class C: public B<T> {
            public:
    
                C();
                C(const C<T> & orig);
                ~C();
                virtual void setD(std::vector<int> a);
    
            };
    
            template <typename T>
            C<T>::C() : B<T>() {
            }
    
            template <typename T>
            C<T>::C(const C<T> & orig) : B<T>(orig) {
                operator=(orig);
            }
    
            template <typename T>
            C<T>::~C() {
            }
    
            template <typename T>
            void
            C<T>::setD(std::vector<int> a) {
                storage["peerIDList"]=3;
            }
    
    //-----------
    class D : public C<int> {
    };
    //-----------
    int main(int argc, char** argv) {
    	D foo;
            std::vector<int> d;
    	foo.setD(d);
    
        return 0;
    }
    

    Ergibt bei mir:

    error: ‘storage’ was not declared in this scope
    

    Mit A::storage tut es.

    Besser?



  • sven_ schrieb:

    Besser?

    Ja 🙂

    Ohne Template tritt das Problem nicht auf. Member einer von Template-Parametern abhängigen Basisklasse werden nicht gefunden, sagt der Standard, es geht also nicht nur mit storage.

    this->storage tut's aber auch.



  • Die Templates werden erst nach der Referenzierung von storage aufgelöst, somit kann der Compiler nicht "aufwärts" suchen. Durch Angabe der Klasse oder Abruf über den Klassen-Instanz Pointer lässt sich dies umgehen.



  • verstehe, dann ist also alles richtig. das freut mich.

    ich bedanke mich vielmals für eure tolle hilfe!!!! 😃

    gruß

    sven


Log in to reply