So geben Sie in C++ mehrere Werte zurück

So Geben Sie In C Mehrere Werte Zuruck



Die Sprache C++ bietet uns viele Funktionen und erleichtert unsere Programmierung erheblich. Aber manchmal müssen wir bei der Arbeit mit C++-Programmierung mehrere Werte zurückgeben. Leider unterstützt uns C++ mit dieser Funktion nicht. Um in C++ mehrere Werte zurückzugeben, müssen wir verschiedene Techniken verwenden. Wir können in C++ mithilfe von Tupeln/Paaren, Zeigern und Arrays mehrere Werte zurückgeben. Wir werden alle diese Techniken in diesem Handbuch gründlich studieren, zusammen mit Codes und Erklärungen.

Beispiel 1: Nutzung der Tupel/Paare

Lassen Sie uns eine praktische Demonstration zur Rückgabe mehrerer Werte in C++ durchführen. Hier verwenden wir die Tupel-/Paartechniken, um die Rückgabe mehrerer Werte in unserem Code zu unterstützen. C++ stellt verschiedene Header-Dateien zur Verfügung, die wir in unseren Code einbinden müssen. Wir fügen hier „bits/stdc++.h“ ein, da es alle Bibliotheken der C++-Programmierung enthält. Dann wird hier der Namespace hinzugefügt, der „std“ ist. Danach verwenden wir das Schlüsselwort „tuple“, in dem wir drei Datentypen, zwei Float-Datentypen und den verbleibenden Datentyp „char“ platzieren. Darunter verwenden wir das Schlüsselwort „return“, um die Werte zu packen und ein Tupel zurückzugeben.

Jetzt verwenden wir die „Pair“-Methode, um mehrere Werte zurückzugeben. In dieser „Paar“-Methode geben wir die Datentypen zweier Variablen ein, und beide sind hier „Float“. Die Variablen heißen „float_1“ und „float_2“. Dann packen wir zwei Werte, um zu den „Paaren“ zurückzukehren. Danach rufen wir hier „main()“ auf und deklarieren dann zwei „float“-Variablen mit dem Namen „f_1, f_2“. Die Variable „char“ wird hier auch als „myChar“ deklariert. Anschließend entpacken wir die Werte, die von der Funktion „My_Tuple()“ zurückgegeben werden.







Darunter speichern wir die zurückgegebenen Werte paarweise. Wir speichern „4,99, 8,98“ in der Funktion „My_Tuple“ und „6,86, 3,22“ in der Funktion „My_Pair“. Dann verwenden wir den „Cout“, der alle darin geschriebenen Informationen ausdruckt.



Code 1:



#include
verwenden Namensraum std ;
Tupel < schweben , schweben , verkohlen > My_Tuple ( schweben f_1, schweben f_2 ) {
zurückkehren make_tuple ( f_2, f_1, '$' ) ;
}
Paar < schweben , schweben > Mein_Paar ( schweben Fa, schweben f_b ) {
zurückkehren make_pair ( f_b, f_a ) ;
}
int hauptsächlich ( ) {
schweben f_1,f_2 ;
verkohlen myChar ;
binden ( f_1, f_2, myChar ) = My_Tuple ( 4,99 , 8,98 ) ;
Paar new_p = Mein_Paar ( 6,86 , 3.22 ) ;
cout << „Werte, die wir durch Tupel erhalten:“ ;
cout << f_1 << ' ' << f_2 << ' ' << myChar << endl ;
cout << „Werte, die wir pro Paar erhalten:“ ;
cout << new_p. Erste << ' ' << new_p. zweite ;
zurückkehren 0 ;
}

Ausgabe :





Die Werte, die wir hier durch die Verwendung der „Tupel“- und der „Paar“-Methode erhalten, werden im Folgenden angezeigt. Beachten Sie, dass hier mehrere Werte zurückgegeben werden.



Beispiel 2: Verwendung der Zeiger

Wir übergeben hier die Parameter zusammen mit ihren Adressen in der Funktion „compare“. Wir fügen „value_1“ und „value_2“ vom Typ „int“ und die „int* g_Address, int* s_Address“ hinzu. Danach verwenden wir die „if“-Bedingung, in der wir eine Bedingung hinzufügen, dass „value_1“ größer als „value_2“ ist. Wenn dies erfüllt ist, wird die folgende Anweisung ausgeführt. Ist dies nicht der Fall, ignoriert es die darunter hinzugefügte Anweisung und geht zum „else“-Teil über. Nachdem wir nun „main()“ aufgerufen haben, deklarieren wir vier neue Variablen mit den Namen „g_value“, „s_value“, „newValue1“ und „newValue2“.

Danach drucken wir eine Nachricht aus, um die Zahlen einzugeben, und geben dann „cin“ ein, wodurch zwei Werte vom Benutzer abgerufen werden. Die vom Benutzer eingegebenen Werte werden in den Variablen „newValue1“ bzw. „newValue2“ gespeichert. Danach rufen wir die Funktion „compare()“ auf, die wir zuvor erstellt haben, und übergeben ihr vier Parameter. Dann zeigen wir das Ergebnis an, nachdem wir die Funktion „Vergleichen“ ausgeführt haben, und es zeigt die größere und die kleinere Zahl der vom Benutzer eingegebenen Zahlen an.

Code 2:

#include
verwenden Namensraum std ;
Leere vergleichen ( int Wert_1, int value_2, int * g_Adresse, int * s_Adresse )
{
Wenn ( Wert_1 > value_2 ) {
* g_Adresse = Wert_1 ;
* s_Adresse = value_2 ;
}
anders {
* g_Adresse = value_2 ;
* s_Adresse = Wert_1 ;
}
}
int hauptsächlich ( )
{
int g_value, s_value, newValue_1, newValue_2 ;
cout << „Bitte geben Sie zwei Zahlen ein:“ <> neuerWert_1 >> neuerWert_2 ;
vergleichen ( neuerWert_1, neuerWert_2, & g_Wert, & s_value ) ;
cout << ' \N Die größere Zahl ist „ << g_value << „und die kleinere Zahl ist“
<< s_value ;
zurückkehren 0 ;
}

Ausgabe :
Hier gibt der Benutzer „86“ und „23“ ein. Nach Drücken von „Enter“ wird das Ergebnis angezeigt. Auf diese Weise erhalten wir mehrere Werte.

Beispiel 3: Verwendung des Arrays

Wir erstellen hier die Funktion „ComputeComparison()“, in die wir zwei Variablen „num_1“ und „num_2“ als Typ „int“ sowie ein Array namens „my_arr[]“ einfügen. Danach haben wir die „if“-Bedingung, die prüft, ob „num_1“ größer als „num_2“ ist oder nicht. Wenn dies zutrifft, wird „num_1“ „my_arr[0]“ und „num_2“ „my_arr[1]“ zugewiesen. Wenn die Bedingung jedoch nicht wahr ist, werden die Anweisungen nach „else“ ausgeführt, in denen wir „num_2“ zu „my_arr[0]“ und „num_1“ zu „my_arr[1]“ zuweisen.

Danach rufen wir hier „main()“ auf und deklarieren dann zwei weitere int-Variablen: „newNum_1“ und „newNum_2“. Danach wird ein Array der Größe „2“ deklariert. Danach erhalten wir mit Hilfe von „cin“ zwei Zahlen vom Benutzer und rufen dann die Funktion „ComputeComparison()“ auf und zeigen das folgende Ergebnis an. Daher werden hier mehrere Werte zurückgegeben.

Code 3:

#include
verwenden Namensraum std ;
Leere ComputeComparison ( int num_1, int num_2, int my_arr [ ] )
{

Wenn ( num_1 > num_2 ) {
my_arr [ 0 ] = num_1 ;
my_arr [ 1 ] = num_2 ;
}
anders {
my_arr [ 0 ] = num_2 ;
my_arr [ 1 ] = num_1 ;
}
}

int hauptsächlich ( )
{
int newNum_1, newNum_2 ;
int my_arr [ 2 ] ;

cout << „Bitte geben Sie zwei Zahlen zum Vergleich ein“ <> newNum_1 >> newNum_2 ;
ComputeComparison ( newNum_1, newNum_2, my_arr ) ;
cout << ' \N Die größere Zahl ist „ << my_arr [ 0 ] << ' und das '
„Kleinere Zahl ist“ << my_arr [ 1 ] ;

zurückkehren 0 ;
}

Ausgabe :
Wir geben hier sowohl „54“ als auch „98“ ein und drücken dann „Enter“, um das Ergebnis anzuzeigen. Es zeigt sowohl die größeren als auch die kleineren Zahlen der von uns eingegebenen Zahlen.

Beispiel 4: Nutzung der Tupel

Hier sind zwei Header-Dateien enthalten: „tuple“ und „iostream“. Als nächstes wird hier der Namespace „std“ abgelegt. Als nächstes verwenden wir das Schlüsselwort „tuple“ und fügen zwei Datentypen ein, die „int“ sind. Anschließend erstellen wir eine Funktion mit dem Namen „findingValues()“ und übergeben als Parameter „intValue_1“ und „intValue2“.

Dann wird das „if“ dort platziert, wo wir die Bedingung „intValue_1 < intValue_2“ eingeben. Darunter verwenden wir das Schlüsselwort „return“ und platzieren die Funktion „make_tuple()“, in der beide Variablen als Parameter „intValue_1, intValue2_“ hinzugefügt werden. Dann haben wir den „else“-Teil, in den wir zusammen mit der Funktion „make_tuple()“ wieder „return“ einfügen. Aber hier platzieren wir zuerst den „intValue_2“ und dann den „intValue1“. Nun rufen wir „main()“ auf und initialisieren „new_value1“ mit „5“ und „new_value2“ mit „28“.

Im Folgenden deklarieren wir zwei weitere Variablen vom Typ „int“ mit den Namen „größer“ und „kleiner“. Dann platzieren wir die Funktion „tie()“ und übergeben die „kleineren, größeren“ Variablen als Parameter und rufen hier auch die Funktion „findingValues()“ auf. Danach drucken wir beide Werte aus: die größere und die kleinere Zahl.

Code 4:

#include
#include
verwenden Namensraum std ;
Tupel  findingValues ( int intValue_1, int intValue_2 )
{
Wenn ( intValue_1 < intValue_2 ) {
zurückkehren make_tuple ( intValue_1 , intValue_2 ) ;
}
anders {
zurückkehren make_tuple ( intValue_2 , intValue_1 ) ;
}
}
int hauptsächlich ( )
{
int neuer_Wert1 = 5 , neuer_Wert2 = 28 ;
int größer, kleiner ;
binden ( kleiner, größer ) = Werte finden ( neuer_Wert1, neuer_Wert2 ) ;
printf ( „Die größere Zahl ist %d und die“
„Kleinere Zahl ist %d“ ,
größer, kleiner ) ;
zurückkehren 0 ;
}

Ausgabe :

Die Zahlen, die wir unserem Code hinzufügen, zeigen gleichzeitig die größeren und kleineren Werte an. Auf diese Weise können wir problemlos mehrere Werte in unserem Code zurückgeben.

Abschluss

In diesem Leitfaden geht es um die „Rückgabe mehrerer Werte“ in C++-Codes. Wir haben diesen Begriff in diesem Leitfaden ausführlich untersucht und drei Techniken besprochen, die bei der Rückgabe mehrerer Werte in der C++-Programmierung helfen. Wir haben erklärt, dass mithilfe der Tupel-, Paar-, Zeiger- und Array-Techniken mehrere Werte zurückgegeben werden. Alle diese Techniken werden hier ausführlich beschrieben.