Fonctions de la paire C ++

Dans ce guide, nous examinerons les conteneurs de paires en C ++ et leurs applications. Dans le langage de programmation C ++, un conteneur de paires fonctionne de manière similaire à un tuple. Cependant, une paire ne peut contenir que deux éléments, tandis qu'un tuple peut contenir de nombreux éléments. Les deux composants pourraient avoir plusieurs types de données ou des types de données similaires comme un tuple. La paire est un conteneur qui est donné par le module et est déclaré dans le langage de programmation C ++ en utilisant le terme «paire». Ainsi, en substance, une paire est utilisée pour combiner deux composants ou entiers dans un. Cela permet le stockage d'éléments hétérogènes ou de plusieurs types de données en tant qu'entité unique.

Seuls deux composants peuvent être stockés à l'intérieur du conteneur de paire. Dont le premier ne pouvait être mentionné que par «premier» et le second ne pouvait être stocké que dans «deuxième». Nous pouvons également utiliser des opérateurs comme = avec des paires. Nous pouvons échanger le contenu d'une paire avec une autre paire en utilisant la fonction swap (). De plus, la fonction Make Pair () a une fonctionnalité qui nous permet de générer des paires de valeur sans spécifier les types de données exactes. Au lieu de cela, nous pouvons simplement écrire les valeurs.

Types d'opérateurs

L'utilisation des opérateurs pour les ensembles est toujours une option.

À une telle paire d'éléments, égal (=) crée un nouvel élément ou un nouvel objet. Cela donne potentiellement au nouveau texte de l'objet de la paire une valeur. Tandis que la deuxième valeur obtient la deuxième valeur. La première valeur obtient la première valeur de PR. Nous pouvons utiliser l'opérateur de comparaison (==) avec une paire C ++. Utilisez simplement le pas égal (!=) Opérateur de la paire: En supposant que la paire1 et la paire2 sont fournies, le!= l'opérateur contraste les premières valeurs des deux paires.

Plus précisément, il contraste la première valeur des deux ensembles, pair1 et pair2. Une combinaison d'opérateurs logiques (> =, =): les opérateurs = et> peuvent également être utilisés avec des paires, comme Pair1 et Pair2. Il évalue simplement la première valeur de la paire et renvoie 0 ou 1. La paire devrait retourner 0 pour les combinaisons (car elle ne teste que la première variable et même si elles sont égales) mais ce n'est pas. La paire vérifie le deuxième élément et renvoie 1 s'il est admissible lors de l'utilisation des opérateurs relationnels> ou simplement pour faire le premier élément équivalent.

Syntaxe de comment déclarer une paire

La paire aurait pu être utilisée comme classe de modèle std :: paire pour démontrer comment ou quand implémenter la paire en tant que tuple en C ++ puisque STL (bibliothèque de modèle standard) utilise l'espace de noms «std». Et la paire est en effet une classe de conteneurs dans STL.

La syntaxe de la paire peut être expliquée largement comme suit:

paire (dt1, dt2) paireName;

Paramètres:

• Les données pour les premier et deuxième éléments sont DT1 pour le composant leader et le DT2, respectivement.
• Les noms de paires sont utilisés pour identifier les premier et deuxième composants d'une paire d'objets.

Nous examinerons un exemple qui définit un conteneur de paires et utilise le fichier d'en-tête.

Exemple 1

Dans ce programme, nous verrions que nous avons inclus le fichier d'en-tête en utilisant des conteneurs de paires et le fichier d'en-tête pour l'impression de messages ou d'entrée ou de sortie. La syntaxe pour utiliser l'espace de noms STD dans les codes susmentionnés est la suivante:

# std :: paire paireName;

Nous pouvons utiliser tout type de données pour la variable définie. Les étapes suivantes sont prises pour définir, accéder ou initialiser les valeurs pour chaque élément à l'intérieur du conteneur de la paire:

• Le premier peut être utilisé pour spécifier ou récupérer le premier élément.
• le second peut récupérer ou spécifier le deuxième élément.

Gardez à l'esprit que même si vous établissez et spécifiant la paire, nous ne sommes pas en mesure de modifier l'ordre ou le type de données des variables.

#inclure
#inclure
Utilisation de Namespace Std;
int main()

STD :: Pair PairName;
nom de paire.premier = 23;
nom de paire.seconde = 16;
std :: cout << "The first value: " << pairname.first << std::endl;
std :: cout << "The second value: " << pairname.second << std::endl;
retour 0;

Nous présenterons le fichier d'en-tête et . Nous utiliserons l'espace de noms standard comme «STD». Ensuite, nous utiliserions la fonction principale (). Ensuite, nous appliquerons la méthode de la paire. À l'intérieur de cette fonction, nous fournirons deux arguments pour cette méthode. Ensuite, nous utilisons l'attribut «pairename». Ensuite, nous déclarerions le «premier» attribut du «pairename» et indiquerions la valeur de cet attribut.

De même, nous allons initialiser l'attribut «deuxième» du «paireName». Après tout cela, nous appliquerions la fonction de sortie standard de «cout». En utilisant cela, nous montrons la première valeur. Ensuite, nous employons à nouveau la commande «cout». En utilisant cette méthode, nous afficherions la deuxième valeur. En fin de compte, nous employons la commande «retour 0».

Exemple 2

Ici, nous n'utilisons toujours pas l'en-tête comme dans le premier exemple.

#inclure
Utilisation de Namespace Std;
int main()

STD :: Pair PairName;
nom de paire.First = "Information";
nom de paire.seconde = 78.45;
std :: cout << "The first item: " << pairname.first << std::endl;
std :: cout << "The second item: " << pairname.second << std::endl;
retour 0;

Nous intégrions le fichier d'en-tête au début du programme. L'espace de noms que nous utiliserons est appelé «std.«À ce stade, la méthode principale () serait appelée. La technique de la paire sera utilisée ensuite. Nous donnerions deux paramètres à cette méthode à partir de cette méthode. 'Float' et 'string' font partie des paramètres. Nous utiliserons l'attribut «pairename» après cela.

Suite à cela, nous déclarerons et spécifierons la valeur du «premier» composant du «paireName."Pour le premier paramètre, nous utiliserons la valeur« Informations.«L'attribut« deuxième »du« pairename »sera initialisé de manière appropriée. À ce stade, la valeur de ce paramètre est fournie. Pour le «deuxième» argument, nous fournisserions la valeur du point flottante. Avec cela, nous utiliserions la sortie standard de la fonction COUT. Ensuite, nous utiliserions à nouveau la commande «cout». Cette méthode nous permettrait d'afficher le deuxième élément. À la fin, nous utiliserons la commande «Retour 0."

Dans ce programme, nous pouvons voir que nous avons défini deux variables, l'une avec le type de données «String» et une autre avec le type de données «Float». Nous utilisons «PairName.Premièrement »pour initialiser la valeur pour peut-être le premier élément lorsque nous l'avons appelé être de type« chaîne ».

Exemple 3

Avec des conteneurs de paires, des opérateurs comme =, == et d'autres peuvent faire quelque chose pour obtenir des résultats. Affichons également comment utiliser la fonction Make Pair (), qui peut être utilisée pour exécuter le programme dans l'exemple ci-dessous même lorsque les données ne sont pas spécifiées.

#inclure
#inclure
Utilisation de Namespace Std;
int main()

pairPair_1 = Make_pair (456, 198);
pairPair_2 = Make_pair (697, 843);
couter<< "Use of opertaors:\n";
couter << (pair_1 <= pair_2) << endl;
couter <= pair_2) << endl;
couter < pair_2) << endl;
couter << (pair_1 < pair_2) << endl;
couter << (pair_1 == pair_2) << endl;
couter << (pair_1 != pair_2) << endl;
couter << "Use of swap function:\n";
couter << "Before swapping:\n" ;
couter << "Values of first pair = " << pair_1.first << " " << pair_1.second << "\n";
couter << "Values of second pair = " << pair_2.first << " " << pair_2.second << "\n";
paire_1.swap (pair_2);
couter << "\nAfter swapping:\n";
couter << "Values of first pair = " << pair_1.first << " " << pair_1.second << "\n " ;
couter << "Values of second pair = " << pair_2.first << " " << pair_2.second << "\n" ;
retour 0;

Ici, nous intégrerons les fichiers d'en-tête et . De plus, nous utiliserions l'espace de noms standard comme «MST». Nous utilisons la fonction de paire. Premièrement, nous fournissons les arguments. Les arguments comprennent deux entiers. Nous spécifions le nom de la première paire en tant que 'paire_1'. Nous avons utilisé la méthode Make_pair () pour créer une paire. Nous donnerons deux valeurs aléatoires pour faire une paire. Pour créer une deuxième paire, nous utiliserions la méthode de la paire. Nous définissons le nom de la deuxième paire en tant que 'paire_2'. Nous créerons une paire de deux valeurs par l'utilisation de la méthode Make_pair ().

Ensuite, la commande «cout» sera utilisée pour afficher le résultat «Utilisation de l'opérateur». Dans l'étape suivante, nous appliquerions la déclaration «cout». Dans cette commande, nous employons différents opérateurs sur les deux paires définies. Tout d'abord, nous appliquerons l'opérateur '=' pour vérifier si les éléments de la première paire seront supérieurs ou égaux aux éléments de la deuxième paire ou non ou non.

Ensuite, nous utiliserions le signe '>' pour évaluer si les valeurs requises de la première paire seront supérieures à la deuxième paire ou non. Ici, nous utiliserons le '<' sign to verify whether the values of pair 1 are less than the values of pair 2 or not. Next, we would utilize the '==' operator. This operator checks whether the pair 1 values would be equal to the pair 2 values or not. In the last, we would use the '!=' operator. This operator evaluates if the value checks whether the value of the first pair would not be equal to the values of the second pair or not.

Nous appliquons ces opérateurs aux valeurs des deux paires. Ensuite, obtenez le résultat sous la forme de 0 et 1. Le résultat «0» représente le «faux» et le «1» représente le «vrai». De plus, nous utiliserions la commande «cout» pour afficher la ligne «Utilisation des fonctions de swap». Tout d'abord, nous montrerons les valeurs de la première et deuxième paire avant d'échanger à l'aide de l'instruction «cout». Nous utiliserions la méthode swap () pour échanger les valeurs de la première paire aux valeurs de la deuxième paire. L'instruction «cout» imprime la ligne «après l'échange».

En plus de cela, nous utilisons à nouveau la commande «cout» pour afficher les valeurs après échange. La commande «return 0» s'appliquerait à la fin du code.

La méthode Make Pair () est démontrée dans l'exemple susmentionné, avec lequel nous pouvons voir que la paire1 est démarrée avec un type «int» et aucun datatype n'est spécifié pour les variables. Ensuite, nous avons examiné les opérateurs qui peuvent être utilisés avec la fonction de paire. Une chose à retenir pour que les opérateurs de comparaison fonctionnent correctement est que deux variables dans une paire doivent être le même type de données. La fonction d'échange a ensuite été démontrée, montrant qu'il était utilisé avec des paires pour échanger non seulement les variables en eux, mais aussi les paires que ce programme avait déclarées.

Exemple 4

La fonction Tie () effectue des opérations très similaires à celles des tuples. Pour extraire les valeurs de tuple (ou paire dans ce cas) dans les variables indépendantes, il produit un tuple de pointeurs précieux vers ses paramètres. Ici, la cravate est disponible en deux versions avec ou sans «ignorer», comme en tuples. Le mot-clé «ignorer» empêche un certain élément de tuple d'être décodé ou déballé. Les paires n'ont que deux paramètres mais les tuples peuvent avoir de nombreux arguments. Par conséquent, le décodage ou le déballage doit être traité explicitement principalement dans le cas des paires.

#inclure
Utilisation de Namespace Std;
int main()

paire paire_1 = 13, 62;
int i, j;
Tie (i, j) = paire_1;
couter << i << " " << j << "\n";
paire paire_2 = 73, 54;
Tie (i, ignore) = paire_2;
couter << i << " " << j << "\n";
paire pair_3 = 23, 34, 'i';
int m, n;
Char O;
m = paire_3.d'abord;
Tie (n, o) = paire_3.deuxième;
couter << m << " " << n << " " << o << "\n";

Premièrement, la bibliothèque serait incluse. Nous utiliserons l'espace de noms standard comme «STD». La fonction principale () serait invoquée. La méthode de la paire sera utilisée. Tout d'abord, nous indiquerons les valeurs de la première paire. Ensuite, nous déclarons deux variables nommées «I» et «J». Nous utiliserons la méthode Tie (). Nous passons deux attributs à cette fonction. L'instruction «cout» sera utilisée pour montrer les valeurs des deux variables.

Ensuite, nous utilisons à nouveau la fonction de paire. Nous spécifions les valeurs de la deuxième paire. La fonction tie () sera utilisée. Nous avons passé «ignorer» comme le paramètre de cette méthode. La commande «cout» sera utilisée pour afficher l'élément de la variable «J». La méthode «paire» est à nouveau utilisée. Nous passerons Int et Char comme arguments à la fonction de paire. Maintenant, nous initialiserions deux variables appelées «M» et «N». Ces variables ont un entier de type de données. Une nouvelle variable «O» sera déclarée. Il a un type de données de caractère. Encore une fois, nous avons utilisé la méthode Tie (). Cette fonction contient deux arguments qui incluent des variables 'n' et 'o'. La déclaration «cout» sera appliquée pour imprimer la valeur.

Conclusion

Le conteneur de paire fonctionne de manière similaire au «tuple» python car il peut maintenir chaque composant dans une variable de paire avec les mêmes types de données ou distincts. Peu importe les données des pièces des pièces, le conteneur de paire en C ++ est principalement utilisé pour combiner deux éléments en une seule unité. Cet article a également démontré l'utilisation des opérateurs swap () et paires. Il a également fourni un exemple d'opérateur de comparaison. Dans un exemple, nous avons échangé des valeurs de deux paires. Nous utilisons également la méthode Tie (). Quatre exemples uniques sont incorporés dans ce guide pour comprendre les paires en C++.