Objekt<???> zur Laufzeit festlegen?

Hallo Zusammen,

habe folgendes Problem. Und zwar benutze ich den C++ Builder
und habe in der Basisklasse des Formulars ein Objekt definiert.
Ich möchte dieses Objekt in allen Membermethoden der Basisklasse
verwenden. Das Objekt soll aber in der Methode Auswahl den Datentypen
zugewiesen bekommen.

Builder Klasse für das Formular:

class TForm1 : public TForm {
__published:
              TLabel *L1;
              ...
public:
              X<unsigned char> *x;
              void Auswahl(int w)
              {
                   switch (w)
                   {
                        case 0: x; //?? z.B. char X<char> *x
                              break; 
                        case 1: x; //?? z.B. short X<short> *x
                              break;
                              // etc. 
                   } 
              }
              ... 

};

Das Objekt gehört der Klasse X

template <class f>
class X {
public:
            // z.B.
            void Ausgabe()
            {
                 cout<<sizeof(f);
            } 
}

Nun möchte ich in der Membermetode der Klasse TForm1
durch eine Switch-Case Anweísung festlegen welchen Datentyp
ich verwenden möchte (Zur Laufzeit entscheiden.).

Aber ich muss schon bei der Definition auf einen Datentyp festlegen.

Also meine Frage, wie kann ich den Datentypen später definieren.

Danke!

rüdiger

hmm, dass geht so leider nicht, da Templates zur Compilezeit generiert werden müssen und dafür komplett vorliegen müssen.

Aber AFAIK kann die more-Library (hmm, die Homepage ist wohl gerade down. Dann hier) auch Code zur Laufzeit kompilieren. Aber AFAIK geht das nur mit dem GCC

Helium

Erstmal, wenn du objekte verschiedenen Typs hast, wie arbeitest du dann damit? Ich kann mir das im Moment nur vorstellen, wenn alle innerhalb einer Hierachie existieren (virtuelle Methoden) oder wenn nur eine fest vorgegebene Menge an Typen existiert, auf die dann z.B. per typeid gesondert reagiert wird. In beiden Fällen sehe ich kein Problem.

Beispiel, wenn alles in einer Hierachie ist: Übergib eine Erstellungsroutine, die dann Objekte des gewünschten Typs erzeugt. Welche Routine übergeben wird, kann zur Laufzeit entschieden werden.

Aber Möglicherweise hab ich das ja alles falsch verstanden.

Hallo,

das Problem liegt daran. Das ich zwei Klassen habe. In der Klasse des Formulars soll mit einem Objekt einer anderen Klasse (X) gearbeitet werden.
Nun weiß ich nicht ob die Daten die in der anderen Klasse X vom Typ char oder short sein sollen. Das entscheidet der Benutzer erst wenn das Programm läuft.

Was mir nun eingefallen war. Ich erstelle eine Klasse mit Templates, bin dadurch Typenunabgängig. Doch bei der Definition des Objektes muss ich einen
Typ für das Template angeben. Und falls der Benutzer nicht den Datentyp char,
sondern short haben möchte. Weiß ich nicht wie ich das ändern kann.

Ich könnte ja ein Objekt mit den Datentypen char und ein Objekt mit den Datentypen short erstellen. Aber dann müsste ich bei jedem Methodenaufruf das Richtige Objekt wählen. Sieht nicht schön aus. Deshalb suche ich einen anderen Weg (Vielleicht Eleganter).

Helium

class BasisMitAllenOperationen {
public:
   virtual void irgendwasWasMitDenDatenGemachtWerdenKann () = 0;
};

template <typename T>
class KonkreteImplementierung {
public:
   virtual void irgendwasWasMitDenDatenGemachtWerdenKann ()
   {
      blabla ();
   }

private:
   T daten;
};

class ErstellerBasis {
public:
   virtual BasisMitAllenOperationen * create () = 0;
};

template <typename T>
class Ersteller {
public:
   virtual BasisMitAllenOperationen * create () 
   {
      return new KonkreteImplementierung <T>;
   }
};

void deineFunktion (ErstellerBasis & ersteller)
{
   BasisMitAllenOperationen * dasObjekt = ersteller.create ();
   ...
}

// Aufruf
deineFunktion (Ersteller<char>());

deineFunktion (Ersteller<short>());

Keine Ahnung. Ich müsste mehr wissen, um einen guten Vorschlag machen zu können.

Objekt&lt;???&gt; zur Laufzeit festlegen?

Objekt<???> zur Laufzeit festlegen?