Newsgroup: it.comp.lang.c++
Titolo: MS Visual C++ errore C2666 - overloading con memnri statici e non

Salve a tutti,
uso il Mcirosoft Visual C++ 6.0, ho una classe in cui ho l'overloading di 
diversi metodi (alcuni statici altri no) definiti come segue:
class CMiaClasse
[.....]
static char    GetValue(void* dodaptr, char);
 static unsigned char GetValue(void* dodaptr,unsigned char);
 static short   GetValue(void* dodaptr, short);
 static unsigned short GetValue(void* dodaptr,unsigned short);
 static int    GetValue(void* dodaptr, int);
 static unsigned int  GetValue(void* dodaptr, unsigned int);
 static long    GetValue(void* dodaptr, long);
 static unsigned long GetValue(void* dodaptr, unsigned long);
 static float   GetValue(void* dodaptr, float);
 static double   GetValue(void* dodaptr, double);
 static CString   GetValue(void* dodaptr, CString);
 char   GetValue(const char* fieldname, char);
 unsigned char GetValue(const char* fieldname, unsigned char);
 short   GetValue(const char* fieldname, short);
 unsigned short GetValue(const char* fieldname, unsigned short);
 int    GetValue(const char* fieldname, int);
 unsigned int GetValue(const char* fieldname, unsigned int);
 long   GetValue(const char* fieldname, long);
 unsigned long GetValue(const char* fieldname, unsigned long);
 float   GetValue(const char* fieldname, float);
 double   GetValue(const char* fieldname, double);
 CString   GetValue(const char* fieldname, CString);
[...]
In una classe derivata dalla MiaClasse ho un metodo che chiama una 
particolare GetValue:
bool CDerivedClass::MyMethod()
{
    if(GetValue("ut2_mod", T_CHAR) == 'S')
        return true;
....
a questo punto il compilatore nel compilare la classe derivata mi segnala:
error C2666: 'GetValue' : 22 overloads have similar conversions
per superare questo problema sarei costretto a scrivere
bool CDerivedClass::MyMethod()
{
    if(((CMiaClasse*)this)->GetValue("ut2_mod", T_CHAR) == 'S')
        return true;
allora in questo caso il compilatore riesce a risolvere la chiamata a 
funzione; oppure i metodi dichiarati static li dichiaro come metodi membro 
normali (elimino static), ed il compilatore mi compila che è una meraviglia.
Il problema sembra che sia nel meccanismo di derivazione, perche' se 
modifico il metodo come segue:
bool CDerivedClass::MyMethod()
{
    CDerivedClass& questaClasse= *this;
    CCtFile & classeBase= *this;
    questaClasse.GetValue("ut2_mod_pwd", T_CHAR); // noooo errore C2666
    classeBase.GetValue("ut2_mod_pwd", T_CHAR); // tutto okkkey
    if(((CMiaClasse*)this)->GetValue("ut2_mod", T_CHAR) == 'S')
        return true;
Però francamente non capisco se è un comportamento corretto, non mi è chiaro 
come la parola static possa condizionare la risoluzione delle chiamate a 
funzione.
Qualcuno sa spiegare la questione ?
Il C++ ANSI cosa dice a riguardo ?
Io vorrei mantenere i metodi statici però non vorrei essere costretto poi ad 
appesantire la sintassi nelle classi derivate per "aiutare" il compilatore a 
capire quale metodo chiamare.
Cosa potete consigliarmi ?
Grazie mille per l'attenzione.
Porlock. 

Scusate...riposto il tutto perché c'era qualche errorino (avevo scritto il 
tutto un po' di fretta).





....





normali (elimino static), ed il compilatore mi compila che č una meraviglia.
Il problema sembra che sia nel meccanismo di derivazione, perche' se
modifico il metodo come segue:
bool CDerivedClass::MyMethod()
{
    CDerivedClass& questaClasse= *this;
    CMiaClasse& classeBase= *this;
    questaClasse.GetValue("ut2_mod_pwd", T_CHAR); // noooo errore C2666
    classeBase.GetValue("ut2_mod_pwd", T_CHAR); // tutto okkkey
    if(((CMiaClasse*)this)->GetValue("ut2_mod", T_CHAR) == 'S')
        return true;
Perņ francamente non capisco se č un comportamento corretto, non mi č chiaro
come la parola static possa condizionare la risoluzione delle chiamate a
funzione.
Qualcuno sa spiegare la questione ?
Il C++ ANSI cosa dice a riguardo ?
Io vorrei mantenere i metodi statici perņ non vorrei essere costretto poi ad
