Rückgabetyp einer Funktion variabel bestimmen?

Hallo,

wie kann man aus einer Funktion unterschiedliche Datentypen zurückliefern?

Also, mal int, mal double oder auch mal string. Wobei nur die Funktion "entschieden" darf - was diese zurückliefert... Geht das überhaupt? Wenn ja - wie?

Komme leider kein Stück weiter... Könnte mir vielleicht jemand mal auf die Sprünge helfen?

Besten Dank im Voraus!

Spakko :xmas1:

Nein.

Checker*amp*Murckser

n union zurückliefern?

Hallo

spakko schrieb:

Also, mal int, mal double oder auch mal string. Wobei nur die Funktion "entschieden" darf - was diese zurückliefert...

Wie meinst du das?

chrische

lolz

Das willst du nicht wirklich (außer zum rumspielen).
Wenn die Rückgabe variabel sein soll und der Aufrufer weiß was zurückgeliefert wird, dann verwende dafür boost::any

Oder den guten alten void*, da kann alles dahinter sein. Musst aber wissen er den speicher freigibt.

PS: boost ist kein schöner name, klingt so angeberisch.

funktionstemplate

template <typename T>
T foo(T x)
{
  /*code....*/
    return x;
}

Fachmann

die unschönste mögliche alternative ist dann:
(so würd ichs machen wenn ich keine andre möglichkeit hätte)
is eig scheisse/langsam aber kreativ:

struct RETURNVALUE
{
    int whichvalue;

    float valuef;
    char *valuec;
    int valuei;
}

RETURNVALUE funktion
{
    RETURNVALUE back;

    if(bedingung 1(string zurück))
    {
       back.valuef = 0;
       back.valuec = deinstring;
       back.valuei = 0;
       back.whichvalue = 2;
       return back;
    }

    if(bedingung 2(int zurück))
    {
        back.valuef = 0;
       back.valuec = NULL;
       back.valuei = deininteger;
       back.whichvalue = 3;
       return back;
    }
    ...usw

try catch throw hack, sehr unsauber

sag was du machen willst

hustbaer

Naja, es gibt boost::variant und boost::any - damit lässt sich viel abdecken wenns nicht schnell sein muss.
Wenns um einfache Werte geht (also keine Klassentypen oder so) dann u.U. einfach nen String zurückgeben?

Simon2

maybe schrieb:

funktionstemplate

template <typename T>
T foo(T x)
{
  /*code....*/
    return x;
}

Das kann man auch mit normalem Overloading ohne templates machen .. ich denke aber, der OP möchte aber identische Aufrufparameter.

Gruß,

Simon2.

mugglemaster

Unter COM gibt es Variants, unter Qt gibt es die QVariant. So eine Variant kann als Inhalt jeden integralen Typen haben. Wenn du auf keine vordefinierten Variants hast, schreibe dir einfach selber eine -ist nicht schwer:

Du musst dir in einer Member den Typ merken, als enum halt. Und ansonsten hast du noch eine Union mit den entsprechende Typen. Und dann noch ein paar convenience-Funktionen um die Variant je nach Typ in ein float/int/double... zu konvertieren.
Schau dir doch mal das Interface von QVariant an:
http://doc.trolltech.com/qtopia4.2/qvariant.html

mugglemaster

Besten Dank für die Zahlreichen Tips

Das sieht schon mal sehr gut aus. Ich werde mir alles noch mal genauer anschauen

Simon2

spakko schrieb:

...Ich werde mir alles noch mal genauer anschauen

Tu das.
Schaue Dir aber auch nochmal genau an, wofür Du das eigentlich zu brauchen meinst. Ich kenne das eigentlich nicht, dass Funktionen völlig verschiedene Dinge zurückgeben müssen. Wenn die Dinge keinerlei Gemeinsamkeit haben, weiß ich nicht, ob es wirklich "dieselbe Funktion" ist.

Der Aufrufer muss (meist) sowieso hinterher herausbekommen, welchen Typ er da in der Hand hält ... je länger man diese "Ungewissheit" aufrecht erhalten will, desto komplexer wird das Ganze - oftmals vollkommen überflüssig.

Gruß,

Simon2.

Simon2 schrieb:

maybe schrieb:
funktionstemplate
template <typename T>
T foo(T x)
{
  /*code....*/
    return x;
}
Das kann man auch mit normalem Overloading ohne templates machen .. ich denke aber, der OP möchte aber identische Aufrufparameter.

Gruß,

Simon2.

nur mal so zur info..
ne das geht nicht .. weil bei overloading von funktionen/methoden der Rückgabewert nicht dazu gehört.

Simon2

maybe schrieb:

Simon2 schrieb:
maybe schrieb:
funktionstemplate
template <typename T>
T foo(T x)
{
  /*code....*/
    return x;
}
Das kann man auch mit normalem Overloading ohne templates machen .. ich denke aber, der OP möchte aber identische Aufrufparameter.

Gruß,

Simon2.
nur mal so zur info..
ne das geht nicht .. weil bei overloading von funktionen/methoden der Rückgabewert nicht dazu gehört.

Aber ganz sicher geht das (was da mit dem Funktionstemplate gemacht wurde) genauso mit overloading, obwohl der Rückgabewert nicht dazugehört (was mir bekannt war). :p

Gruß,

Simon2.

ne ist nicht so weil ich als rückgabewert
template <typename T>
T foo(T x)
{
/*code....*/
return x;
}

habe und wenn du das versuchen würdest zu überladen hättest du ein dickes problem.

Simon2

maybe schrieb:

ne ist nicht so weil ich als rückgabewert
template <typename T>
T foo(T x)
{
/*code....*/
return x;
}

habe und wenn du das versuchen würdest zu überladen hättest du ein dickes problem.

Ich glaube, Du übersiehst das Wesentliche:
template <typename T>
T foo(T x)
{
/*code....*/
return x;
}

Und genau deswegen geht das auch mit Overloading !

Gruß,

Simon2.

Shinja

Da du aber 2x den gleichen Typ hast koenntest du auch die Funtkionen ueberladen

string foo(string s);
int foo(int i);

Aber der Threadersteller woltle wohl eher sowas wie

template<class T>
T foo(int i);

oder so, denke ich.

mir geht es nicht um die parameterliste!!
mir geht es hier um den rückgabewert!!!
und wenn ich mich recht ensinne war seine frage wir er was zurückgeben kann und das geht nun mal mit overloading nicht..

und in dem thread geht es ja "Rückgabetyp einer Funktion variabel bestimmen?" ..

gruss
maybe :xmas1:

PS: frohes Fest trotzdem