ich bin ein C++ Anfänger und hab ein problem.
Ich habe eine Funktion in der ich 2 Werte zurückgeben will, weiss aber nicht wie...
so sieht mein Programm in etwa aus(sehr, sehr vereinfacht auf das Problem):

# include <iostream>
using namespace std;

int funktion1(int a, int b)
{
    //Berechnungen (veränderung von a und b)

    return a, b; //so in etwa
}

int main()
{
    int a=1;
    int b=2;
    //....

    funktion1(a,b);
    //weitere Berechnungen mit den von funktion1 zurückgegebenen Werten

    return 0;
}

hoffe ihr könnt mir schnell helfen.

mfg

struct Zahlen
{
    int zahl1;
    int zahl2;
};

Dann kannst du die Variable zahl1 in dem struct Zahlen verändern, zahl2 ebenso und dann gibst du einfach das komplette Struct zurück. So gesehen könntest du unendlich viele Variablen auf diese Weise zurückgeben.

wenn ich das struct zurückgegeben habe, wie kann ich dann wieder auf die einzelnen variablen zurückgreifen?

#include <iostream>
#include <vector>

//Struct Variante
struct Zahlen
{
    int StructZahl1;
    int StructZahl2;
    Zahlen(int zahl1, int zahl2) : StructZahl1(zahl1), StructZahl2(zahl2) { }
};

Zahlen Funktion(int zahl1, int zahl2)
{
    return Zahlen(zahl1, zahl2);
}
//////////////////

//Vector Variante
std::vector<int> Funktion2(int zahl1, int zahl2)
{
    std::vector<int> VectorZahlen;
    VectorZahlen.push_back(zahl1);
    VectorZahlen.push_back(zahl2);
    return VectorZahlen;
}
/////////////////

//Array Variante - Nicht wirklich schön
int* Funktion3(int zahl1, int zahl2)
{
    static int Array[2];
    Array[0] = zahl1;
    Array[1] = zahl2;
    return Array;
}
////////////////

//Pair Variante - Meiner Ansicht nach die beste Variante
std::pair<int, int> Funktion4(int zahl1, int zahl2)
{
    return std::pair<int, int>(zahl1, zahl2);
}
///////////////

int main()
{
    //Struct Variante
    Zahlen z = Funktion (5, 6);
    std::cout << z.StructZahl1 << " " << z.StructZahl2 << std::endl;

    //Vector Variante
    std::vector<int> v = Funktion2(5, 6);
    std::cout << v[0] << " " <<v[1] << std::endl;

    //Array Variante - Nicht wirklich schön
    int* a = Funktion3(5, 6);
    std::cout << a[0] << " " << a[1] << std::endl;

    //In deinem Fall willst du 2 Zahlen zurückgeben, also wird
    //diese Variante wohl für sich sprechen
    std::pair<int, int> p = Funktion4(5, 6);
    std::cout << p.first << " " << p.second;
}

Ich war auch schon in einer ähnlichen Situation. Wäre eventuell "pass by reference" noch eine Möglichkeit oder ist das sehr hässlich?

Zeig mal, wie soll das denn dann aussehen?

@FreakY<3Cpp
const und reference sollten dir aber kein Fremdwort sein

#include <iostream>

void Funktion(int &zahl1, int &zahl2)
{
    zahl1 = 7;
    zahl2 = 3;
}

int main()
{
    int zahl1 = 5;
    int zahl2 = 6;
    Funktion(zahl1, zahl2);
    std::cout << zahl1 << " " << zahl2;
}

Wäre natürlich auch eine Variante, gefällt mir auch persönlich besser als die Arraysache, aber ist nunmal Geschmackssache.

Edit:

Kóyaánasqatsi schrieb:

@FreakY<3Cpp
const und reference sollten dir aber kein Fremdwort sein

... Nein, aber ich hab es eben schnell hingeklatscht, da hab ich jetzt auf Sachen die zwar gut wären, aber nicht von nöten sind, weggelassen.

Zeig mal, wie soll das denn dann aussehen?

Ich an so etwas gedacht:

#include <iostream>

void calculate_something(int & a, int & b);

int main()
{
	using namespace std;

	int a = 10;
	int b = 20;

	cout << "Before calculation: " << "a = " << a << ", b = " << b;

	calculate_something(a, b);

	cout << endl << endl;
	cout << "Before calculation: " << "a = " << a << ", b = " << b;
	cout << endl << endl;

	return 0;
}

void calculate_something(int & a, int & b)
{

	a += 10;
	b += 20;

}

Natürlich ist die Berechnung in calculate_something(...) völliger Unfug, reicht aber als Beispiel. Hier hat man zwar keine Rückgabewerte, die beiden Werte a und b wurden aber trotzdem verändert.

So wie ich das sehe wäre das auch eine Möglichkeit.

*Edit:
@ FreakY<3Cpp
Jup, genau das habe ich gemeint

icarus2 schrieb:

Ich war auch schon in einer ähnlichen Situation. Wäre eventuell "pass by reference" noch eine Möglichkeit oder ist das sehr hässlich?

Zeig mal, wie soll das denn dann aussehen?

@FreakY<3Cpp
const und reference sollten dir aber kein Fremdwort sein

Wie du das mitner const reference machst will ich aber mal sehen...

# include <iostream>
using namespace std;

int funktion1(int a[2])
{
    //Berechnungen (veränderung von a[0] und a[1])

    return a;
}

int main()
{
    int a[2]
    a[0]=1;
    a[1]=2;
    //....

    funktion1(a);
    //weitere Berechnungen mit den von funktion1 zurückgegebenen Werten

    return 0;
}

Mein Programm is etwas komplizierter als mein beispiel hier, aber vom prinzip is es das selbe.
habe meine 2 variablen ganz weggelassen und habe gleich mit array gerechnet, übergeben und zurückgegeben...

ich danke euch für die hilfe...

oder haben net funktioniert.

Kann nicht sein, ich hab alle getestet und alle haben einwandfrei funktioniert.

so wird langsam zeit. ich geh jatzt pennen...

Mein Programm is etwas komplizierter als mein beispiel hier, aber vom prinzip is es das selbe.
habe meine 2 variablen ganz weggelassen und habe gleich mit array gerechnet, übergeben und zurückgegeben...

Ich weiss zwar nicht, was du genau gemacht hast, aber ein natives Array zurückgegeben hast du bestimmt nicht..

Ich hätte einfach die beiden Werte als Referenz an die Funktion übergeben.
Find ich am besten;-)

Je nachdem macht eine Klasse, die als tuple fungiert auch Sinn.