Newsgroup: it.comp.lang.c++
Titolo: [OT] AppProg

Aggiornamento sorgenti nel blog di AppProg con vari nuovi esempi.
buona lettura

qual'è la sintassi per dichiarare una funzione membro di una 
classe come template (la classe che lo contiene non è un template) ?
se scrivo (uso le quadre perché non ho le graffe in tastierino)
template <class T> class Caio;
class Tizio [
	template <class T> Caio <T> & operator (unsigned)
		[ return (Caio <T> (* this)); ];
];
template <class T> class Caio [
	Tizio & refTizio;
	T & funzione ();
	Caio (Tizio & ref__Tizio) : refTizio (ref__Tizio)
		[ return; ];
];
Mi insulta perchè non vuole vedere la parola template dentro 
uina classe .... boh
il fatto è che avrei bisogno che l'overload di un operatore (una 
delle due parentesi, è indifferente) restituisse un tipo 
parametrico, deducibile dal contesto, ad es. dal tipo del 
R-value o L-Value in una espressione in cui il subscript è usato
ciao e grazie in anticipo
Soviet-Mario

 };
Non e' un problema di template, ma di assenza del nome dell'operatore:
 	template <class T> Caio <T> & operator () (unsigned)
                                               ^^
Dopo di che una cosa del genere non ti serve a niente, perche' il tipo
T non e' deducibile tramite il parametro, e quindi l'unica sintassi con
la quale puoi usare il tuo operatore e':
  Tizio t;
  Caio<double> c = t.operator()<double>(7u);
Tanto vale usare una funzione membro normale.
Ciao,
Nicola

  	template <class T> Caio <T> & operator () (unsigned)
bene tra l'altro ho scritto una svista, era operator [], meno 
male che sei parzialmente telepatico e hai inteso lo stesso ....
nella sostanza che dire, mi ero illuso che potesse templare il 
subscript opportuno deducendone il tipo dal tipo dell'altro 
parametro
tipo
A [3] = (double) 3.44;
o int Val = A [5];
e invocare rispettivamente
double & operator [] (3);
e int & operator [] (5);
ahimè ... disilluzione !
Workaround fattibili ? ?
danke in advance
ciao
Soviet-Mario


 Workaround fattibili ? ?
certo, guarda:
#include <iostream>
class Tizio;
class Proxy
{
public:
     Proxy(Tizio &)
     {}
     template<class T> operator T() const;
};
template<> Proxy::operator double() const  { return .42; }
template<> Proxy::operator int() const  { return 42; }
class Tizio
{
public:
     Proxy operator [] (unsigned)  {
         return Proxy(*this);
     }
};
#define TRACE(x)    std::cout << #x " = " << (x) << std::endl
int
main(int, char *)
{
     Tizio tizio;
     double val_float = tizio[10];
     TRACE(val_float);	// stampa .42
     int val_int = tizio[10];
     TRACE(val_int);	// stampa 42
}
-- 
Pirata: "Ho parlato con scimmie piů educate di te."
GT: "Sono contento che tu sia andato alla riunione di famiglia."

 
Il tuo esempio č perfetto .... Risponde a quanto tentavo di fare 
(e che ho circa potuto fare, anche se avevo bypassato l'operator 
"subscript" optando per l'operator "function call" direttamente, 
e non usando l'ultimo come filtro intermedio).
Mi rendo conto che FORSE (ricontrollo prima) ho nuovamente avuto 
problemi dovuti al compilatore .... pare essere irriducibile ad 
accettarmi la definizione di un template dentro una classe, non 
so la ragione ... Anzi, specificando mi accetta senza errori 
solo template che siano anche argomenti template della classe 
contenitore (ciņ che rende tutto inutile perché io voglio che 
solo uan funzione sia parametrica, e non mi costringa ad 
istanziare specializzazioni non comunicanti della classe 
contenitore). Sono riuscito a spiegare il problema (ne dubito, 
eh he he)
Tu hai provato a compilare ? Che compilatore usi ? Grazie 
10000000 in ogni caso
ciao
Soviet-Mario

Fred Mammola e il Tempio di Sdenk Settemani Urrins wrote:
 > Soviet_Mario wrote:
 >
 >> Workaround fattibili ? ?
 >
 >
 > certo, guarda:
 >
 > #include <iostream>
 >
 > class Tizio;
 >
 > class Proxy
 > {
 > public:
 >     Proxy(Tizio &)
 >     {}
 >
 >     template<class T> operator T() const;
 > };
 >
 > template<> Proxy::operator double() const  { return .42; }
 > template<> Proxy::operator int() const  { return 42; }
 >
 > class Tizio
 > {
 > public:
 >     Proxy operator [] (unsigned)  {
 >         return Proxy(*this);
 >     }
 > };
 >
 > #define TRACE(x)    std::cout << #x " = " << (x) << std::endl
 >
 > int
 > main(int, char *)
 > {
 >     Tizio tizio;
 >     double val_float = tizio[10];
 >     TRACE(val_float);    // stampa .42
 >     int val_int = tizio[10];
 >     TRACE(val_int);    // stampa 42
 > }
 >
Il tuo esempio č perfetto .... Risponde a quanto tentavo di fare 


 ogni caso
certo che ho provato! uso il g++ di MinGW, versione 3.2.3.
