typedef in template-class

Meep Meep

hola leute

ich hab eine template-klasse, in welcher ich grundsaetzliche typdefs habe die fuer alle moeglichen template-parameter vorhanden und gleich sein sollen, sprich sie sind unabhaengig vom template parameter.

template<class T>
class my_class
{
   public:
      typedef int my_int;
};

nun will ich folgendes schreiben koennen:

my_class<my_class::my_int> value;

was aber klaererweise nicht funktioniert, weil ich dem template-paramaeter my_class auch wiederrum einen parameter uebergeben muesste.

ich koennte zwar meine typedefs in eine basisklasse legen und die template-klasse davon erben lassen, dann wuerde es aber ungefaehr so aussehen:

my_class<my_basic_class::my_int> value;

was ich aber auch nicht will.

gibt es dafuer ne loesung ?

Meep Meep

Zunächst obligatorisch der Hinweis: Es handelt sich dabei nicht um eine Template-Klasse, sondern um eine Klassen-Template bzw. Klassenvorlage. In deinem Beispiel ist my_class keine Klasse, sondern eine Vorlage, aus der Klassen erstellt werden können. myclass<int> ist eine Klasse.

Du kannst aus my_class nicht einfach ohne Konkretisierung irgendein Symbol herausnehmen, weil dieses nicht eindeutig definiert sein muss. Einfaches Beispiel:

template<typename T> struct foo { typedef T type; };

...welcher Typ sollte jetzt durch foo::type bezeichnet werden?

Dazu kommt die Möglichkeit von Spezialisierungen, beispielsweise

template<typename T> struct foo { typedef int type; };
template<> struct foo<double> { int type; };

...was sollte foo::type jetzt sein?

Dein Vorhaben ist also so nicht durchführbar. Du kannst eine Template nicht mit etwas konkretisieren, das du erst kennst, wenn du die konkrete Klasse hast -- es ist wie mit der Kiste, in der die Brechstange liegt, mit der man die Kiste aufbrechen könnte. Du musst die Brechstange irgendwo außerhalb der Kiste aufbewahren.

TyRoXx

Äh?

typedef int my_int;
template<class T>
class my_class
{
   public:
};

Wenn es unbedingt sein muss, schreib doch my_class<my_class<void *>::my_int> oder so etwas.

Auf

template<typename T = void*>
struct my_class {
  typedef int my_int;
};

my_class<my_class<>::my_int> foo;

könnte man den Compiler womöglich runterhandeln. In Templates dann

my_class<typename my_class<>::my_int> foo;

Richtig hübsch wird das so oder so nicht.

Meep Meep

seldon schrieb:

Beispiel:
template<typename T> struct foo { typedef T type; };
...welcher Typ sollte jetzt durch foo::type bezeichnet werden?

aus dem grund schrieb ich ja

sprich sie sind unabhaengig vom template parameter.

dachte halt das es dafuer vielleicht ne moeglichkjeit gibt

Meep Meep