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

   }

};

(aber was soll der Sinn der Aktion sein?)

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

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>>>, ...).

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.

Ich gehe schlicht und einfach von schlechten Design aus.

...
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.

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é

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 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.