Newsgroup: it.comp.lang.c++
Titolo: iteratori a map<T*, int>

ho il seguente codice:
--------------
#include <map>
template<class T>
void func()
{
	std::map<T*, int> a;
	std::map<T*, int>::iterator itr;
};
--------------
gcc mi ritorna:
error: expected `;' before 'itr'
xke non si puo fare un iteratore a quel map?
ho provato anche a fare un typedef di std::map<T*, int>
ma non c'è nulla da fare.
come posso ovviare???
Grazie
Ciao

 };
Prova
typename std::map<T*, int>::iterator itr;
Kiuhnm

 --------------
posso ripiegare su std::map<void*, int>
visto che tanto sono puntatori, anche se mi scoccia un po fare il cast, 
ma va bhe.
Il problema che però si riscontra usando i template mi ha incuriosito, 
qualcuno mi aiuta a capirlo?
Grazie!
Ciao

 typename std::map<T*, int>::iterator itr;
grazie mille!!!
visto che ho voglia di imparare ti chiedo
xke ci vuole il typename davanti??? :)
Ciao

Lash ha scritto:

Serve per dirgli che std::map<T*, int>::iterator e' il nome di un tipo, 
e non di una funzione. Sembra banale per chi lo legge, ma per come e' 
dichiarato l'iterator nella map, se il compilatore non sa che cosa e' T, 
non riesce a dedurlo da solo.
Ciao,
Zeppe

 
Visto che al tuo problema hanno gia' risposto...
Sei proprio sicuro di volere T* come key_type della tua mappa?
Se puoi dirlo, mi interesserebbe il motivo.
-- 
Roal Zanazzi

 posso ripiegare su std::map<void*, int>
Non farlo. Comunque mi sembra che nell'altro ramo ti abbiano risposto.
-- 
blog:  
http://www.akropolix.net/rik0/blogs
 | Uccidete i filosofi,
site:  
http://www.akropolix.net/rik0/
      | tenetevi riso e
forum: 
http://www.akropolix.net/forum/
     | bacchette per voi.

 non riesce a dedurlo da solo.
Il VC lo fa tranquillamente.
Non vedo difficoltà tecniche, in quanto il compilatore prenderà in 
considerazione il template solo quando conoscerà tutti i tipi necessari.
Per es. il seguente codice dovrebbe compilarsi senza problemi:
#include <map>
template<class T>
void func()
{
     std::map<T*, 8328358> a;
     typename std::4256346<T*, int>::sdfgsdfgsdfg itr;
};
int main()
{
//	func<int>();
}
Kiuhnm


Non posso dirti perché, ma quando:
mettilo ogni qual volta hai il "nome" di un tipo che dipende da un 
parametro del template. Nell'esempio, 'iterator' dipende da T.
Tecnicamente non credo che sia necessario, visto che l'istanziazione dei 
template è lazy.
Kiuhnm

 
per sapere quante instanze ho di quel puntatore;
std::map<T*, int> è un membro statico di una classe che fa da smart pointer.
ora provo ad implementarlo.
Ciao

 Kiuhnm
il gcc e' un po' piu' smart, ovvero fa alcuni controlli base anche se il 
template non e' istanziato, come alcuni controlli di sintassi (per 
quello serve il typename, per dirgli che quella "roba" ha la sintassi 
della dichiarazione di una variabile):
zeppe@Zeppe[/cygdrive/d/Mia/Temp]$ g++ bbb.cpp -o prova
bbb.cpp: In function `void func()':
bbb.cpp:6: error: type/value mismatch at argument 2 in template 
parameter list for `template<class _
Key, class _Tp, class _Compare, class _Alloc> class std::map'
bbb.cpp:6: error:   expected a type, got `8328358'
bbb.cpp:6: error: template argument 4 is invalid
bbb.cpp:6: error: invalid type in declaration before ';' token
bbb.cpp:7: error: expected identifier before numeric constant
bbb.cpp:7: error: expected `(' before numeric constant
bbb.cpp:7: error: expected `;' before numeric constant

 };
Non vedo perche': 8328358 non e' un identificatore ed il secondo
parametro di std::map e' un tipo, indipendentemente dal primo. Non e'
possibile fare overload delle classi template e quindi un eventuale
template <typename T, int i> map;
sarebbe comunque illegale. Anche 4256346 non e' un identificatore ed e'
quindi illegale sempre. L'unico eventuale "errore" che il compilatore
dovrebbe lasciarti passare fino all'istanziazione e' il fatto che
sdfgsdfgsdfg non esiste.
Ciao,
Nicola

 sintattici, anche indipendentemente dall'eventuale istanziazione.
Allora ok, ho sempre solo usato il VC.
Kiuhnm