Ich war ursprünglich auf der Suche nach sowas:

template<typename T, typename A>
class CTemplate
{ };

template<typename T>
typedef CTemplate<int, T> t_Template;

Musste aber feststellen, dass es dies anscheinend nicht gibt. Nach weiterem rumprobieren, hat plötzlich etwas funktioniert, wo ich allerdings Mühe habe zu verstehen, was das soll.

template<typename T, typename A>
class CTemplate
{
public:
    A m_A;
};

typedef CTemplate<int, typename> t_Template;

int main()
{
    t_Template Template;

    /* (1)
    std::cout << Template.m_A << std::endl;
    */

    return 0;
}

Das kompiliert einwandfrei, sogar wenn ich (1) unkommentiere. Wenn es kommentiert ist, läuft es sogar ohne Absturz durch. Wenn ich es unkommentiere, dann kommt ein Laufzeitfehler, welcher mir meldet, dass die Variable Template uninitialisiert ist.

Kann mir einer sagen, was das sein soll?

Grüssli

Welcher Compiler lässt dir das durch?

P.S.: Bis der neue Standard kommt musst du dir wohl oder übel mit sowas behelfen:

template <typename A, typename B>
class Template
{
// ...
};

template <typename T>
class IntTemplate : public Template<int, T>
{
// Alle Konstruktoren von Template zum durchreichen nachbauen und hoffen, dass
// niemand die für bestimmte B verändert hat
};

// oder
template <typename T>
struct IntTemplate
{
    typedef Template<int, T> type;
};
// Zugriff mit typename IntTemplate<bla>::type

Durchlassen tut mir das der MS Visual Studio 2005 Compiler.

Edit:
Bezüglich des Edits von filmor,
Daran hatte ich auch schon gedacht, bzw. vor allem an die zweite Möglichkeit. Aber das würde die Situation nicht vereinfachen, welche ich versuche zu vereinfachen:

template<typename TNode>
CNodeIterator<t_NodeList::const_reverse_iterator, TNode> rbegin(t_NodeList const& rNodeList)
{ return CNodeIterator<t_NodeList::const_reverse_iterator, TNode>(rNodeList.rbegin(), rNodeList.rend()); }

Das ist das extremste. Wäre halt praktischer, wenn man den Rückgabetyp kürzer schreiben könnte

Muss es halt der Anwender der Funktion machen und zwar ca. so:

// Irgendwo in einer Funktion
typedef CNodeIterator<t_NodeList::const_reverse_iterator, CElement> t_ElemIter;

t_ElemIter ElemIter = rbegin<CElement>(NodeList);

Daher, nicht weiter schlimm

Grüssli

Edit:
Bezüglich des Edits von filmor,
Daran hatte ich auch schon gedacht, bzw. vor allem an die zweite Möglichkeit. Aber das würde die Situation nicht vereinfachen, welche ich versuche zu vereinfachen:

template<typename TNode>
CNodeIterator<t_NodeList::const_reverse_iterator, TNode>
rbegin(t_NodeList const& rNodeList)
{ return CNodeIterator<t_NodeList::const_reverse_iterator, TNode>(rNodeList.rbegin(), rNodeList.rend()); }

Das ist das extremste. Wäre halt praktischer, wenn man den Rückgabetyp kürzer schreiben könnte

Ich arbeite gerade an einer Bibliothek mit, wo wir dieses Problem dauernd und in noch schlimmerer Form haben.

Ein übliches Idiom ist bei uns sowas hier:

template <typename TIter, typename TNode>
struct NodeIter {
    typedef CNodeIterator<TIter, TNode> Type;
};

template<typename TNode>
CNodeIterator<t_NodeList::const_reverse_iterator, TNode> rbegin(t_NodeList const& rNodeList)
{
    typedef typename NodeIter<t_NodeList::const_reverse_iterator, TNode> TRet;
    return TRet(rNodeList.rbegin(), rNodeList.rend());
}

Structs dieser Art nennt man „Metafunktionen“, da sie analog zu Funktionen Eingabe- und einen Rückgabewert haben, nur eben auf Typenebene (daher „meta-“), also statt Werteparametern Typenparameter und einen Typ als Rückgabewert. Analog zu 'return' schreibt man 'typedef … Type;'. Der „Aufruf“ einer Metafunktion läuft eben über den Zugriff auf diesen typedef ab.

Wobei man diese Metafunktionen sogar durch (partielle) Spezialisierung „überladen“ kann. Sie machen Den Code also gar nicht unbedingt kürzer, heben aber eine Kopplung an konkrete Typen auf.

(Falls jemand neugierig ist: http://www.seqan.de/)