Wieso schreibt man template<class T, class U>, um dann T und U doch nur wieder zu typedefen? Ein Vorteil ist wohl, dass man bei einer Klasse jederzeit über den Scopeoperator nochmal den Typ abfragen kann. Aber gibt es noch andere?

Und was mache ich, wenn ein Templateparameter typisiert ist, also z.B. int X. Kann ich dann static const int WieAuchImmerDasHeissenSoll = X; machen oder was empfiehlt ihr da?

Wieder so ne Miniaturfrage, aber ich hoffe, das ist ok.

Viele Grüße
Eis

Den typisierten Parameter kannst du dann ganz normal wie eine konstante Variable benutzen und zuweisen wie du willst.

template<class T>
struct vector
{
    typedef T ElementType;
};

cout << vector<int>::ElementType;

Ein Vorteil ist wohl, dass man bei einer Klasse jederzeit über den Scopeoperator nochmal den Typ abfragen kann. Aber gibt es noch andere?

...

Mach Folgendes mal ohne typedef:

template<class T>
struct vector
{
    typedef T ElementType;
};

cout << vector<int>::ElementType;

Externe Type-Traits:

template <class Container>
struct ElementType;

template <typename T>
struct ElementType< vector<T> >
{
    typedef T Type;
};

Ist vor allem geeignet als Workaround für Designs wie hier.

typename<typename Foo, typename Bar>
struct xy {
  typedef Foo foo_type;
  typedef Bar bar_type;
};

oä

template <class T> struct Foo
{
	typedef T Bar;
	Bar DoSomething();
};

template <class T> struct Foo<std::vector<T> >
{
	typedef std::vector<T> Bar;
	Bar DoSomething(); // ohne typedef müsste man hier T zu std::vector<T> ändern
};

Michael E. schrieb:

Mach Folgendes mal ohne typedef:

template<class T>
struct vector
{
    typedef T ElementType;
};

cout << vector<int>::ElementType;

Externe Type-Traits:

template <class Container>
struct ElementType;

template <typename T>
struct ElementType< vector<T> >
{
    typedef T Type;
};

Naja, ohne Typedef Aber richtig, in der eigentlichen Klasse ist kein Typedef mehr

Naja, ohne Typedef

Wenn du mir so kommst... Nimm das! :p

int