# Wert aus einer Funktion zurückgeben



## Studentin2009 (5. März 2010)

Hallo!

Das Problem klingt sehr simpel, aber trotzdem blicke ich da noch nicht so ganz durch.

Wann muss man aus einer Funktion einen Wert mit return zurückgeben?

Muss ich nur Werte zurückgeben, die nur innerhalb der Funktion definiert sind, oder auch global definierte?

Kann ich auch mehrere Werte zuückgeben? 
Wenn ja:
- schreibe ich dann 2x return xy?
- und rufe ich im Hauptprogramm die Funktion 2x auf, damit ich den Rückgabewert mit einem "=" davor schreiben kann? Oder kann ich die zusammenfassen?

Linda


----------



## 3Cyb3r (5. März 2010)

Hallo Linda
den return Wert einer Funktion definierst du in deinem Prototyp oder falls du keine hast direkt in der Funtkion (Falls diese über dem Programmeinstiegspunkt steht).
also z.B.:

```
// int ist der Typ von dem diese Funtkion ist
int macheirgendwas();  // prototyp

int main()   // Programmeinstiegspunkt
{
     //.............. 
    return 0;
}
int macheirgendwas()
{
    return 5;
}

int main()   // Programmeinstiegspunkt
{
     //.............. 
    return 0;
}
```

dein return Wert ist das, was vor dem Namen der Funtkion steht. In meinem Beispiel also int.
D.h. du musst in deiner Funktion eine Variable vom Typen Integer zurück geben.
Ob dies eine globale oder lokale variable ist, ist egal.
Wenn du eine Funktion habe mächtest du nichts zurück gibt benutzt du den Typ void
z.B.

```
void funtkionohnerueckgabewert()
{

// was auch immer

}
```

Das ganze könnte man auch so schreiben:

```
int macheirgendwas()
{
    return 5;
}
```

EDIT:
Ok das mit den 2 Returnwerten habe ich ganz vergessen. So wie du das meisnt geht es nicht, aber anders. Also du hast immer eine Varaible als Returnwert.
Ich weiß nicht wie weit du mit c/c++ bist. Du kannst deiner Funktion ja auch selbst definierte Typen asl Rückgabewert zuordnen.
also z.B. mit #define oder eine Objekt eienr Struktur oder eine Objekt einer Klasse (oder jeweils nur einen Zeiger darauf^^).
Beispiel:

```
struct return2values
{
   int x, y;
}

return2values meine Funtkion()
{
     return2values returnwert;
     returnwert.x = 1;
     returnwert.y = 2;

     return returnwert;
}

int main()
{
   return2values   structobjekt;
   structobjekt = meinefunkton();

   printf( "erster Wert: %d, zweiter Wert %d", structobjekt.x, structobjekt.y);
   return 0;
}
```


MFG
// Ich freue mich auch immer über positive Bewertugnen


----------



## Jennesta (5. März 2010)

> Muss ich nur Werte zurückgeben, die nur innerhalb der Funktion definiert sind, oder auch global definierte?
> 
> Kann ich auch mehrere Werte zuückgeben?
> Wenn ja:
> ...



Hi,
du kannst natürlich auch globale Variablen zurückgeben, jedoch muss man sich immer fragen, ob dies wirklich Sinn macht, da sie ja eben global sind und das Programm diese Variablen kennen sollte. Und ob die Funktion auch immer die globale Variable kennt (bspw. wenn die Funktion in einer anderen Datei als die globale Variable steht). Musst du halt mit aufpassen.

2 Werte kannst du mit einer Funktion soweit ich weiß nicht zurück geben. Hier bietet es sich an, der Funktion Zeiger auf die Variablen zu übergeben, die Werte dann in der Funktion so zu verändern wie du sie möchtest und keinen Wert zurück zugeben. Also eine Funktion mit dem Typ void zu schreiben. Beispiel wäre zb die Funktion swap() die 2 Werte vertauscht.
Und dann greifst du wieder in deinem Programm auf die veränderten Werte zu.

Gruß Jennesta


----------



## Marschal (5. März 2010)

Zu mehreren rückgabewerten:
du kannst alles mögliche als rückgabetyp festlegen.

Wenn deine Funktion zum Beispiel nur globale variablen verrechnen muss, braucht du ja keinen Rückgabe wert, also eine void Funktion.

```
//globale variablen
int erg;

int main()
{
//...
Addition(2,3);
//..
}

void Addition(int a, in bt)
{
erg =a + b;
}
```
so hättest du eine Funktion ohne rüchgabewert und dein ergebniss steht in allen Funktion global zur Verfügung.

Du kannst aber auch mehre Werte zurück geben lassen(arrays zb.)

```
int[] vektoraddition(int ax, int ay, int bx, int by)
{
int erg[] = new int[2];
erg[0] = ax + bx;
erg[1] = ay + by;

return erg;
}
```
diese Funktion gibt ein eindimensionales Array beliebiger gröse zurück.

Hoffe mein Vorredner und ich konnten dir Klarheit verschaffen


----------



## Studentin2009 (5. März 2010)

Also...  Lange Rede kurzer Sinn.. globale Variablen muss ich nicht zurückgeben! Danke! 
Das wollte ich vorallem wissen!


Eine Frage hätte ich aber noch:

Was bedeutet das wenn ich zB. so eine Funktion vor mir habe:

zk_typ*genstring(char*str)

So habe ich ja kein void o.ä. da stehen, sondern nur einen Pointer. Was sagt mir das für die Bearbeitung des Strings und wie berücksichtige ich das dann bei meinem Rückgabewert?

Grüße Linda


----------



## 3Cyb3r (5. März 2010)

Studentin2009 hat gesagt.:


> zk_typ*genstring(char*str)
> 
> So habe ich ja kein void o.ä. da stehen, sondern nur einen Pointer. Was sagt mir das für die Bearbeitung des Strings und wie berücksichtige ich das dann bei meinem Rückgabewert?



Das sagt dir absolut garnichts für die Bearbeitung des Strings.
Nur der Rückgabewert muss dann vom Typ Zeiger auf zk_typ sein.
Jedoch müsste man schon wissen was zk_Typ ist, da gäbe es ja Tausende Möglichkeiten.


----------

