ich möchte diese Typedefs:

typedef std::pair<PANO_UINT,UTM> UTM_PAIR ;
typedef std::map<PANO_UINT,UTM>::iterator UTM_ITERATOR;
typedef std::map<PANO_UINT,UTM>::const_iterator UTM_CONST_ITERATOR;
typedef std::pair<std::map<PANO_UINT,UTM>::iterator,bool> UTM_BOOL_ITERATOR;

typedef std::pair<PANO_UINT,Knot> KNOT_PAIR ;
typedef std::map<PANO_UINT,Knot>::iterator KNOT_ITERATOR;
typedef std::map<PANO_UINT,Knot>::const_iterator KNOT_CONST_ITERATOR;
typedef std::pair<std::map<PANO_UINT,Knot>::iterator,bool> KNOT_BOOL_ITERATOR;

typedef std::pair<PANO_UINT,Edge> EDGE_PAIR ;
typedef std::map<PANO_UINT,Edge>::iterator EDGE_ITERATOR;
typedef std::map<PANO_UINT,Edge>::const_iterator EDGE_CONST_ITERATOR;
typedef std::pair<std::map<PANO_UINT,Edge>::iterator,bool> EDGE_BOOL_ITERATOR;

typedef std::pair<PANO_UINT,Face> FACE_PAIR ;
typedef std::map<PANO_UINT,Face>::iterator FACE_ITERATOR;
typedef std::pair<std::map<PANO_UINT,Face>::iterator,bool> FACE_BOOL_ITERATOR;

durch ein struct template ersetzen:

template<typename T> struct topology { };

template<> struct
topology<typename class T> { 

	typedef std::pair<PANO_UINT,T> pair;
	typedef std::map<PANO_UINT,T>::iterator it;
	typedef std::map<PANO_UINT,T>::const_iterator const_it;
	typedef std::pair<std::map<PANO_UINT,T>::iterator,bool> bool_it;

};

Dieser Teil scheint mir richtig zu sein. Jetzt habe ich probleme dieses template aus einer Funktion aus aufzurufen.

Wie erstelle ich folgende Variable mit dem template?

UTM_BOOL_ITERATOR utmboolit;

Ich dachte eigentlich an

typedef topology<UTM>:: bool_it utmboolit;

Klappt aber nicht. Wäre dankbar wenn jemand die richtige Syntax posten würde.

(ohne typdef )

topology<UTM>::bool_it utmboolit;

(ohne typdef )

brotbernd schrieb:

...

Klappt leider beides nicht.

bool_it is not a member of 'topology<T>'

Ich würde Dir auch von Deinen All-Caps-Bezeichnern abraten. Bezeichner bestehend nur aus Großbuchstaben werden typischerweise nur für Makros verwendet.

So scheint es zu funktionieren.

Was hat es mit dieser Vorwärtsdeklaration auf sich? Wann und warum muss diese gemacht werden? Warum muss ich vor manche zeilen nochmal explizit typename hinschreiben? Beispiel:

#include <map>

using namespace std;

template<typename T> struct topology{
	typedef typename std::pair<int, T> pair;
	typedef typename map<int, T>::iterator it;
	typedef typename map<int, T>::const_iterator const_it;
	typedef std::pair<it, bool> bool_it;

};

int main(int argc, char* argv[])
{

	typedef int UTM ;
	typedef topology<UTM>::bool_it utmboolit;

	return 0;
}

Wenn ich dort nämlich das typename aus den drei zeilen weglasse, lässt sich das ganze nicht kompilieren.

Zur Zeit der Deklaration ist T unbekannt. map<int, T> ist von T abhängig (dependent name). Damit der Compiler das in der Typdefinition annimmt, musst du ihm mit typename mitteilen, dass das ein Typ ist.
edit: hmm.. vielleicht kann das jemand besser erklären

Das ist doch genau das, was ich vorher gepostet habe!?

Zur Zeit der Deklaration ist T unbekannt. map<int, T> ist von T abhängig (dependent name). Damit der Compiler das in der Typdefinition annimmt, musst du ihm mit typename mitteilen, dass das ein Typ ist.
edit: hmm.. vielleicht kann das jemand besser erklären

Ja stimmt, dann hat wahrscheinlich nur diese Vorwärtsdeklaration { }; gestört.
Wofür braucht man sie überhaupt?

template<typename T> struct topology { };

template<> struct
topology<int> {
    typedef std::pair<PANO_UINT,int> pair;
    typedef std::map<PANO_UINT,int>::iterator it;
    typedef std::map<PANO_UINT,int>::const_iterator const_it;
    typedef std::pair<std::map<PANO_UINT,int>::iterator,bool> bool_it;
};

Damit ist der ganze kram nur für topology<int> definiert. Für alle anderen T ist topology leer.