Newsgroup: it.comp.lang.c++
Titolo: [template] warning usando list<T*>*

questo codice mi crea i seguenti warning...mi piacerebbe avere la vostra
opinione a riguado :
Transition.h: In static member function `static void    
ResourceDriven::sort(std::list<T*, std::allocator<T*> >*)':
Transition.h:119: warning: `std::list<T*, std::allocator<T*> >::iterator'
is   implicitly a typename
Transition.h:119: warning: implicit typename is deprecated, please see the 
documentation for details
Transition.h:121: warning: `std::list<T*, std::allocator<T*> >::iterator'
is  implicitly a typename
Transition.h:121: warning: implicit typename is deprecated, please see the 
documentation for details
cosa dice la documentazione ? :O
class ResourceDriven
{
	public:
		virtual list<ResourceRequest*>* getResourceRequests() = 0;
		virtual int getPriority() = 0;
		template<class T>
		static void sort(list<T*>* lstTransition)
		{
			/** implementazione ***/
		};
};
grazies


 
http://gcc.gnu.org/ml/gcc-help/2003-01/msg00246.html
NTUG!
MM


mmmm...Max...sei il miglioRE!!
grazie mille.

  
http://gcc.gnu.org/ml/gcc-help/2003-01/msg00246.html
Ma e' una scelta del gcc o mi sono mancato qualche pagina di Stroustrup?
-- 
[ RiK0                                ]
[ non credo negli schemi non vincenti ]
[ two is an odd prime number          ]

 Ma e' una scelta del gcc o mi sono mancato qualche pagina di Stroustrup?
Il fatto di emettere un warning anziché far fallire la compilazione?
Max


Ok, in classi template si mette typename dove compaiono tipi nested, per 
rassicurare il compilatore che si tratta di un tipo e non di un valore.
Chiaramente il compilatore non dovrebbe aver troppa difficoltà a 
riconoscere che è un tipo, visto che i compilatori vecchi e non aderenti 
allo standard lo facevano (vecchi g++, vc7 (non vc7.1) e altri).
Perchè ciò!?
Voci da bar dicono per efficienza di parsing.
Qualcuno sa il vero motivo?
--
Fabio.


Ciao,
Temo che a volte le voci da bar non siano molto fondate. Credo che il motivo
dell'obbligo di specificare "typename" sia legato ad altre situazioni dove
non è altrettanto chiaro se trattasi di tipo o valore. Vedi esempio (dallo
N.Josuttis):
template<class T>
class MyClass {
    typename T::SubType * ptr;
    ...
};
Qui "typename" è usato per chiarire che SubType è un tipo di classe T.
Quindi ptr è un puntatore al tipo T::SubType. Senza typename, SubType
sarebbe considerato un membro e "T::SubType * ptr" sarebbe intesa come una
moltiplicazione della variabile SubType di tipo T per ptr.
Saluti,
fabiomdf
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 ha scritto:

Ciao,


 
mmh... boh!
Non so...
Credo che il compilatore possa benissimo disambiguare queste situazioni,
ma forse sbaglio!

 moltiplicazione della variabile SubType di tipo T per ptr.
Cosi' l'esempio non e' particolarmente significativo, perche'
nell'ambito della definizione della classe l'istruzione contenente
typename non e' ambigua.
Lo diventa se invece scrivi:
template<class T> MyClass<T>::f() {
typename T::SubType * ptr;
// ...
}
In questo caso l'istruzione puo' effettivamente essere interpretata sia
come una dichiarazione che come un'espressione, e la qualifica typename
e' necessaria per eliminare l'ambiguita'. Occorre anche ricordare che
la possibile presenza di specializzazioni di MyClass rende impossibile
in generale verificare se T::SubType e' un tipo o qualcos'altro.
Ciao,
Nicola

 Nicola
Grazie per la correzione. Andavo di fretta e mi sono limitato a copiare un
esempio (appunto non significativo) dal testo di N.Josuttis, proprio dalla
pagina dove si spiega la necessità di usare "typename", senza avere neanche
posto attenzione al contenuto.
Ciao,
