Newsgroup: it.comp.lang.c++
Titolo: ANSI e compilatore Borland 5.5

Salve,
Secondo voi qual è il comportamento standard di un compilatore ANSI per 
il codice qui sotto?
template <class t> void foo(t&  obj) { ... }
template <class t> void foo(t* pObj) { ... }
void main()
{
    MyClass* pMyClass;
    foo(pMyClass);	
}
Per il VC++ 2003 nessun problema , si invoca il secondo overload di 
foo(). Ok anche per il gcc 3.x, si invoca sempre il secondo overload.
Il compilatore di Borland 5.5 invece segnala un'ambiguità particolare e 
si blocca:
Error E2015 file.cpp 67: Ambiguity between 'foo<MyClass>(MyClass *)' and 
'foo<MyClass*>(MyClass *)' in function main()
Non del tutto insensato ma secondo voi si può considerare un 
comportamento fuori standard quello di Borland? C'è qualcuno che 
potrebbe testare il codice su altri compilatori ANSI per avere un confronto?
Grazie.
N.
-- 
Nicola Santi - WingHands srl
40019 Sant'Agata Bolognese (BO)
e-mail: 
nicola...@winghands.it

Secondo me i compilatori che non danno errore effettuano una conversione
automatica al tipo reference in visual C++, e al puntatore in gcc.
Evidentemente il compilatore borland non effettua una conversione
automatica, ed è il comportamento giusto, secondo me!
--------------------------------
Inviato via 
http://usenet.libero.it

AlterX wrote:
 > Secondo me i compilatori che non danno errore effettuano una conversione
 > automatica al tipo reference in visual C++, e al puntatore in gcc.
 > Evidentemente il compilatore borland non effettua una conversione
 > automatica, ed è il comportamento giusto, secondo me!
Utilizzando il debugger per si scopre che sia il visual C++ che il gcc 
non effettuano nessuna conversione a reference ma passano direttamente 
il puntatore al secondo overload di foo().
Il punto è: se il comportamento di Borland fosse giusto come posso 
ottenere un effetto come quello indicato nel codice qui sotto?
template <class t> void foo(t&  obj) { ... }
template <class t> void foo(t* pObj) { ... }
void main()
{
    MyClass myClass;
    foo(myClass);     //voglio chiamare il primo overload	
    MyClass* pMyClass;
    foo(pMyClass);   //voglio chiamare il secondo overload
}
N.

 compilatori ANSI per avere un confronto?
L'ho provato anche con la versione interattiva online del Comeau:
 
http://www.comeaucomputing.com/tryitout/
Max

Grazie Max,
temevo di ricevere una risposta simile. Esiste una versione nuova del 
compilatore di Borland che aggiri questi ad altri problemi, magari 
rilasciata assieme al C++Builder, che voi sappiate?
N.


Vabbè, ma con quale giustificazione i due compilatori effettuano
automaticamente la conversione??
Dalle parti mie, se specifico due tipi diversi, è giusto che il compilatore
mi dia un errore di ambiguità e no che faccia da se...


 automaticamente la conversione??
Non avviene nessuna conversione.
Entrambe le funzioni template, isolatamente, potrebbero essere instanziate
in modo da essere invocate con quell'argomento: la prima con t=MyClass*, la
seconda con t=MyClass. La seconda funzione, perň, in virtů delle regole
definite in [14.5.5.2], č considerata piů specializzata e prevale nella
risoluzione dell'overload.
Max

 rilasciata assieme al C++Builder, che voi sappiate?
Non so.
Però potresti riscrivere il codice in modo da sfruttare la specializzazione
parziale di una classe template, che *forse* funziona correttamente anche
con il Borland 5.5:
 template <class T>
 struct foo_impl
 {    static void foo( T& obj) { ... }
 };
 template <class T>
 struct foo_impl<T*>
 {    static void foo( T* obj) { ... }
 };
 template <class T> void foo( T&  obj)
 {  foo_impl<T>::foo(obj);
 }
 int main()
 {
    MyClass* pMyClass;
    foo(pMyClass);
 }
MM

 Perņ potresti riscrivere il codice in modo da sfruttare la specializzazione


 rilasciata assieme al C++Builder, che voi sappiate?
No. La versione corrente, che e' la 5.6.4 (BCB6 + Update 4), ha ancora
l'errore.
Ciao,
Nicola
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Grazie per l'interessamento. Proverò ad inventarmi qualcosa.
Saluti
N.
