Array aus Funktion zurückgeben

anno

Hallo zusammen,
ich will einer Funktion 2 werte übergeben. Das funktioniert auch wunderbar.

Doch Wie kann ich dann beim return der Funktion einen Array ausgeben und wie weise ich die enzelnen Elemente des Arrays wieder einzelnen Variablen zu. So wie ich das gemacht habe, wird halt immer nur eine Zahl ausgegeben, klar dass das falsch sit, aber mir ist leider ncihts besseres eingefallen.

Könntet ihr mir da bitte HELFEN?

mfg anno

int rueck(int zahl1, int zahl2) {

	  int zahl[2];
	 zahl[0] = zahl1;
	  zahl[1] = zahl2;

	  return zahl1[0],zahl1[1];
}

int main(int argc, char* argv[])
{
	   int zahl1,zahl2;
	   int out[1];

	 cin >> zahl1;
	 cin >> zahl2;

	 out[0] = rueck(zahl1,zahl2);
	 out[1] = rueck(zahl1,zahl2);

	 cout << out[0] << " " << out[1];;

	  getchar();
	  getchar();

	return 0;
}

CStoll

Arrays direkt kannst du nicht ausgeben, höchstens Pointer (wobei du aber beachten mußt, daß ihr Speicher das Ende der Funktion überlebt) oder Containerklassen.

(aber dazu gibt es hier schon etliche Threads - schau dich mal ein wenig im Board um ;))

lolz

Bei zwei Werten ist es einfach:

#include <utility>

std::pair< int, int > foo( int zahl1, int zahl2 )
{
  return std::make_pair( zahl1, zahl2 );
}

int main()
{
  std::pair< int, int > zweiZahlen( foo( 2, 3 ) );

  int zahl1 = zweiZahlen.first;
  int zahl2 = zweiZahlen.second;
};

Michael E.

Bei drei Werten auch: http://thedailywtf.com/forums/thread/109194.aspx

Badestrand

Ähm, eine Sache noch: Du deklarierst int out[1];. Liest dann aber in out[0] und out[1] ein. Die Variable kann aber nur ein Element beinhalten, weil out**[1]**! Also int out[2];

anno schrieb:

int rueck(int zahl1, int zahl2) { // Wenn das Array zurückgegeben werden soll
  // (und nicht nur zahl1[1]), dann muss der Typ des Rückgabewertes int* sein,
  // nicht nur int.

	  int zahl[2];
	 zahl[0] = zahl1;
	  zahl[1] = zahl2;

	  return zahl1[0],zahl1[1]; /* hier kommt allerdings nur zahl1[1] wieder
  zum Aufrufer der Funktion zurück */
}

Nach diesen Überlegungen definieren wir die Funktion etwas anders:

int* rueck(int zahl1, zahl2){ // int* statt int
 int* zahl = new int[2];
 zahl[0]=zahl1;
 zahl[1]=zahl2;
return zahl; // dieses Mal kommt tatsächlich das komplette Array zurück,
   // und nicht nur der Wert von zahl[1];
}

Jetzt nehmen wir noch die main() unter die Lupe

int main(int argc, char* argv[])
{
	   int zahl1,zahl2;
	   int out[1];  // Dieses Array ist erstmal zu klein, um darin
      // zwei Zahlen zu speichern, so wie es weiter unten im Programm
      // geschieht. Statische Arrays sind problematisch, weil der Arrayname
      // nicht auf der linken Seite einer Zuweisung stehen kann.
      // out = rueck(5,6) ist also beispielsweise nicht erlaubt

	 cin >> zahl1;
	 cin >> zahl2;

	 out[0] = rueck(zahl1,zahl2); // Das hier habe ich gemeint
	 out[1] = rueck(zahl1,zahl2); // es ist nur für eine Zahl Platz im Array

	 
       cout << out[0] << " " << out[1]; // Die einzigen Arrays, die cout <<
      // standardmäßig 'als Ganzes' ausgeben kann, sind char-Arrays
      // bei int-Arrays ist das nicht möglich

	  getchar(); // wieso?
	  getchar();

	return 0;
}

Nach all diesen Überlegungen schreiben wir die main() in modifizierter Form
noch einmal, außerdem wäre auch eine Ausgabefunktion für ein komplettes
Array günstig.

// Diese Funktion sollte dazu geeignet sein, das int-Array auszugeben
// (was ja cout << nicht kann)

#include<stdio.h>  // dafür brauchen wir <iostream> und namespace std nicht
 // mehr zu schreiben
void ausgabefunktion(int* Array,unsigned Elementezahl){
 for(int i=0;i<Elementezahl;i++)
  printf("%d\n",Array[i]);
}  // ausgabefunktion() können wir ab jetzt dazu verwenden, int-Arrays
   // komplett auszugeben

int main(int argc, char* argv[]){
 int zahl1=0,zahl2=0; // Einige neuere Compiler bekritteln sogar schon fehlende
    // Initialisierungen

 int* out=new int[2]; // Dieses Array ist gut für unsere Zwecke geeignet

 scanf("%d%d",&zahl1,&zahl2); // Macht das gleiche wie cin >> zahl1,
  // (etwas weniger fehleranfällig als cin >>)

 // Und jetzt bekommen wir ohne Probleme das komplette Array von der Funktion
 // rueck() zurückgegeben, können also schreiben:

 out = rueck(zahl1,zahl2);

 // Und auch die Ausgabe ist kein Problem mehr
 ausgabefunktion(out,2); // gibt das komplette Array aus

 return 0;
}

So fragwürdig der Sinn des Programmes auch ist, aber in etwa so sollte es funktionieren!

Mfg

Klar die Loesung ist super, macht ja nix dass du keine Ahnung hast, der Quellcode schlecht ist, und noch tolle Speicherleaks erzeugt.

Alle die von diesem ,,Prüforgan`` je geprüft wurden tun mir schrecklich leid.

LordJaxom

Prüforgan schrieb:

// (etwas weniger fehleranfällig als cin >>)

OMFG

Von dem doppelten new und den zwei Speicherlecks will ich garnicht sprechen...

Entenwickler schrieb:

Klar die Loesung ist super, macht ja nix dass du keine Ahnung hast, der Quellcode schlecht ist, und noch tolle Speicherleaks erzeugt.

Alle die von diesem ,,Prüforgan`` je geprüft wurden tun mir schrecklich leid.

Bei der Anforderung von Speicherplatz für insgesamt 4 int-Werte (16 Bytes, au!) von Speicherleaks zu sprechen ist lächerlich. Das demaskiert nur die totale Inkompetenz des Posters. Der Quellcode ist jedenfalls gut genug. Schlag erst etwas besseres vor, dann kann man Deine oberklugen Abqualifizierungen von Quelltexten als 'schlecht' vielleicht auch einmal ernst nehmen.

CStoll

Jeder Speicherverlust ist schlecht - und normalerweise ruft man so eine Funktion auch nicht nur einmal auf, dann läppern sich die Verluste ziemlich schnell.

Und bessere Möglichkeiten gibt es genug: Der einfachste Ansatz ist es wohl, sich vom Anwender das Array zu geben und zu füllen. Alternativ kannst du auch std::vector (oder in diesem Beispiel std::pair) verwenden.

PS: Und wenn du dich ein wenig besser mit der Speicherverwaltung auskennst, kannst du mal drüber nachdenken, wie man deine Funktion korrekt umsetzen kann