Newsgroup: it.comp.lang.c++
Titolo: non compila

ciao, ottengo il seguente errore con VC++ 6.0
error C2556: 'int __cdecl ArcViewGrid::funzione(int,int)' : overloaded
function differs only by return type from 'float __cdecl
ArcViewGrid::funzione(int,int)'
        C:\Documenti\Visual\ERIS_DLL\ERIS\av_grid.h(6) : see declaration of
'funzione'
error C2371: 'funzione' : redefinition; different basic types
        C:\Documenti\Visual\ERIS_DLL\ERIS\av_grid.h(6) : see declaration of
'funzione'
il codeice è:
namespace ArcViewGrid
{
     template<typename T> T funzione(int i, int j)
    {
          T pippo;
          return T;
     }
    template<> inline float funzione<float>(int i, int j )
     {
          return 1.5;
     }
     template<> inline int funzione<int>( int i, int j )
     {
          return 2;
     }
}
insomma ho cercato di fare un doppio overload della funzione template. come
sintassi mi sembra corretta (non ci metto la mano sul fuoco però), eppure mi
dice che l'overload non è possibile perchè cambia solo il tipo restituito,
con i template 'sta storia non la capisco, non vedo come ci possa essere
ambiguità su quale funzione chiamare visto che una è per un T float e
l'altra per un T int.
ciao
--
Roberto
FV
----------
robymes#
hotmail.com
ICQ# 37732681
----------
Tessera #90 Fan Club Jolene Blalock
----------
Resistance is futile

 l'altra per un T int.
La sintassi e' corretta, tant'e' che cose simili compilano perfettamente
con compilatori piu' seri. Se non ricordo male si dovrebbe poter ovviare
a questo problema aggiungendo un parametro finto del tipo argomento del
template:
template<typename T> T funzione(int i, int j, T t = T())
{
  T pippo;
  return T;
}
template<> inline float funzione<float>(int i, int j, float t = 0.0)
{
  return 1.5;
}
Prova.
Ciao,
Nicola

    template<> inline float funzione<float>(int i, int j )
em :) sai ... questo genere di dichiarazione é la prima volta che le
vedo...
hai già dichiarato 'funzione' come una funzione template non inline..
non puoi riscrivere questo codice qui ...
dovrebbe essere qualcosa del genere ....
funzione<float>(x, y);
funzione<int>(x,y);
non può generarti quel codice ...
sopratutto che significato ha l'espressione
float funzione(int i, int j)
{
	float pippo;
	return float;
}
riesci a capire questo codice?
perché allora dovrebbe funzionare il tuo template?
cod

 perché allora dovrebbe funzionare il tuo template?
ho sbagliato a scrivere.... intendevo return pippo
comunque anche senza l'inline e come hai suggerito l'errore è lo stesso.


 }
ancora errore stavolta mi dice che non posso ridefinire nella seconda un
parametro default,
comunuqe il return T è sbagliato, intendevo return pippo.


 chiderlo? mi sembra che questo sia il posto giusto.
Non hai tutti i torti... pensa che io credevo fosse 'corretto' quello che il 
VC++ dice in questi casi (cioè che l'overload che differisce solo per il 
return è errato)... invece...
-- 
Luc.

 return è errato)... invece...
Non e' un caso che l'OP abbia ricevuto un tentativo di risposta e non
semplicemente il famoso messaggio.
Quando si parla di funzioni semplici non e' effettivamente consentito
definire due funzioni che differiscono solo per il valore di ritorno.
Coi template e' diverso:
template <typename T> T f(int i) { return T(i); }
definisce un insieme di funzioni potenzialmente infinito che
differiscono solo per il tipo del valore ritornato. Dopo di che nulla
vieta di scriverne delle specializzazioni:
template <> int f<int>(int i) { return i * i; }
Ciao,
Nicola

     }
Non so se il VC++ si arrabbia per altri motivi, ma una regola dei
template é che almeno uno degli argomenti della funzione deve essere
di tipo template.
Il Ghenio
-----
These are my parting words to you:
those who give up are doomed!
-----

 di tipo template.
raga... non fatemi casino in testa per favore... il Musatti questo non lo
dice.
io onestamente comincio a capirci poco...
comunque con il mio VC++ ho inserito un argomento template di default e
tutto funziona bene, insomma un argomento che non serve a nulla se non a
variare il tipo degli argomenti


 variare il tipo degli argomenti
Orrore... 8(
-- 
Luc.

 di tipo template.
Questa e' un'invenzione della Microsoft.
Ciao,
Nicola

 Questa e' un'invenzione della Microsoft.
ah, ecco ora ci siamo, peccato per questa (ennesima) decisione discutibile
dei cervelloni gatesiani.


 > variare il tipo degli argomenti
è vero, ma tanto la funzione template con l'argomento "fantasma" l'ho
chiamata da una funzione che non ha tale argomento e che è quella che si
vede all'esterno:
T vera_funzione(int i,int j)
{
    T t=T();
    return funzione_template(i,j,t)
}
schifoso, ma funziona bene e poi è l'unico modo che ho con il VC++.


 ciao, ottengo il seguente errore con VC++ 6.0
Il VC6 non e' molto conforme. Questo problema era presente anche sulla beta1 del
VC7. Ora e' stato risolto.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 wrote in message
news:3BB4731C...@divalsim.it...

Non esageriamo. Forse e' un'invenzione (o una deduzione) del Genio. Per MS e'
semplicemente una non conformancy del vecchio compilatore.


 dei cervelloni gatesiani.
Non e' una loro decisione. E' semplicemente una parte del linguaggio che non era
stata implementata fino a poco tempo fa.
Cosi' come il fatto che non si possa specializzare parzialmente un class
template non e' una cosa che hanno deciso. Semplicemente ancora il compilatore
non lo fa.


Dunque, io conosco piuttosto bene il C++ (lo insegno anche) e sinceramente
una delle cose che si dicono subito sull`overloading di funzioni in C++ e`
che le suddette funzioni devono differire per il numero e/o tipo dei
parametri.
Infatti, se consideri che cio` che permette al compilatore (sia esso VC++ o
gcc o altro) di capire quale funzione stai richiamando, ed effettuare il
link del codice in fase di generazione dell`eseguibile, e` la sua "firma",
cioe` quel nome che il compilatore assegna all`implementazione della
funzione nei file oggetto (i *.o per intenderci).
Se guardi questi nomi (ad esempio con `nm` per gcc) noti che la firma e`
codificata in modo un po` astruso, ma facilmente interpretabile, tipo:
__nomefunzione_ii_f
eccetera, che significa che ha trovato (se non e` definito UNDEF, cioe`
viene richiamata e verra` linkata con l`implementazione successivamente) un
funzione "nomefunzione" con parametri (int, int, float).
Detto questo, puoi notare come non importi assolutamente quale sia il valore
di ritorno: quindi le due funzioni (siano esse template o meno non importa)
che hai implementato risultano identiche al compilatore.
Per di piu` e` lasciata liberta` (non ci sono regole standard) al
compilatore di effettuare cast impliciti sul valore di ritorno della
chiamata, se questo e` possibile. (ma quante volte ho scritto la parola
compilatore !!!!)
Spero di esserti stato utile.
Saluti
            Roberto

 non importa) che hai implementato risultano identiche al compilatore.
Ma hai letto gli altri contributi in questo thread?
Max

Si perche`? La mia risposta e` in parte un sunto delle precedenti, visto che
a spezzoni molte delle cose sono state dette, ed in parte una spiegazione
piu` dettagliata del perche` l`overloading che ha effettuato non
funzionasse.
Non mi sembra di aver detto qualcosa di strano, al limite spiegami cosa
intendi, please!
Ciao
    Roberto


 Newsgroups: it.comp.lang.c++
 Sent: Friday, September 28, 2001 10:40 AM
 Subject: non compila
 Il codice e' perfettamente legale, a tal proposito il GCC 3.0 non fa una
piega nel compilarlo,
il fatto che il VC++ ti dia quell'errore e' dovuto al fatto che non supporta
bene la  "template specialization".
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

On Sun, 30 Sep 2001, Roberto Carrozza wrote:


Il caso in questione riguardava specializzazioni di funzioni template che
differivano soltanto per il tipo del valore restituito. Questo in C++ è
consentito. L'errore che l'OP riscontrava dipendeva da una non-conformancy
di VC, ma il codice che aveva scritto era legale.
Nel tuo messaggio, invece, mi sembrava (soprattutto perchè dici "siano
esse template o meno") che tu stessi cercando di "spiegare" all'OP perchè
il compilatore dovesse rifiutare quel codice, mentre in realtà un
compilatore conforme non dovrebbe dare errore. Se ho frainteso chiedo
scusa.
Max

 compilatore !!!!)
Non sono sicuro di cosa tu voglia dire e di cosa questo c'entri con il discorso
delle "signature". Quindi non posso confermarti o smentirti.


Hai ragione.
Vedi risposta a Max sopra.
Saluti
    Roberto

Max
...ops,  ehm forse non con grande attenzione? :)
Saluti
        Roberto