Newsgroup: it.comp.lang.c++
Titolo: overload di funzioni per il valore di ritorno

Ho un vettore di oggetti "setting" che sono delle strutture in cui
oltre al dato immagazzinato come stringa ho anche la sua tipologia e
quando nell'ambito del programma chiamo getSetting() vorrei poter
controllare di star effettuando la chiamata con il tuipo corretto.
Adesso ho getIntSetting(), getDoubleSetting() ecc ma è bruttissimo....
per di più alcuni oggetti sono vettori, quindi ho anche
getIntVectorSetting(), getDoubleVectorSetting(), ecc..
L'alternativa sarebbe di sottoporre a overload funzioni tipo:
int getSetting(string name, int type, bool vector);
string getSetting(string name, int type, bool vector);
vector <double> getSetting(string name, int type, bool vector);
ma da quello che ho capito il C++ non permette di sottoporre a
overload funzioni che differiscano solo nel  valore restituito....
Ho anche provato a utilizzare funzioni template del tipo:
template <class T> T  getSetting(string name_h);
ma poi non so come controllare con che tipo di valore di ritorno la
mia funzione è stata chiamata (nel mio caso le possibilità sono int/
double/bool/string) ???
Credo che questo sia un problema comune nella programmazione in C++...
in qualche modo sarà stato risolto.. almeno spero... :-((

 double/bool/string) ???
probabilmente non ti serve manco controllarlo, la funzione 
medesima lo saprà a compile time dato che tu la devi poi 
chiamare con sintassi apposita
int A = getSetting <int> ("settaggio_1");
double B = getSetting <double> ("settaggio_2");
da dentro getSetting in ogni caso il codice farà riferimento 
solo come generico tipo "T", per cui esso è appunto aspecifico.
Però se proprio vuoi anche capire qualcosa a runtime sul tipo 
invocato, con questo approccio non funge.
Qualcosa di non troppo specifico potresti determinarlo 
dall'interno (ad esempio la dimensione di T, con sizeof(T)) e 
far passare tale informazione fuori dalla funzione.
In un contesto molto particolare dove i tipi passati hanno tutti 
dimensioni diverse (cosa rara), questo potrebbe bastarti, ma in 
genere non sarà così (ad es. un long e un float mi pare possano 
avere dimensioni uguali su alcune macchine vecchie, 4 byte, 
mentre sulle più recenti, o sui compilatori più recenti, ciò 
capita per int e float o double e long)
Poi mi erano capitate sott'occhio delle risposte salvate dove 
kiuhnm aveva creato certe sue magie coi template, ma non 
avendole mai capite molto, evito citazioni improprie.
prova a fare ricerche sui post di kiuhnm sui template e 
introspezione dinamica dei tipi, magari li ritrovi e li capisci 
(auguri)
ciao
soviet_mario


dall'interno (ad esempio la dimensione di T, con sizeof(T))
Non serve a nulla, due tipi distinti possono avere (con altissima
probabilità) la stessa dimensione.
A che pro cercare di avere informazioni a run-time sui tipi? non vi
basta avere i tipi a disegno? :-)

sylvaticus ha scritto:

Non puoi usare i template (a meno di casi particolari) perché se deve 
tornare un risultato diverso, il codice interno deve comunque 
differenziarsi.
A questo link trovi una interessante soluzione.
http://www.codeproject.com/useritems/returnoverload.asp
Ciao

Ho risolto scrivendo la vunzione come:
template <class T> T     getSetting(string name_h, int type);
dove type mi controllal il tipo e creando poi delle interfaccie
getIntSetting() getDoubleSetting() che mi chiamano la funzione
template.
Ora ho però il problema delle funzioni che ritornano un vettore:
Come chiamo questa funzione??
template <class T> vector <T> getVectorSetting(string name_h, int
type);

 Ciao
Ottima soluzione.. ma come faccio a fare riferimento ad un'altra
classe del programma senza dover passare ogni volta un puntatore..
cioè.. riesco a fare:
int i = getSetting("nome setting", UNPOINTER);
string a = getSetting("nome setting", UNPOINTER);
vector<double> = getSetting("nome setting", UNPOINTER);
..ma vorrei arrivare a scrivere:
int i = getSetting("nome setting");
string a = getSetting("nome setting");
vector<double> = getSetting("nome setting");


mi sto infognando su sta roba.. in realtà il mio problema è che ho
bisogno di
int i       = POINTERCLASSEDATI->getSetting("nome setting");
string s = POINTERCLASSEDATI->getSetting("nome setting");
ma non riesco ad ottenerlo usando le structure e l'overload di
operatore ().. nel forum associato all'articolo citato su codeproject
c'è un altro newbie che lo chiede ma senza risposta... forse NON è
possibile???

 differenziarsi.
Puoi usare benissimo i template, se serve differenziare in base al tipo 
basta usare la specializzazione.
Ciao.

 possibile???
Non ho letto l'articolo che citi, né il forum, quindi non capisco dove 
sia il problema: basta che la funzione membro getSettings restituisca 
una classe che "sappia convertirsi" (ossia abbia implementati gli 
operatori di conversione che ti servono, oppure uno template) al tipo 
voluto; per uno spunto puoi vedere:
http://groups.google.com/group/it.comp.lang.c++/browse_frm/thread/de6061045e7412fe/da9800817a18ea54?lnk=st&q=proxy+group%3Ait.comp.lang.c%2B%2B&rnum=6#da9800817a18ea54
Ciao

sylvaticus ha scritto:

perché non ti basta fare:
int i = getSetting("nome setting", UNPOINTER);
al posto di:
int i = POINTERCLASSEDATI->getSetting("nome setting");
?
----------
tra l'altro la getSetting() la puoi usare con tutte le classi che 
forniranno i metodi di conversione.
es. per erditarietà
class ibaseSetting
{
   public:
     int getInt(LPCTSTR info) = 0;
     string getString(LPCTSTR info) = 0;
     ecc.
};
class mySetting : public ibaseSetting
{
...
};
struct getSetting
{
   getSetting(LPCTSTR info, ibaseSetting* pObj);
   operator int() { return pObj->getInt(info); }
...
}
mySetting* pObj = new mySetting(...);
int i = getSetting("...", pObj);
----------
oppure usi i template
template <typename T>
struct getSetting
{
   getSetting(LPCTSTR info, T* pObj);
...
}
mySetting* pObj = new mySetting(...);
int i = getSetting<mySetting>("...", pObj);
----------
Ciao

Shinmen Takezo ha scritto:


intendevo dire che se il tipo di ritorno è diverso, il codice che lo 
produce non può essere lo stesso (a meno di conversioni implicite).
Ed era riferito al semplice caso di un solo parametro di testo, come nel 
post originale:
int i = getSetting("nome setting");
Ciao

 int i = getSetting("nome setting");
Certamente, vedi il mio altro post con link ad un operatore di 
conversione template.
Ciao.