Kann die Funktion der geschachtelten Klassenmitglieder innerhalb der abgeleiteten Klasse nicht definieren

Question

Ich habe eine Basisklasse, die aus einer anderen Klasse besteht (nennen wir sie Komponente). Wenn ich von der Base-Klasse erben, ist es möglich, der Component-Klasse Funktionalität hinzuzufügen (vorausgesetzt, Sie können den Base-Code nicht ändern)? Ich möchte grundsätzlich eine 'Derived :: Component :: foo' Funktion.

#include <iostream> 

class Base 
{ 
    public: 
     void Print() { std::cout << c.data; } 

     class Component 
     { 
      public: 
       int data; 
     }; 
     Component c; 
}; 

class Derived : public Base 
{ 
    private: 
     void Component::foo(int value) 
     { 
      this->data = value; 
     } 
    public: 
     void bar(int value) 
     { 
      this->c.foo(value); 
     } 
    }; 

int main() { 
    Derived d; 
    d.bar(4); 
    d.Print(); 
} 

Dieser Code gibt den folgenden Fehler unter G ++ 4.8 auf Ubuntu:

Fehler: kann nicht Memberfunktion 'Basis :: Component :: foo' in 'Abgeleitet'

Answer 1

Sie müssen definieren, erklären, die foo Funktion in der Component Klasse. Und dann definieren sie im Inneren des Component selbst:

#include <iostream> 

class Base 
{ 
public: 
    void Print() { std::cout << c.data; } 

    class Component 
    { 
    public: 
     int data; 
     void foo(int value) 
     { 
      data = value; 
     } 
    }; 

    Component c; 
}; 

class Derived : public Base 
{ 
private: 
public: 
    void bar(int value) 
    { 
     c.foo(value); 
    } 
}; 

int main() { 
    Derived d; 
    d.bar(4); 
    d.Print(); 
} 

oder außerhalb aller Klassen:

#include <iostream> 

class Base 
{ 
public: 
    void Print() { std::cout << c.data; } 

    class Component 
    { 
    public: 
     int data; 
     void foo(int value); 
    }; 

    Component c; 
}; 

void Base::Component::foo(int value) 
{ 
    data = value; 
} 

class Derived : public Base 
{ 
private: 
public: 
    void bar(int value) 
    { 
     c.foo(value); 
    } 
}; 

int main() { 
    Derived d; 
    d.bar(4); 
    d.Print(); 
} 

Answer 2

[..] add functionality [..] (assumming you can't modify the Base code) [..]

Je nachdem, wie die tatsächliche Basisklasse in Frage aussieht, können Sie versuchen, erhalten, indem mit einfachen Subklassifizieren der Component:

/* using struct to have public accessibility */ 
struct Base { 
    struct Component { 
    int data; 
    virtual ~Component() {} // ABSOLUTELY NECESSARY 
    }; 
    std::unique_ptr<Component> component; // ABSOLUTELY NECESSARY 

    void print(void) { 
    std::cout << component->data << endl; 
    } 
}; 

/* The decorated component, with the additional functionality */ 
struct DecoratedComponent : public Base::Component { 
    void set(int d) { 
    data = d; 
    } 
}; 

Dann wird ein Wenn es eine Möglichkeit gibt, die Komponente zu setzen, müssen Sie Ihre dekorierte Komponente übergeben (Hinweis: Wenn der Status beibehalten werden soll, können Sie auch eine Component Instanz in Ihre dekorierte Komponentenklasse einfügen, was eine echte Verwendung des Decorator-Musters darstellt):

Base the_base; 
auto the_component = std::make_unique<DecoratedComponent>(); 
// Inject the decorated component 
the_base.component = the_component; 
the_component.set(42); 
the_base.print(); // 42 

Dies funktioniert nur, wenn die Basis es ist Komponente entweder einen Verweis oder eine Art Zeiger zu speichern/Zugriff verwendet. Wenn die Basis die Lebensdauer der Komponente verwaltet, muss die Component darüber hinaus über einen virtuellen Destruktor verfügen.