class Base{

public:
  class Elem{

  protected;
     int ElemBaseData;

  };
private:
  std::list<*Elem> data;
.
.
.
protected:
  int BasePara;
};

Von dieser Klassenstruzktur, werden dann erweiterte Klassen strukturen Mo11/ Mod2 abgeleitet:

class Mod1 : public Base{

  class Mod1Elem : public Base::Elem{

     int Mod1ElemData;

   };
  int Mo11Data;
};

class Mod2 : public Base{

  class Mod2Elem : public Base::Elem{

     int Mod2ElemData;

   };
  int Mo12Data;
};

Ist so eine art der Vererbung sinnvoll? Könnte man doch im prinzip auch mit einem Template machen oder?

Noch was zur Sturktur:

Die Klasse Mod1 soll nur Objekte des Typs Mod1Elem enthalten, und Mod2 Objekt des Typs Mod2Elem!

warum eigendlich nested classes?
ich seh zumindest in deinem beispiel keinen grund dafuer.
insofern ist es schwierig zu sagen welches design besser waere.
Falls du aus irgendeinem grund mit dem design nicht zu frienden bist, solltest du den eventuell auch erwaehnen.

Meep Meep

Zufrieden bin ich nich ganz... bzw. würd gern wissen wie man sowas noch anders machen könnte...??

class BaseElem
{
   ...
};

class Base
{
   ...
   protected:
      std::list<BaseElem*> liste;
};

class ModElem1 : public BaseElem
{
   ...
};
class ModElem2 : public BaseElem
{
   ...
};

template<class T>
class ModBase : public Base
{
   public:
      T mod_elem_x;
      ...
};

waere eventuell auch eine loesung. nur fraglich ob es ne loesung fuer deine aufgabenstellung ist.

Meep Meep

class Elem{
....
};

class Base{

std::list<Elem*> data;

};

class ElemA : public Elem{

};
class ElemB : public Elem{

};

class BaseA : public Base{

};

class BaseB : public Base{

};

wie könnte ich nunr ereichen, das BaseA nur ElemA Objekte enthält, und BaseB nur ElemB Objekte?? Wenn du verstehst was ich meine....

Meep Meep

ok gut, aber wenn nun BaseMod1 bzw. BasMod2 noch zusätzliche member attribute hat, muss ich ja diese von Base ableiten...

naju dann vielleicht so:

class BaseElem { };
class ModElem1 : public BaseElem { };
class ModElem2 : public BaseElem { };

template<class T>
class Base
{
   ...
   std::list<T*> liste;
};

class BaseMod1 : public Base<ModElem1>
{
   int value;
};

class BaseMod2 : public Base<ModElem2>
{
   float value;
};

Meep Meep