Erweitern struct in erben Klasse

Question

Ist es möglich, eine Struktur in einer übergeordneten Klasse zu deklarieren und definieren Sie es in der erbenden Kindklasse (in jeder Kindklasse sollte es anders aussehen)?

Ein Beispiel würde wie folgt aussehen:

class parent 
{ 
    virtual struct AlwaysDifferentStructure; 

    //Some methods here 
    //... 
}; 

class child1 : public parent 
{ 
    struct AlwaysDifferentStructure 
    { 
     int foo; 
    } 

    //Some methods here 
    //... 
}; 

class child2 : public parent 
{ 
    struct AlwaysDifferentStructure 
    { 
     char* foo; 
     float bar; 
     double foobar; 
    } 

    //Some methods here 
    //... 
}; 

Also eigentlich das, was ich mit der folgenden gehe ich versucht: ich eine Elternklasse bekam shader und viel erben Klassen (das heißt simple_color_shader). Jeder Shader hat eine eigene Vertex-Struktur. Nun möchte ich ein Objekt mit einem dieser Shader rendern, aber ich weiß nicht, wie die Vertex-Struktur genau aussieht, weil sie immer anders ist, aber ich brauche sie. Also dachte ich, dass ich die Struktur in allen Kindern einfach neu deklarieren und Zugang durch die Eltern erhalten könnte. So in der object Klasse sieht es im Grunde wie folgt:

class object 
{ 
    parent* m_pParent; 
    AlwaysDifferentStructure* m_structArray; 
}; 

(Fragen Sie, wenn Sie nicht verstehen, was ich versuche, Ihnen zu sagen, mein Englisch ist nicht so gut)

Meine Frage ist, : Ist das überhaupt möglich und wenn ja, würde ich mich freuen wenn mir jemand sagen könnte wie.

Answer 1

so etwas wie dieses kann mit dem Curiously recurring template pattern

template <typename derived> 
class parent 
{ 
    void someMethod() 
    { 
     typename derived::AlwaysDifferentStructure x; 

     x.foo; 
    } 
}; 

class child1 : public parent <child1> 
{ 
    struct AlwaysDifferentStructure 
    { 
     int foo; 
    } 

    //Some methods here 
    //... 
} 

class child2 : public parent <child2> 
{ 
    struct AlwaysDifferentStructure 
    { 
     char* foo; 
     float bar; 
     double foobar; 
    } 

    //Some methods here 
    //... 
} 

Answer 2

_{erreicht werden für das OP die Schnipsel in den Kommentaren gepostet gefunden gute Vorschläge zu sein, ich bin sie hier für zukünftige Leser veröffentlichen.}

---

Hier ist ein möglicher Ansatz, wie er in den Kommentaren erwähnt:

class parent { }; 
class child1 : public parent { }; 
class child2 : public parent { }; 

template<typename> 
struct AlwaysDifferentStructure; 

template<> 
struct AlwaysDifferentStructure<child1> { 
    int foo; 
}; 

template<> 
struct AlwaysDifferentStructure<child2> { 
    char* foo; 
    float bar; 
    double foobar; 
}; 

int main() { 
    AlwaysDifferentStructure<child1> c1t; 
    c1t.foo = 42; 
    AlwaysDifferentStructure<child2> c2t; 
    c2t.foo = new char{'c'}; 
    c2t.bar = .42; 
    c2t.foobar = 0.; 
} 

Als eine andere praktikable Lösung, können Sie dies tun:

class parent { 
    //Some methods here 
    //... 
}; 

class child1 : public parent { 
public: 
    auto alwaysDifferentStructure() { 
     struct S { 
      int foo; 
     } s; 

     return s; 
    } 
}; 

class child2 : public parent { 
public: 
    auto alwaysDifferentStructure() { 
     struct S { 
      char* foo; 
      float bar; 
      double foobar; 
     } s; 

     return s; 
    } 
}; 

int main() { 
    auto c1t = child1{}.alwaysDifferentStructure(); 
    c1t.foo = 42; 
    auto c2t = child2{}.alwaysDifferentStructure(); 
    c2t.foo = new char{'c'}; 
    c2t.bar = .42; 
    c2t.foobar = 0.; 
} 

Beachten Sie, dass dieses zweite Beispiel erfordert C++ 14.