also, ich habe eine funktion, die eigentlich 2 werte zurückgeben soll. geht das? ich glaube eher nich aber ich frage trotzdem mal

da hokage

struct Pair
{
    int first, second;
};

Pair ThisFuncReturnsTwoValuesInAStruct(void)
{
    //do something and return a Pair
}

Felix

Du könntest eine Struktur erstellen, und diese zurückgeben:

struct ResultA
{
 float wert1;
 int   wert2;
};

ResultA Funktion()
{
 //...
 ResultA data;
 data.wert1 = 0;
 data.wert2 = 1;

 return data;
}

Oder du benutzt einfach Zeiger / Referenzen:

void Funktion(float* wert1, int* wert2)
{
  // ...
  *wert1 = 0;
  *wert2 = 1;
}

#include <iostream>

void getTwoNumbers(int& number_1, int& number_2)
{
    number1 = 5;
    number2 = 17;
}

int main()
{
    int num_1 = 0, num_2 = 0;
    std::cout << num_1 << ' ' << num_2 << std::endl;
    getTwoNumbers(num_1, num_2);
    std::cout << num_1 << ' ' << num_2 << std::endl;

    std::cin.get();
    return 0;
}

Es gibt natürlich noch mehr Möglichkeiten z.B. einen Vector returnen oder boost::tuple verwenden. Kommt immer auf das konkrete Problem an.

Edit: viel zu spät...

Gruß
Don06

#include <string>
#include <utility>
#include <iostream>

std::pair< int, std::string > foo( ) {

	return std::pair< int, std::string >( 43, "stupid question" );
}
int main( ) {

	std::cout << foo( ).first << ", " << foo( ).second << std::endl;
}

greetz, Swordfish

Gruß
Don06

#include <string>
#include <utility>
#include <iostream>

std::pair< int, std::string > foo( ) {
    int x;
    //festlegung x
    x= irgendwas;
    int y;
    //festlegung y
    y = auchirgendwas;
    return std::pair< int, int >( x,y );
}
int main( ) {

    std::cout << foo( ).first << ", " << foo( ).second << std::endl;
}

nur um ma bei dem code zu bleiben

ok, danke nochma für die hilfe

std::pair<int, std::string>

in

std::pair<int, int>

ändern.

BTW: boost enthält eine Template Klasse namens "tuple" die auch mehr als 2 Elemente halten kann. Und eine nette erweiterung namens "tie" mit der man dann folgendes machen kann:

boost::tuple<int, int, int> foo()
{
    return boost::tuple<int, int, int>(1, 2, 3);
}

std::pair<int, int> bar()
{
    return std::pair<int, int>(1, 2);
}

void baz()
{
    int x, y, z;
    boost::tie(x, y, z) = foo();
    // nun ist x == 1, y == 2 und z == 3 :)

    // und geht natürlich auch mit std::pair
    boost::tie(x, y) = bar();
}

hokage schrieb:

kann ich da auch variablen aus der entsprechenden funktion reinpacken?

törlich

#include <iostream>
#include <string>
#include <time.h>
using namespace std;

void umlaute_string( string& str )
{
	unsigned long i = 0;
	unsigned char c = 0;

	//if ( GetConsoleOutputCP() != 850 ) return NULL;

	for ( i; i < str.size(); i++ )
	{
		c = str.at(i);
		switch ( c )
		{
			case 228: // Ä
				 str.at(i) = (char)132;
			break;

			case 196: // ä
				 str.at(i) = (char)142;
		    break;

			case 246: // ö
				str.at(i) = (char)148; 
		    break;

			case 214: // Ö
				 str.at(i) = (char)153;
		    break;

			case 252: // ü
				 str.at(i) = (char)129;
		    break;

			case 220: // Ü
				 str.at(i) = (char)154;
		    break;

			case 223: // ß
				 str.at(i) = (char)225;
		    break;
		}
	}
}

int multi_returner( int& c ) // multi ritöörna !!!
{
	static int y = 0;
	int Variable_In_Entsprechender_Funktion;

	for ( int i = 0; i < 100; i++ )
	{
		Variable_In_Entsprechender_Funktion = rand();
	}

	c = Variable_In_Entsprechender_Funktion;

	return y += 1;

}

int main()
{
	unsigned  n = 0;
	int Variable_Aus_Entsprechender_Funktion;

	srand( (unsigned)time( NULL ) );

	string str("Just a test ääähöömmmiaüüüüüü");
	string str1("ritöörned ??? ");
	string str2("hätten");
	string str3("ritöörned ");

	umlaute_string( str  );
	umlaute_string( str1  );
	umlaute_string( str2  );
	umlaute_string( str3  );

	cout << str << endl;

	cout << "Wie viele Werte " << str2 <<  " haetten Sie denn gern " << str1;
	cin >> n;

	if ( n < 5 )
	{
		cout << "Iiiiiiiiiih sind Sie aber knauserig ! " << endl;
		return 0;
	}

	if ( (signed)n < 0 )
	{
		cout << "Doch so viele ? " << endl;
		return 0;
	}

	for ( int i = 0; i < n; i++ )
	{
		cout << str3 << multi_returner( Variable_Aus_Entsprechender_Funktion) << endl;
		cout << "(RANDOM)Variable_Aus_Entsprechender_Funktion: ";
		cout << Variable_Aus_Entsprechender_Funktion << endl;
	}

	return 0;
}

MfG,
p.

--------------------------------------------------------------------------------
Boost Me Up !

Boost Me Up !

Ok, gern !
Here we go:

#include <iostream>
using namespace std;

namespace OVER_BOOOSTERRR 
{
	class MyOVER_BOOOSTER
	{
		private:

			string boost_me;
		public:

			MyOVER_BOOOSTER()
			{
				boost_me = "BOOOOOOOOOOOOOOOOOOOOOOOOOOOOST !!! ";
			}

			string boost_me_up_exclamation_mark() const
			{
				return boost_me;
			}
	};

	ostream &operator<<( ostream &ostr, const MyOVER_BOOOSTER& mb ) 
	{ 
		ostr << mb.boost_me_up_exclamation_mark();
		return ostr;
	} 
}

namespace proggingmania = OVER_BOOOSTERRR;

int main()
{
	cout << "boost - booster is going to boost: " << endl;
	cout <<  "boost(piep)" << endl;
	cout << "done." << endl;

    cout << endl << endl << endl;

	using namespace proggingmania;
	MyOVER_BOOOSTER BOOOSTER;
	cout << "Proggingmanias - booster is going to boost: " << endl;
	cout << "Sure you are ready for this ? Type: [y/n] and ENTER ";

    char c; cin >> c;
	if ( c == 'y' || c == 'Y' )
	{
		 cout << BOOOSTER << endl;
		 cout << "DONE." << endl;
	}
	else
	{
	   cout << "Har Har little coward" << endl;
	}

	int dummy;
	cin >> dummy;
	return 0;
}

MfG

Sei f eine Menge von geordneten Paaren.
f ist genau dann eine Funktion, falls für alle a,b,c Folgendes gilt:
(a,b) ε f UND aus (a,c) ε f FOLGT b == c
Grundsatz der Rechtseindeutigkeit. Was auch immer diese Definition nicht erfüllt, ist keine Funktion. So sehen es die Mathematiker.

Ähnliche Gedanken haben sich die Entwickler der Programmiersprachen gemacht, und weil obendrein ein Register nur 32 Bit oder 64 Bit breit sein kann, andererseits der Aufrufer einer Funktion sich aus diesem einen Register bedient und dessen Inhalt als Rückgabewert der Funktion interpretiert, kann höchstens ein Zeiger auf einen mittels calloc oder malloc oder new angeforderten Speicherbereich buchstäblich an den Aufrufer 'zurückgegeben' werden. Hoffentlich verwaltet irgendeine globale Funktion den Speicher, um nicht unnötig Speicherlöcher durch den Funktionsaufruf verursachen zu lassen. Aber auch andernfalls ist immer noch das gute alte Betriebssystem dafür zuständig, die letztendliche Kommunikation mit der MMU zu führen. Wie schön für den Programmierer.

Wie auch immer, es ist ÜBLICH und GESUND, einer Funktion, die mehrere Rückgabewerte haben soll (und das ist nicht gerade selten), einen Zeiger auf einen VOM AUFRUFER bereitgestellten Speicherbereich als Parameter zu übergeben, in den die Funktion ihre Resultate hineinschreiben kann. (1)
Nach dem Aufruf der Funktion kann sich der Aufrufer aus seinem von ihm selbst verursachten Speicherloch bedienen und die Daten weiterverarbeiten.

Eine Funktion im Programmier-Technischen Sinn kann also entgegen aller mathematischer Definitionen durchaus - zumindest indirekt - weit mehr als nur einen Wert zurückliefern. Aber eben nur indirekt.
Nur muss eben der Aufrufer auch den Speicherbereich für die vielen Werte bereitstellen. Oder auch nicht. Speziell dann, wenn der Programmierer groben Unfug als Parameter an die Funktion übergibt. Dann hat es sich der Aufrufer auch nicht verdient, dass die Funktion korrekte Werte 'indirekt' zurückliefert.

Was auch immer diese Definition nicht erfüllt, ist keine Funktion. So sehen es die Mathematiker.
Ähnliche Gedanken haben sich die Entwickler der Programmiersprachen gemacht, und weil obendrein ein Register nur 32 Bit oder 64 Bit breit sein kann...

wie in mathe eine funktion definiert ist, oder wie's auf maschinenebene abläuft, steht doch gar nicht zu debatte. in 'besseren' programmiersprachen kann eine funktion beliebig viele werte ausspucken, auch ohne speicherlöcher zu erzeugen
das ist einfach so...

Karawarankarahahaha schrieb:

Was auch immer diese Definition nicht erfüllt, ist keine Funktion. So sehen es die Mathematiker.
Ähnliche Gedanken haben sich die Entwickler der Programmiersprachen gemacht, und weil obendrein ein Register nur 32 Bit oder 64 Bit breit sein kann...

das ist einfach so...

Das wäre allerdings eine Überraschung. Sozusagen packt die Funktion mehrere Rückgabewerte einfach in ein 32- oder 64- bit Register, und der Aufrufer freut sich darüber.
Vielleicht gibt's das ja in einer modernen Fassung von Hauff's Märchen. Es wäre jedenfalls ein märchenhaftes Wunder der Technik.

Wie auch immer, es ist ÜBLICH und GESUND, einer Funktion, die mehrere Rückgabewerte haben soll (und das ist nicht gerade selten), einen Zeiger auf einen VOM AUFRUFER bereitgestellten Speicherbereich als Parameter zu übergeben, in den die Funktion ihre Resultate hineinschreiben kann.

Soo ein Quark. Und dann noch ohne Begründung. Merke: Caps Lock schreit stets nach einer Begründung.

Wieso ist es üblich (habe ich in C++-Code außer in Spezialfällen und bei 'swap' noch nicht gesehen)? Wieso ist es gesund?

Was spricht dagegen, ein Tupel zurückzugeben und den Compiler die Optimierung (NROV ...) machen zu lassen? Der Mathematiker hätte zumindest *nichts* dagegen, denn aus dessen Sicht befindet man sich halt in einem höherdimensionalem Raum und gibt einen Vektor zurück -- so what? Das machen die sowieso den ganzen Tag, ohne sich dran zu stoßen.

@alle, die hier immer 'std::pair<T1, T2>' durch die Gegend werfen: Mögt ihr 'std::make_pair' nicht?