Comment renvoyer plusieurs valeurs en C++

Comment Renvoyer Plusieurs Valeurs En C



Le langage C++ nous offre de nombreuses fonctionnalités et facilite grandement notre programmation. Mais parfois, nous devons renvoyer plusieurs valeurs lorsque nous travaillons avec la programmation C++. Malheureusement, C++ ne nous facilite pas cette fonctionnalité. Pour renvoyer plusieurs valeurs en C++, nous devons utiliser les différentes techniques. Nous pouvons renvoyer plusieurs valeurs en C++ en utilisant des tuples/paires, des pointeurs et des tableaux. Nous étudierons en profondeur toutes ces techniques dans ce guide ainsi que des codes et des explications.

Exemple 1 : Utilisation des tuples/paires

Faisons une démonstration pratique pour renvoyer plusieurs valeurs en C++. Ici, nous utilisons les techniques de tuples/paires pour aider à renvoyer plusieurs valeurs dans notre code. C++ fournit divers fichiers d'en-tête que nous devons inclure dans notre code. Nous incluons ici « bits/stdc++.h » car il contient toutes les bibliothèques de programmation C++. Ensuite, l'espace de noms est ajouté ici qui est « std ». Après cela, nous utilisons le mot-clé « tuple » dans lequel nous plaçons trois types de données, deux types de données float et le type de données « char » restant. En dessous, nous utilisons le mot-clé « return » pour regrouper les valeurs afin de renvoyer un tuple.

Maintenant, nous utilisons la méthode « paire » pour renvoyer plusieurs valeurs. Dans cette méthode « paire », nous mettons les types de données de deux variables, et les deux sont ici « flottants ». Les variables sont nommées « float_1 » et « float_2 ». Ensuite, nous emballons deux valeurs pour revenir aux « paires ». Après cela, nous invoquons ici le « main() », puis déclarons deux variables « float » avec le nom « f_1, f_2 ». La variable « char » est également déclarée ici comme « myChar ». Ensuite, nous décompressons les valeurs renvoyées par la fonction « My_Tuple() ».







En dessous, nous stockons les valeurs renvoyées par paires. Nous stockons « 4,99, 8,98 » dans la fonction « My_Tuple » et « 6,86, 3,22 » dans la fonction « My_Pair ». Ensuite, nous utilisons le « cout » qui imprime toutes les informations qui y sont écrites.



Codage 1 :



#include
en utilisant espace de noms norme ;
tuple < flotter , flotter , carboniser > Mon_Tuple ( flotter f_1, flotter f_2 ) {
retour make_tuple ( f_2, f_1, '$' ) ;
}
paire < flotter , flotter > Ma_Paire ( flotter FA, flotter f_b ) {
retour make_pair ( f_b, f_a ) ;
}
int principal ( ) {
flotter f_1,f_2 ;
carboniser monChar ;
cravate ( f_1, f_2, monChar ) = Mon_Tuple ( 4,99 , 8,98 ) ;
paire new_p = Ma_Paire ( 6,86 , 3.22 ) ;
cout << 'Valeurs que nous obtenons par tuples : ' ;
cout << f_1 << ' ' << f_2 << ' ' << monChar << fin ;
cout << « Valeurs que nous obtenons par paire : » ;
cout << nouveau P. d'abord << ' ' << nouveau P. deuxième ;
retour 0 ;
}

Sortir :





Les valeurs que nous obtenons ici en utilisant les méthodes « tuples » et « paire » sont affichées ci-dessous. Notez qu'il renvoie ici plusieurs valeurs.



Exemple 2 : Utilisation des pointeurs

Nous transmettons ici les paramètres ainsi que leurs adresses dans la fonction « comparer ». On ajoute « value_1 » et « value_2 » de type « int » et les « int* g_Address, int* s_Address ». Après cela, nous utilisons la condition « si » dans laquelle nous ajoutons une condition selon laquelle la « valeur_1 » est supérieure à « valeur_2 ». Si cela est satisfait, l'instruction suivante est exécutée. Si ce n'est pas le cas, il ignore l'instruction ajoutée en dessous et se déplace vers la partie « else ». Maintenant, après avoir invoqué « main() », nous déclarons quatre nouvelles variables avec les noms « g_value », « s_value », « newValue1 » et « newValue2 ».

Après cela, nous imprimons un message pour saisir les chiffres, puis plaçons « cin » qui obtient deux valeurs de l'utilisateur. Les valeurs saisies par l'utilisateur sont enregistrées respectivement dans les variables « newValue1 » et « newValue2 ». Après cela, nous appelons la fonction « compare() » que nous avons créée précédemment et lui passons quatre paramètres. Ensuite, nous affichons le résultat après avoir exécuté la fonction « comparer » et il montre le plus grand nombre et le plus petit nombre parmi les nombres saisis par l'utilisateur.

Code 2 :

#include
en utilisant espace de noms norme ;
vide comparer ( int valeur_1, int valeur_2, int * g_Adresse, int * s_Adresse )
{
si ( valeur_1 > valeur_2 ) {
* g_Adresse = valeur_1 ;
* s_Adresse = valeur_2 ;
}
autre {
* g_Adresse = valeur_2 ;
* s_Adresse = valeur_1 ;
}
}
int principal ( )
{
int g_value, s_value, nouvelleValue_1, nouvelleValue_2 ;
cout << « Veuillez saisir deux numéros : » <> nouvelleValeur_1 >> nouvelleValeur_2 ;
comparer ( nouvelleValeur_1, nouvelleValeur_2, & g_value, & valeur_s ) ;
cout << ' \n Le plus grand nombre est ' << g_valeur << ' et le plus petit nombre est '
<< valeur_s ;
retour 0 ;
}

Sortir :
L'utilisateur saisit ici « 86 » et « 23 ». Après avoir appuyé sur « Entrée », il affiche le résultat. De cette façon, nous obtenons plusieurs valeurs.

Exemple 3 : Utilisation du tableau

Nous créons ici la fonction « ComputeComparison() » dans laquelle nous insérons deux variables, « num_1 » et « num_2 », comme type « int » ainsi qu'un tableau nommé « my_arr[] ». Après cela, nous avons la condition « if » qui vérifie si « num_1 » est supérieur à « num_2 » ou non. Si c'est vrai, le « num_1 » est attribué à « my_arr[0] » et « num_2 » est attribué à « my_arr[1] ». Mais si la condition n'est pas vraie, les instructions après « else » sont exécutées dans lesquelles nous attribuons « num_2 » à « my_arr[0] » et « num_1 » à « my_arr[1] ».

Après cela, nous appelons ici le « main() », puis déclarons deux autres variables int : « newNum_1 » et « newNum_2 ». Après cela, un tableau de taille « 2 » est déclaré. Après cela, nous obtenons deux nombres de l'utilisateur à l'aide de « cin », puis appelons la fonction « ComputeComparison() » et affichons le résultat suivant. Ainsi, il renvoie ici plusieurs valeurs.

Code 3 :

#include
en utilisant espace de noms norme ;
vide CalculComparaison ( int num_1, int num_2, int mon_arr [ ] )
{

si ( num_1 > num_2 ) {
mon_arr [ 0 ] = num_1 ;
mon_arr [ 1 ] = num_2 ;
}
autre {
mon_arr [ 0 ] = num_2 ;
mon_arr [ 1 ] = num_1 ;
}
}

int principal ( )
{
int nouveauNum_1, nouveauNum_2 ;
int mon_arr [ 2 ] ;

cout << 'Veuillez saisir deux chiffres à des fins de comparaison' <> nouveauNum_1 >> nouveauNum_2 ;
CalculComparaison ( nouveauNum_1, nouveauNum_2, mon_arr ) ;
cout << ' \n Le plus grand nombre est ' << mon_arr [ 0 ] << ' et le '
'un plus petit nombre est' << mon_arr [ 1 ] ;

retour 0 ;
}

Sortir :
Nous tapons ici « 54 » et « 98 », puis appuyons sur « Entrée » pour afficher le résultat. Il montre les nombres les plus grands et les plus petits parmi les nombres que nous avons entrés.

Exemple 4 : Utiliser les tuples

Deux fichiers d'en-tête sont inclus ici : « tuple » et « iostream ». Ensuite, l'espace de noms « std » est placé ici. Ensuite, nous utilisons le mot-clé « tuple » et insérons deux types de données qui sont « int ». Après cela, nous créons une fonction avec le nom «findingValues()» et passons «intValue_1» et «intValue2» comme paramètres.

Ensuite, le « if » est placé là où nous tapons la condition « intValue_1 < intValue_2 ». En dessous, nous utilisons le mot-clé « return » et plaçons la fonction « make_tuple() » dans laquelle les deux variables sont ajoutées en tant que paramètre « intValue_1, intValue2_ ». Ensuite, nous avons la partie « else » dans laquelle nous plaçons à nouveau « return » avec la fonction « make_tuple() ». Mais ici, nous plaçons d'abord le « intValue_2 » puis le « intValue1 ». Maintenant, nous appelons le « main() » et initialisons le « new_value1 » avec « 5 » et « new_value2 » avec « 28 ».

Dans ce qui suit, nous déclarons deux autres variables de type « int » avec les noms « plus grand » et « plus petit ». Ensuite, nous plaçons la fonction « tie() » et passons les variables « plus petites, plus grandes » comme paramètre et appelons également la fonction «findingValues()» ici. Après cela, nous imprimons les deux valeurs : le plus grand et le plus petit nombre.

Code 4 :

#include
#include
en utilisant espace de noms norme ;
tuple findingValues ( int valeurint_1, int valeurint_2 )
{
si ( valeurint_1 < valeurint_2 ) {
retour make_tuple ( valeurint_1 , valeurint_2 ) ;
}
autre {
retour make_tuple ( valeurint_2 , valeurentier_1 ) ;
}
}
int principal ( )
{
int nouvelle_valeur1 = 5 , nouvelle_valeur2 = 28 ;
int plus grand, plus petit ;
cravate ( plus petit, plus grand ) = recherche de valeurs ( nouvelle_valeur1, nouvelle_valeur2 ) ;
imprimer ( 'Le plus grand nombre est %d et le '
'le plus petit nombre est %d' ,
plus grand, plus petit ) ;
retour 0 ;
}

Sortir :

Les nombres que nous ajoutons à notre code affichent simultanément les valeurs supérieures et inférieures. De cette façon, nous pouvons facilement renvoyer plusieurs valeurs dans notre code.

Conclusion

Ce guide concerne le « retour de valeurs multiples » dans les codes C++. Nous avons exploré en profondeur cette notion dans ce guide et discuté de trois techniques qui aident à renvoyer plusieurs valeurs dans la programmation C++. Nous avons expliqué que plusieurs valeurs sont renvoyées en utilisant les techniques des tuples, des paires, des pointeurs et des tableaux. Toutes ces techniques sont décrites en détail ici.