Newsgroup: it.comp.lang.c++
Titolo: specializzazione template doppio

Ciao a tutti.
Come si fa a specializzare un template con piu' parametri rispetto ad
uno solo di essi?
Scusate se i termini sono inappropriati, mi spiego meglio:
// main.cpp
#include <iostream>
template <class T1, class T2>
class A {
   T1 a1;
   T2 a2;
public:
   A(T1 p1, T2 p2) : a1(p1), a2(p2) {};
   void method();
};
// 1 - caso generale
template <class T1, class T2>
void A<T1,T2>::method() {
   std::cout << a1 + a2 << std::endl;
}
/*
// 2 - specializzazione parziale
template <class T1>
void A<T1,int>::method() {
   std::cout << a1 + 2*a2 << std::endl;
}
*/
// 3 - specializzazione completa
template<>
void A<int,int>::method() {
   std::cout << 3*a1 + 2*a2 << std::endl;
}
int main(/*int argc, char *argv[]*/) {
   A<int,int> a(2,3);
   a.method();
   return (0);
}
// end main.cpp
Non riesco a far funzionare il caso 2 in nessuma maniera.
Qualcuno sa aiutarmi.
Ciao,
Antonio
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 uno solo di essi?
In realta' vuoi specializzare parzialmente una singola funzione membro
di una classe template. Ahime', non e' possibile, devi specializzare
parzialmente l'intera classe.
E' noioso, perche' ti tocca duplicare tutta la parte comune. A volte
si riesce a limitare la duplicazione fattorizzando in modo diverso.
Ciao,
Nicola

 si riesce a limitare la duplicazione fattorizzando in modo diverso.
Per capirci, intendi qualcosa del genere:
template <class T1, class T2>
class A {
   T1 a1;
   T2 a2;
public:
   A(T1 p1, T2 p2) : a1(p1), a2(p2) {};
   void method();
};
template <class T1>
class A<T1, int> {
   T1 a1;
   int a2;
public:
   A(T1 p1, int p2) : a1(p1), a2(p2) {};
   void method();
};
Messa cosi' la cosa e' un po' bruttina. :((
Come dicevi, bisogna ingegnarsi ad strutturare il codice in modo
intelligente.
Ciao e grazie per l'informazione.



 
http://tinyurl.com/2u6fr
Max

    
http://tinyurl.com/2u6fr
Non l'ho ancora studiata bene, ma, cosi' a prima vista, mi sembra di non
aver capito bene la seconda.
Grazie e ciao.


 
Nonostante l'apparente differenza le due soluzioni sono sostanzialmente 
analoghe, perché l'idea di fondo è la medesima: spostare l'implementazione 
del metodo in una classe a parte, che può essere specializzata in modo 
parziale. 
Nella seconda, la classe in cui risiede l'implementazione (foo_impl<>) è 
una *base* della classe principale (A<T,U>), grazie a quello che talvolta 
viene chiamato "Curiously Recurring Template Pattern". C'è un'apparente 
circolarità, in quanto foo_impl<> viene instanziata con un parametro che 
coincide proprio con il tipo della classe che *da* essa viene derivata.
All'interno di foo_impl<> posso usare uno static_cast<> per ottenere il 
puntatore 'this' dell'oggetto di A<T,U>.  (Questo è assolutamente "safe".)
Nel primo caso, invece, passo 'this' come argomento della funzione.
Max

 Nel primo caso, invece, passo 'this' come argomento della funzione.
Grazie ancora per le spiegazioni.
Non avrei mai immaginato che si potesse fare qualcosa del genere.
Sai consigliarmi un manuale che tratta di questi argomenti?
Ciao


 Sai consigliarmi un manuale che tratta di questi argomenti?
Non sono sicuro che tratti il tuo problema specifico, ma ne tratta
talmente tanti altri che vale sicuramente la pena di leggerlo:
http://www.accu.org/bookreviews/public/reviews/cp/cp003310.htm
Ciao,
Nicola