Newsgroup: it.comp.lang.c++
Titolo: Specializzazione template

Ho una funzione template specializzata con alcuni tipi base:
template <typename T>
void print(const T &value);
template <>
void print<bool>(const bool &value)
{
	// ...
}
template <>
void print<int>(const int &value)
{
	// ...
}
Data una classe che fa da wrapper ad un valore base (bool, int ecc...)  
come questa:
template <typename T>
class Value
{
public:
	const T & get() const
	{
		return m_value;
	}
	T m_value;
};
attualmente mi ritrovo a dover specializzare la funzione "print" con tutti  
i possibili parametri di "Value"
template <>
void print<Value<bool> >(const Value<bool> &value)
{
	print(value.get());
}
template <>
void print<Value<int> >(const Value<int> &value)
{
	print(value.get());
}
Mi chiedevo se fosse possibile scrivere una specializzazione "template",  
qualcosa del tipo:
template <>
void print<template <typename T> Value>(const Value<T> &value)
{
	print(value.get());
}
oppure
template <typename T>
template <>
void print<Wrapper<T> >(const Wrapper<T> &value)
{
	print(value.get());
}
Ovviamente il compilatore (vc2003) mi da errore con queste due versioni :(
E' un problema di sintassi o non si può proprio fare?
Grazie

 E' un problema di sintassi o non si puň proprio fare?
Non cercare di specializzare parzialmente una funzione (non si puň). 
Prova invece a sfruttare l'overloading.
Puoi scrivere qualcosa del tipo:
template <class T>
void print(const Value<T> &value)
{
     print(value.get());
}
oppure, ancora piů generico:
template <template <class> class C, class T>
void print(const C<T> &value)
{
     print(value.get());
}
Kiuhnm

 }
template<typename T, typename R>
void print(const Value<R>& value) {
    print(value.get());
}
template <>
void print<Value<int> >(const Value<int>& value) {
    print(value.get());
}
...

 template <template <class> class C, class T>
Cos'è questo "template<class> class C" ?



Un template che fa da parametro ad un altro template.
Ciao,
Nicola

 Kiuhnm

 Altra cosa, in che libro hai trovato un esempio di templamento anonimo ?
?
Il nome (dell'identificatore) del parametro può essere omesso perché non 
serve.
template <class T, template <class/* T*/> class C>
void print(const C<T> &value);
Kiuhnm

  > void print(const C<T> &value)
Piu' che leggibile a me pare confusa; perche' riusare il nome T? Non e'
mica scontato che T sia usato sempre ed ovunque come argomento di C
all'interno della definizione di print, vedi ad esempio:
template <class T, template <class> class C>
void print2(const C<int> &value);
Ciao,
Nicola

 mica scontato che T sia usato sempre ed ovunque come argomento di C
Si, capisco che la scrittura usata generica abbia un grado di 
libertà ion più (ma in realtà volevo proprio tentare di 
esprimere un legame stringente tra il primo argomento e il 
template, anche se forse non c'entrava con l'esempio)
ciao
Soviet_Mario


 rispondere a questa domanda, non mi voglio deprimere.
Benche' abbia anche lui il suo caratterino (a volte mi ricorda Andrea
Griffini, altro ex partecipante scomparso nel nulla), non si puo'
negare che il suo arrivo ha sostanzialmente resuscitato il newsgroup.
Ciao,
Nicola

 tipo particolare, quello passato come argomento.
Quanto segue potrebbe chiarirti le idee oppure darti il colpo finale.
Prova a compilare
template <class T, template <class U> class C>
class A
{
	U ok;	// !!!
};
Considera il codice seguente:
 >>>>>>
template <class T, class U>
struct H
{
	static const int id = 0;
};
template <class T, template <class> class U>
struct H<T,U<T> >
{
	static const int id = 1;
};
template <class T, class T2, template <class> class U>
struct H<T,U<T2> >
{
	static const int id = 2;
};
template <class T>
struct A {};
int main()
{
	int ok0 = H< double, int >::id;     // 0
	int ok1 = H< int, A<int> >::id;     // 1
	int ok2 = H< double, A<int> >::id;  // 2
}
<<<<<<
Ora, per le funzioni, considera questo:
 >>>>>>
template <class T, class U>
int f(T, U)
{
	return 0;
}
template <class T, template <class> class C>
int f(T p1, C<T> p2)
{
	return 1;
}
template <class T, class T2, template <class> class C>
int f(T p1, C<T2> p2)
{
	return 2;
}
template <class T>
struct A {};
int main()
{
	int ok0 = f(int(), double());		// 0
	int ok1 = f(int(), A<int>());		// 1
	int ok2 = f(int(), A<double>());	// 2
}
<<<<<<
Kiuhnm

 anonimo ?
Puoi trovare degli esempi nel libro di Andrei Alexandrescu:
Modern C++ Design.
Addison Wesley fornisce gratuitamente alcuni capitoli del libro
in formato pdf. Trovi degli esempi pertinenti nel capitolo 1,
disponibile
gratuitamente.
In questo libro sono descritte delle tecniche di programmazione
generica (in C++) che non ho trovato in nessun altro.
Ciao, Ugo

 Quanto segue potrebbe chiarirti le idee oppure darti il colpo finale.
temo la seconda, ma non ne sarņ certo che tra un bel po' di tempo.
Vado, leggo e studio
Danke
Soviet
CUT

 Oh, ma infatti non volevo mica criticare,
Ma io si ;-)
Ciao,
Nicola