[ERLEDIGT] template struct



  • Hallo Leute,

    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.



  • template<typename T> 
    struct topology 
    { 
        typedef std::pair<int,T> pair;
        typedef typename std::map<int,T>::iterator it;
        typedef typename std::map<int,T>::const_iterator const_it;
        typedef std::pair<it, bool> bool_it;
    
    }; 
    
    int main(int argc, char* argv[])
    {
    	using namespace std;
    	typedef int UTM ;
    	typedef topology<UTM>::bool_it utmboolit;
    
            return 0;
    }
    


  • topology<UTM>::bool_it utmboolit;
    

    (ohne typdef )



  • ipsec schrieb:

    topology<UTM>::bool_it utmboolit;
    

    (ohne typdef )

    brotbernd schrieb:

    ...

    Klappt leider beides nicht.

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



  • Sieht so aus, als ob bei Dir ein paar typename s fehlen.

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



  • template<typename T> struct topology{ 
    
    		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<it,bool> bool_it;
    
    };
    

    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.



  • 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 🙄



  • brotbernd schrieb:

    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?



  • { }; ist keine Deklaration sondern Definition. Was du da hattest sieht ein bischen aus wie eine Spezialisierung.

    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.



  • Super, danke für die schnellen Antworten an alle!


Log in to reply