Dynamischer Klassenmember

BorisDieKlinge

Ist sowas möglich? Entsprechend dem Konstruktoaufruf die Klasse dummy mit Objetken A oder B füllen:

class dummy{

 std::vector< TYPE> data;

public:

   dummy(bool boTyp){

    if( boTyp)
      //data mit dem Vectorelementen TYPE: A
    else
      //data mit den Vectorelementen TYPE :B

   }

};

Apeman

sollte gehen, wenn du aus class dummy auch ein template machst.

BorisDieKlinge

und wenn ich erst über den konstruktor entscheiden will was für ein typ? geht das denn dann mittemplate?

CStoll

Nein, mit Templates geht sowas nicht - der Typ einer Variablen muß zur Compilezeit feststehen. Zur Laufzeit könntest du höchstens über Polymorphie etwas erreichen.

(aber was soll der Sinn der Aktion sein?)

BorisDieKlinge

war nur mal so ne frage:) aber noch was anderes:

template <class TYPE>

class Elem{

  std::vector<TYPE> data;

};

class container{

 std::vector< Elem<???> > data;

};

kann ich es auch nicht ereichen Elemente mit unterschiedlichen TYPEN in den container zu speichern?

quasie Elem<A> und Elem<B> in die container liste

CStoll

Nochmal: was hast du vor (inhaltlich)?

In einen std-Container kannst du grundsätzlich nur gleichartige Objekte reinpacken, für kompliziertere Konstruktionen benötigst du eigene Lösungen (Polymorphie, mehrere Container verwenden, ein vector<pair<Elem<A>,Elem<B>>>, ...).

BorisDieKlinge

ne du hast es schon verstanden:) naja egal, war nur so ein gedankenspiel;)

Simon2

BorisDieKlinge schrieb:

war nur mal so ne frage:) aber noch was anderes:
template <class TYPE>

class Elem{

  std::vector<TYPE> data;

};

class container{

 std::vector< Elem<???> > data;

};
kann ich es auch nicht ereichen Elemente mit unterschiedlichen TYPEN in den container zu speichern?...

Nö - in einem vector sind immer Elem<TYPE> - das ist ein (zur Compilezeit feststehender) Typ.
Spätestens wenn Du versuchst, "???" zu füllen, wirst Du feststellen, dass da etwas konkretes drinstehen muss...

Gruß,

Simon2.

asc

Mehrere Typen bekommst du nur dann in ein und die selbe Liste wenn sie entweder
a) Durch ein Varianttyp abgebildet werden (mit allen damit verbundenen Nachteilen)
b) Eine gemeinsame Basisklasse haben (und man sollte auch ein gleiches Interface verwenden für alle Aufrufe)
c) Du void-Pointer verwendest und dir gleichzeitig den Typ jedes Eintrages merkst... was aber auch nichts anderes als ein Typunsicherer Varianttyp ist.

Ich gehe schlicht und einfach von schlechten Design aus.

Simon2

asc schrieb:

...
a) Durch ein Varianttyp abgebildet werden (mit allen damit verbundenen Nachteilen)
b) Eine gemeinsame Basisklasse haben (und man sollte auch ein gleiches Interface verwenden für alle Aufrufe)
c) Du void-Pointer verwendest und dir gleichzeitig den Typ jedes Eintrages merkst...

Ist das nicht letztlich eh' alles dasselbe ? (nur dass die Typprüfung zur Laufzeit in unterschiedlichen Verantwortungbereichen (boost-Entwickler/Compiler, Compiler, Anwender) liegt ?

Gruß,

Simon2.

asc

Simon2 schrieb:

Ist das nicht letztlich eh' alles dasselbe ? (nur dass die Typprüfung zur Laufzeit in unterschiedlichen Verantwortungbereichen (boost-Entwickler/Compiler, Compiler, Anwender) liegt ?

Zumindestens würde ich b von a und c different ansehen. Ich sehe zumindest ein unterschied ob ich mittels switch oder über polymorphie arbeite
Und letzteres erfordert auch ein entsprechendes Design...

cu André

pumuckl

Fuer deine allererste frage faellt mir folgendes ein (glaube das nennt man virtueller Konstruktor, bin mir aber nicht sicher)

class DummyBase {
protected:
  DummyBase() {}

public:
  virtual ~DummyBase() {};

  //rest des Interfaces
}

template <typename T>
class Dummy : public DummyBase
{
  vector<T> data;

public:
  Dummy();            //konstruktoren..
  Dummy(const T& t);  //was du halt so brauchst
}

//jetzt der Trick:
template <typename T>
DummyBase* MakeDummy(const T& t) {
  return new Dummy<T>(t);  //oder so aehnlich, je nach Bedarf
}

//Anwendung:

class A;
class B;

int main()
{
  DummyBase* pDBA, pDBB;
  A a;
  pDBA = MakeDummy(a); //zeigt jetzt auf ein Dummy<A>
  pDBB = MakeDummy(B()); //zeigt auf ein Dummy<B>
}

So kann man das ganze per Polymorphie loesen.

Simon2

asc schrieb:

Simon2 schrieb:

Ist das nicht letztlich eh' alles dasselbe ? (nur dass die Typprüfung zur Laufzeit in unterschiedlichen Verantwortungbereichen (boost-Entwickler/Compiler, Compiler, Anwender) liegt ?

Zumindestens würde ich b von a und c different ansehen. Ich sehe zumindest ein unterschied ob ich mittels switch oder über polymorphie arbeite
Und letzteres erfordert auch ein entsprechendes Design...

cu André

Naja, ich meinte halt "gleich" im Sinne von:
- Der std::vector "sieht" trotzdem immer nur denselben Typ
- Zur Laufzeit entscheidet ein Dispatchingmechanismus über einen Pointer, als welche Daten man das Zeug, auf das er zeigt, interpretieren soll.

Nicht missverstehen: Ich würde immer, immer, immer die "eingebaute Polymorphie" der Sprache vorziehen.
... eben weil der Mechanismus erprobt und von anderen Sprachfeatures (z.B. dynamic_cast) unterstützt wird => höhere Verlässlichkeit.

Gruß,

Simon2.