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:

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

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

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

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

sag was du machen willst

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.

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

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

...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.

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 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.

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

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.

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.

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

gruss
maybe :xmas1:

PS: frohes Fest trotzdem

...
Aber der Threadersteller woltle wohl eher sowas wie

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

oder so, denke ich.

Das meinte ich mit

Simon2 schrieb:

.. ich denke aber, der OP möchte aber identische Aufrufparameter.

Gruß,

Simon2.

Gruß,

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.

Nur mal so ne Überlegung, was daraus werden soll:

DBase db("DNS");
db.Connect();

RSet rs(db.Execute("SQL-Irgendwas..."));

rs.MoveFirst();

do
{
    cout << rs.Fields("COL-Irgendwas").Value() << endl;
} while(rs.MoveNext());

rs.Close();
db.Close();

Spakko :xmas1:

...
Nur mal so ne Überlegung, was daraus werden soll:

DBase db("DNS");
db.Connect();

RSet rs(db.Execute("SQL-Irgendwas..."));

rs.MoveFirst();

do
{
    cout << rs.Fields("COL-Irgendwas").Value() << endl;
} while(rs.MoveNext());

rs.Close();
db.Close();

Spakko :xmas1:

Sowas hatte ich befürchtet.

OK, da braucht man wirklich ein Konzept "generischer Typen".
Wir hatten da einen Externen in unserer Firma, der hatte etwas Vergleichbares geschrieben ... und es war sehr gut ... und seeeehr aufwendig !

Als Erstes solltest Du Dir überlegen, wann und wie die Typinformation der DB in Dein Programm übergeben werden: Zur Compile-/Link/-Laufzeit ?
Je früher, desto "entspannter" kannst Du generisch programmieren (unaufwendiger, sicherer, ...).

Außerdem musst Du Dir überlegen, welce DB-interne Strukturen (Schlüsselbeziehungen, delete-Rules, Joins, Nullables, ....) Du nach Außen nutzbar machen möchtest ... und wie Du das abbildest.

Schließlich: Denke bei Deinen Entscheidungen nicht nur an Deine Schnittstelle, sondern auch an den armen Programmierer, der das nutzen muss - und daran, dass Du vermutlich in Konkurrenz zu "DB-eigenen APIs" (SQL, ...) stehst.
Wenn Deine Schnittstelle komplizierter zu nutzen ist als diese, wird sie sich kaum durchsetzen.

Naja, Du hast ja schon einiges zum Lesen und rumprobieren bekommen.

Frohe Weihnachten wünscht,

Simon2.

genau Shinja .. das wollte ich eigentlich sagen, ok mein Beispiel war wohl nicht irreführend..

das nicht kann man streichen habs verpeilt

ich habe mich auch auf diene aussage hier bezogen..

Simon2 schrieb:

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

aber ich denke mitlerweile ist klar geworden was du sagen wolltest und was ich sagen wollte oder?

gruss
maybe