Tuple C++

Tuple C



Travailler avec n'importe quel langage de programmation nécessite d'utiliser des tuples, des listes, des tableaux, etc. Les tableaux, les listes et les tuples offrent les mêmes services avec de légères différences. Un tuple est un objet qui contient une liste d'ordre d'éléments. C'est comme un tableau et une liste, cependant, ils sont tous les deux modifiables, mais le tuple est immuable. Un objet immuable ne peut subir aucune modification lors de son exécution. La liste et le tableau peuvent facilement être modifiés, découpés ou indexés car ils sont modifiables. Mais un tuple ne peut pas être modifié, tranché ou changé puisqu'il s'agit d'un objet immuable. De plus, la liste et le tableau ne peuvent stocker qu'un seul type de données, mais un tuple peut contenir des données de plusieurs types. Dans ce guide, nous discuterons de la fonction principale d'un tuple et de la manière dont il peut être utilisé dans un programme c++.

Qu'est-ce qu'un tuple dans un langage de programmation C++ ?

Un tuple dans un langage de programmation c++ est un objet qui contient une liste ordonnée d'éléments. Il s'agit d'un type de données immuable, ce qui signifie que les valeurs du tuple ne peuvent être modifiées à aucun moment de l'exécution. La valeur d'un tuple est donnée entre parenthèses rondes () séparées par une virgule et est accessible par la référence de l'index. De nombreuses fonctions peuvent être exécutées sur un tuple, c'est-à-dire get(), swap(), tuple_size(), etc. Dans les sections suivantes, nous expliquerons le fonctionnement des 4 fonctions à l'aide d'exemples.

Exemple 1:
Dans cet exemple, nous allons créer un tuple en utilisant la fonction make_tuple(). Le make_tuple() est utilisé dans un programme c++ pour attribuer une valeur à un tuple. Les valeurs qui doivent être affectées au tuple doivent être dans le même ordre que celui dans lequel elles ont été déclarées dans le tuple. Voyons le code joint ci-dessous pour comprendre comment la fonction make_tuple() fonctionne dans un programme c++.







Les bibliothèques 'include ' et 'using namespace std' sont incluses dans le programme pour utiliser les fonctions d'entrée et de sortie standard comme cin et cout. Le 'include ' permettra l'utilisation d'un tuple dans le programme. Le code complet est fourni dans la fonction main(). Un tuple ‘t’ est déclaré avec cinq éléments, . Les valeurs du tuple doivent suivre le même ordre. Comme vous pouvez le constater, ('a', 75, 5, 'z', 5.5) dans la fonction make_tuple() sont dans le même ordre que les valeurs déclarées pour le tuple. Après avoir exécuté ce code, vous n'obtiendrez rien en retour indiquant que l'exécution est réussie.



#include
#include
utilisant espace de noms std ;
entier principale ( )
{
tuple < carboniser , entier , entier , carboniser , flotteur > t ;
t = make_tuple ( 'un' , 75 , 5 , 'Avec' , 5.5 ) ;
revenir 0 ;
}



Vérifiez la sortie résultante donnée dans la capture d'écran ci-dessous :





Notez qu'il n'y a rien retourné par le programme. Imprimons les valeurs du tuple.



Exemple 2 :
Dans cet exemple, la fonction get() est utilisée sur le tuple pour afficher ses valeurs. Les valeurs des tuples ne peuvent être imprimées qu'avec la fonction get() dans le langage de programmation c++. Voir le code ci-dessous.

Notez que nous avons utilisé le même code et les mêmes exemples de données que dans l'exemple précédent. En utilisant la fonction make_tuple(), les valeurs sont correctement affectées au tuple. La fonction get() est utilisée pour accéder aux valeurs du tuple en référençant le numéro d'index à partir de 0. Chaque numéro d'index est donné à la fonction get() et toutes les valeurs du tuple sont imprimées avec l'instruction cout.

#include
#include
utilisant espace de noms std ;
entier principale ( )
{
tuple < carboniser , entier , entier , carboniser , flotteur > t ;
t = make_tuple ( 'un' , 75 , 5 , 'Avec' , 5.5 ) ;
entier je ;
écoute << 'Les valeurs de tuple sont : ' ;
écoute << obtenir < 0 > ( t ) << ' ' << obtenir < 1 > ( t ) << ' ' << obtenir < deux > ( t )
<< ' ' << obtenir < 3 > ( t ) << ' ' << obtenir < 4 > ( t ) << fin ;
revenir 0 ;
}

Découvrez la sortie de ce code dans la capture d'écran ci-dessous :

La fonction get() imprime les valeurs dans le même ordre qu'elles sont assignées au tuple.

Exemple 3 :
Dans cet exemple, nous allons démontrer le fonctionnement de la fonction tuple_size(). À l'aide d'un exemple, nous expliquerons comment obtenir la taille d'un tuple en utilisant la fonction tuple_size. Consultez le code ci-dessous.

Le reste des lignes de code est identique à celui utilisé dans les exemples précédents. La fonction tuple_size ici obtiendra la taille du tuple. Le 'decltype' représente le type déclaré utilisé pour examiner le type d'une expression donnée.

#include
#include
utilisant espace de noms std ;
entier principale ( )
{
tuple < carboniser , entier , entier , carboniser , flotteur > t ;
t = make_tuple ( 'un' , 75 , 5 , 'Avec' , 5.5 ) ;
entier je ;
écoute << 'La taille du tuple est = ' ;
écoute << tuple_size < decltype ( t ) > :: évaluer << fin ;
revenir 0 ;
}

Lorsque vous exécutez ce code, la sortie suivante sera générée :

Nous avons attribué 5 valeurs au tuple et la fonction tuple_size() a également renvoyé la taille du tuple 5.

Exemple 4 :
Nous pouvons concaténer les tuples en utilisant la fonction tuple_cat() et créer un nouveau tuple à partir d'eux. Ici, nous allons démontrer l'utilisation de la fonction tuple_cat() pour concaténer deux tuples.

Dans le code ci-dessous, nous avons déclaré deux tuples t1 et t2 et attribué des valeurs 3/3 à chaque tuple. Ensuite, nous avons utilisé la fonction tuple_cat() pour concaténer les deux tuples et en créer un nouveau. Après cela, nous avons simplement imprimé les valeurs de tous les tuples à l'aide de la fonction get(). La fonction tuple_cat() prend les tuples qui doivent être concaténés, combine les valeurs attribuées à chaque tuple et crée un nouveau tuple à partir de celui-ci.

Notez que les tuples t1 et t2 ont des valeurs 3/3 et nous avons imprimé chaque valeur à l'aide de la fonction get() en faisant référence de l'index 0 à l'index 2. Cependant, lorsqu'ils sont concaténés, les valeurs totales seront 6. Nous avons donc besoin pour imprimer l'index de 0 à 5 afin que toutes les valeurs soient imprimées. Vérifiez la sortie ci-dessous et notez que 3 valeurs sont imprimées sur le tuple t1 ; 3 valeurs sont imprimées sur le tuple 2. Cependant, 6 valeurs sont imprimées sur le tuple 3 car les valeurs concaténées dans le nouveau tuple sont 6.

#include
#include
utilisant espace de noms std ;
entier principale ( )
{
tuple < carboniser , entier , flotteur > t1 ( 'un' , 75 , 6.7 ) ;
tuple < entier , carboniser , flotteur > t2 ( dix , 't' , 77,9 ) ;
auto t3 = tuple_cat ( t1, t2 ) ;
cout << 'Le premier tuple contient =  ' ;
cout << obtenir < 0 > ( t1 ) << ' ' << obtenir < 1 > ( t1 ) << ' ' << obtenir < deux > ( t1 ) << fin << fin ;
cout << 'Le deuxième tuple contient =  ' ;
cout << obtenir < 0 > ( t2 ) << ' ' << obtenir < 1 > ( t2 ) << ' ' << obtenir < deux > ( t2 ) << fin << fin ;
cout << 'Le nouveau tuple est = ' ;
cout << obtenir < 0 > ( t3 ) << ' ' << obtenir < 1 > ( t3 ) << ' ' << obtenir < deux > ( t3 ) << ' '
<< obtenir < 3 > ( t3 ) << ' ' << obtenir < 4 > ( t3 ) << ' ' << obtenir < 5 > ( t3 ) << fin ;
revenir 0 ;
}

Voici la sortie :

Conclusion

Cet article est un aperçu des tuples dans le langage de programmation c++. Le tuple en c++ est un objet immuable qui porte les valeurs de différents types de données en même temps. Les tuples ne peuvent être changés ou modifiés à aucun moment de l'exécution car ils sont immuables. Plusieurs fonctions peuvent être exécutées sur des tuples pour obtenir un certain résultat, 4 d'entre elles sont démontrées dans cet article avec des exemples d'exemples.