Desingfrage?

BorisDieKlinge

folgende Basis Klasse (verwaltet Elemente/Knoten):

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?

BorisDieKlinge

Niemand ne Idee, Kritik, Alternativen?

Noch was zur Sturktur:

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

Meep Meep

hola

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

BorisDieKlinge

naja die verschachtelung ist hat den grund, da die Base klasse BaseElem objekte verwaltet... (ne art zusammengehörigkeit)

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

Meep Meep

jeh nach dem was genau du machen willst und wie du dann deine Elems einsetzen willst.

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

BorisDieKlinge

Nehmen wir an es sähe so aus:

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

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

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

typedef Base<ModElem1> BaseMod1;
typedef Base<ModElem2> BaseMod2;

Meep Meep

BorisDieKlinge

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

Meep Meep

BorisDieKlinge schrieb:

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