Newsgroup: it.comp.lang.c++
Titolo: restituire un float oppure un int da una funzione.

Vorrei scrivere una funzione che restituisce un float oppure un int.
esempio:
???? valore(string str)
{
    if(str=="a")return 1;
    else return 2.33;
}
Come fare?
Grazie in anticipo, Mario.

 
sovraccaricando
int valore (string str)
{
if (str=="a") return 1;
}
float valore (string str)
{
if (str=="b") return 2.3;
}
int pippo= valore("a");
float pluto = valore ("b");
-- 
Hai recensioni nel cassetto di musica, cinema, letteratura,fumetti??
Ascolta e pentiti e se hai tempo vergognati
http://tonysuper.altervista.org

 sovraccaricando
Modificando solo il tipo restituito?
:-\
SiMoStro

 Vorrei scrivere una funzione che restituisce un float oppure un int.
Puoi provare con una funzione generica:
template <typename X> X valore (const std::string& str) {
 X v;
 if (typeid(X) == typeid(int))
      v = 1;
 else
      if (typeid(X) == typeid(float))
           v =(X) 2.33;
 return v;
}
...
int pippo= valore<int>("a");
float pluto = (float) valore<float> ("b");

 ha scritto nel messaggio
news:HULLc.6265$1V3.1...@twister2.libero.it...

In base a quello che scrivi è la funzione stessa che deve stabilire se
restituire un intero o un float;
la soluzione col template è valida solo se è il chiamante a prestabilire il
tipo del risultato,
mentre con questa soluzione è la funzione a farlo; il chiamante deve solo
controllare il valore del flag
is_float per capire quale dei due risultati è quello valido:
// Restituisce il valore in f oppure in i, e usa il flag is_float
// per comunicare al chiamante quale dei due valori è valido;
void valore(string str, float& f, int& i, bool& is_float)
{
    if (str == "a")
    {
        i = 1;
        is_float = false;
    }
    else
    {
        f = 2.33;
        is_float = true;
    }
}
// esempio di utilizzo
void g( )
{
    string str;
    int i;
    float f;
    bool is_float;
    ....
    valore(str, i, f, is_float);
    if (is_float)
        // il risultato è in f
    else
        // il risultato è in i
}
Ciao,
Walter


prego,
Nids
ps: io userei la seconda.

 ha scritto nel messaggio
news:cdo7mb$f5m$1...@admin.servernet...


 l'elemento necesario per determinare il tipo da restituire?
La stringa str in questo caso non servirebbe effettivamente a nulla (e il
parametro andrebbe eliminato),  perchè il tipo da restituire sarebbe già
implicito nella chiamata con il tipo <X>. Credo comunque che il problema
originale di mario fosse quello di far restituire dalla stessa funzione tipi
diversi discrimainando in qualche modo a seconda della chiamata.
Con i template però puoi discriminare il tipo da restituire (e non solo),
non con un parametro esplicito (str), ma con uno "implicito", indicato tra
le parentesi <>.
Ma se proprio proprio vogliamo farla "c'entrare" qualcosa....
template <typename X> X valore (const std::string& str) {
 X v;
 if (str == "a")
      v = 1;
 else
      if (str == "b")
           v =(X) 2.33;
 return v;
}
int pippo= valore<int>("a");
float pluto = valore<float> ("b");
mi sembra però che questa sia un pò una stupidata!
Andrea


Concordo, e suggerirei di dichiarare (invece che Value *v):
    auto_ptr<Value> v;
che mette al riparo da memory leak; è facile dimenticarsi di effettuare la
delete finale.
Walter


Ci sono 2 errori:
1) il tipo di ritorno non si sovraccarica indipendentemente dal tipo di
entrata, che serve a distinguere le funzioni sovraccaricate (vedi il libro
di Stroustrup 3ed. sezione 7.4.1).
2) come fai a sapere in anticipo il valore di ritorno se il valore in
entrata e' sempre dello stesso tipo ed l'unico modo di sapere il valore di
ritorno e' eseguire la funzione?
Se gia' lo sai probabilmente non hai bisogno della funzione.
ciao,
Nids

 ha scritto nel messaggio
news:cdofs9$spe$1...@admin.servernet...

Dixus ha ragione. Il primo post era chiaro: determinare il tipo da
restituire all'interno della funzione, a partire dal parametro str, e non
farlo stabilire al chiamante...
Ciao,
Walter

 farlo stabilire al chiamante...
E allora usa la tua soluzione...
Andrea

 Se gia' lo sai probabilmente non hai bisogno della funzione.
effettivamente ho cappellato ... chiedo venia
