[C++] Map iterator error

[vdvleon]

Hallo iedereen,

Ik heb een raar probleem. Ik wil een iterator variable aanmaken van de map class.
fout: expected `;' before ‘it’

C++:

IDKeys::iterator it;

// Waar bij:
typedef std::map<unsigned long, Item*> IDKeys;
typedef vdDBItem<T> Item;
template<class T> class vdDBItem{ ... };

Het lijkt er dus op dat hij geen iterator wil aanmaken met een map met een type van Item*.

Weet iemand waarom dit is?

[Zoijar]

Wat si dit: typedef vdDBItem<T> Item; ? Dat kan niet.

[vdvleon]

Hoezo kan dat niet. Dat werkt gewoon (in de rest van de code).
Misschien bedoel je dit, die typedef's staan allemaal in de class vdDB.

edit:
beter voorbeeld van indeling:

C++:

template<class T> class vdDBItem{
    // ...
};

template<class T> class vdDB{
    public:
        typedef vdDBItem<T> Item;
        typedef std::vector<Item*> Items;
        typedef std::map<unsigned long, Item*> IDKeys;
    
        // ...
        
        Items select(){
            IDKeys::iterator it;
            IDKeys::iterator it_end;
            
            // ...
        }
};

[ Voor 59% gewijzigd door vdvleon op 14-07-2009 01:33 ]

[.oisyn]

vdvleon schreef op dinsdag 14 juli 2009 @ 01:25:
Misschien bedoel je dit, die typedef's staan allemaal in de class vdDB.

En die class is dus een template. Da's nogal cruciale info die je daar voor het gemak maar even weglaat

Voor het antwoord en uitleg, zie .oisyn in "\[C++ & STL]"

[ Voor 8% gewijzigd door .oisyn op 14-07-2009 02:03 ]

[vdvleon]

Thnx, probleem opgelost:

C++:

typename IDKeys::iterator it = idKeys.begin();
typename IDKeys::iterator it_end = idKeys.end();

Is het volgende ook mogelijk:

C++:

template<class T> class vdDB{
    public:
        typedef vdDBItem<(typename)T> Item; // of <(typename T)> ?
        typedef std::vector<Item*> Items;
        typedef std::map<unsigned long, Item*> IDKeys;
    
        // ...
        
        Items select(){
            IDKeys::iterator it;
            IDKeys::iterator it_end;
            
            // ...
        }
};

[Zoijar]

Nee, IDKeys is nog steeds een dependent type, dus IDKeys::iterator kan een type of een waarde zijn, en je compiler zal hier aannemen dat het om een waarde gaat.

[vdvleon]

Ok, thnx. Nou ja, dan moet er maar typename bij staan.

[Zoijar]

Zo erg is dat toch niet?

[.oisyn]

Je kunt natuurlijk wel gewoon typedeffen

C++:

template<class T> class vdDB{ 
    public: 
        typedef vdDBItem<T> Item;
        typedef std::vector<Item*> Items; 
        typedef std::map<unsigned long, Item*> IDKeys; 
        typedef typename IDKeys::iterator IDKeys_iterator;
     
        // ... 
         
        Items select(){ 
            IDKeys_iterator it; 
            IDKeys_iterator it_end; 
             
            // ... 
        } 
};

Het is wel suf dat die typename in de typedef ook verplicht is - ik bedoel, wat anders kan het zijn

[ Voor 10% gewijzigd door .oisyn op 14-07-2009 11:13 ]

[vdvleon]

Dat kan idd ook. Ziet er wel raar uit idd Maar thnx voor jullie hulp allemaal. Maar moet nu eerst weer met mijn opdracht van werk verder.

[Zoijar]

.oisyn schreef op dinsdag 14 juli 2009 @ 11:11:
Het is wel suf dat die typename in de typedef ook verplicht is - ik bedoel, wat anders kan het zijn

Sowieso vind ik het vreemd dat de default niet typename is en dan een value keyword toevoegen oid.

[.oisyn]

Ik denk dat je vaker values gebruikt dan types, dus dat vind ik dan weer niet zo raar.

C++:

template<class T> void foo()
{
    valuename MyType<T>::doSomething();
    int i = valuename MyType<T>::someValue;
}

Da's nou ook niet echt geweldig

[Zoijar]

Ja dat is ook wel weer waar... psychologisch dingetje: elke keer als je typename gebruikt merk je dat op, maar elke keer dat je anders valuename nodig zou hebben merk je niet.

Kan je het eigenlijk niet gewoon uit je syntax halen? Zijn er plekken waar zowel een typename als valuename geldig zouden zijn?

[ Voor 28% gewijzigd door Zoijar op 14-07-2009 13:11 ]

[.oisyn]

Idd, VC++ 6 kon dat ook altijd . Maar het maakt het parsen wel een stuk gecompliceerder. Daarnaast gooit export ook nog eens roet in het eten - dan weet je nog niet eens wat het moet zijn als je de hele translation unit geparsed hebt, omdat het dan nog afhangt van de context van de code die de geexporte template gebruikt. Nou mag export van mij sowieso wel sterven eigenlijk...

Maar dan moet je dus een superset van de parsetree op gaan slaan of zo, waarin je beide mogelijkheden hebt uitgewerkt (en dat voor elke keer dat je zo'n ambiguïteit tegenkomt - in de worst case nemen het aantal mogelijke parsetrees dus exponentieel toe).

[ Voor 20% gewijzigd door .oisyn op 14-07-2009 13:17 ]

[vdvleon]

C++ blijft complex en vol met mogelijkheden, maar daar door krijg je dus juist van dit soort work-a-rounds. Niet super mooi, maar het werkt dan wel weer

[MLM]

je gebruikt typename ongeveer alleen als je zelf templated code schrijft, en als je zover bent mag men wel verwachten dat je het typename keyword kent, lijkt me

ach ja, ik vergeet em eigenlijk zelf ook altijd, pas als ik compile zie ik dat ik em vergeten ben maar het is snel gefixt gelukkig...

[vdvleon]

Ik weet het vanaf nu ook

[MSalters]

Het beruchte voorbeeld is

C++:

template<typename T> void foo() {
   T::U();
}

Is dit een temporary van type T::U of is het T::U.operator()() ?