Échange standard C++

Echange Standard C



'L'échange est l'acte d'échanger deux ou plusieurs choses. Les données entre deux variables dans la programmation peuvent être commutées. L'échange de choses entre deux personnes est possible dans la vraie vie. Les valeurs de deux objets peuvent être échangées à l'aide de la fonction de bibliothèque standard swap() en C++. Il a été placé sous l'en-tête « utilitaire » dans C11. La fonction swap() en C++ a une complexité de N pour les tableaux car chaque élément doit être permuté individuellement, tandis que la difficulté de la fonction pour les constantes est constante. La fonction swap() génère un avertissement ou une erreur si l'un des éléments variables échoue. Regardez la signature de la fonction pour std :: swap () ci-dessous :

Syntaxe:

modèle < classe T > annuler échanger ( J & variable_1 , J & variable_2 ) ;

La valeur de la première variable et de la seconde variable, qui stockent toutes deux des valeurs, doivent être échangées. La fonction change simplement les valeurs des variables ; il n'a pas de sortie.







Fonctionnement de la fonction swap() en C++

La fonction swap est implémentée en C++ à l'aide des trois lignes suivantes.



Modèle annuler échanger ( J & je , J & j ) {
T temp = std :: mouvement ( je ) ;
je = std :: mouvement ( j ) ;
j = std :: mouvement ( temp ) ;
}

L'instruction « T temp = std :: move(i) » ; fait une copie de l'élément 'i' et le duplique. Ici, 'i = std::move(j)' ; supprime les éléments originaux de 'i' et stocke la copie 'i' de 'j' à la place de l'original 'j'. La formule 'j = std :: move(temp)' ; enregistrez 'i' avec un clone de temp et supprimez le contenu identique de temp. Supprimez également la variable temporaire une fois l'exécution de la fonction swap() terminée.



Exemple 1 : programme utilisant la méthode std :: move pour échanger

Comme démontré ci-dessous, nous pouvons échanger deux objets à l'aide de la fonctionnalité C++11 std::move.





#include

#include



modèle
annuler échanger ( J & un , J & b )
{
T temp = std :: mouvement ( un ) ;
un = std :: mouvement ( b ) ;
b = std :: mouvement ( temp ) ;
}
entier principale ( )
{
std :: vecteur liste = { dix , 12 , 13 , quinze , 16 , 17 } ;
entier je = 3 , j = 5 ;
échanger ( liste [ je ] , liste [ j ] ) ;
pour ( entier je : liste ) {
std :: cout << je << ' ' ;
}
revenir 0 ; }

Nous avons un modèle de déclaration qui a un objet 'T'. Après cela, nous avons établi la fonction comme 'swap'. La fonction prend les deux paramètres &a et &b, de type « T ». En raison des arguments T& a, T& b référençant ou stockant l'adresse de la variable passée et s'y appliquant directement sans retour, la fonction swap(T& a, T& b) est appelée un appel par référence.



A l'intérieur du void swap, nous avons appliqué l'algorithme de swapping en utilisant la méthode std::move. Ensuite, nous avons construit le programme principal. Ici, nous avons déclaré la variable « liste » et l'avons initialisée avec la liste des valeurs numériques. Nous avons défini les valeurs pour les 'i' et 'j' pour l'échange. La valeur numérique située au deuxième index a été remplacée par la valeur numérique au cinquième index. Ensuite, nous avons appelé la fonction d'échange et lui avons transmis les index 'i' et 'j' pour l'échange. La boucle for est utilisée pour imprimer la liste permutée.

La sortie affiche la liste modifiée. Vous pouvez observer que la nouvelle liste générée a échangé la valeur en fonction des index spécifiés.

Exemple 2 : programme utilisant la méthode std :: swap pour échanger

L'utilisation du mécanisme std :: swap trouvé dans l'en-tête de l'utilitaire (en C++ 11) est la solution habituelle. Les valeurs de deux objets sont commutées pour le faire fonctionner.

#include

#include

#include



entier principale ( )
{
std :: vecteurarr = { 3 , 6 , 9 , quinze , 13 } ;
entier je = 3 , j = 4 ;

std :: échanger ( arr [ je ] , arr [ j ] ) ;

pour ( entier je : arr ) {
std :: cout << je << ' ' ;
}

revenir 0 ;
}

En important le fichier d'en-tête , nous pouvons accéder à la fonction swap dans notre programme. Ici, nous avons inclus le fichier d'en-tête avec deux bibliothèques plus importantes. Ensuite, nous avons établi la méthode int main. Dans le programme principal, nous avons déclaré le vecteur en créant la variable 'arr.' La variable « arr » est initialisée avec les cinq éléments de l'entier. Les positions d'index sont attribuées aux « i » et « j » pour l'échange. Les variables 'i' et 'j' sont ensuite passées à la méthode std :: swap pour l'échange de la valeur de l'index spécifié. Avec la boucle for, nous avons imprimé les tableaux échangés.

La liste obtenue après l'opération d'échange à l'aide de la méthode std::swap s'affiche comme suit :

Exemple 3 : programme utilisant la méthode std::iter_swap pour permuter

L'utilisation de l'algorithme std::iter_swap, qui est répertorié dans l'en-tête de l'algorithme, est une option supplémentaire. Il fonctionne en changeant les valeurs des objets vers lesquels pointent les itérateurs fournis.

#include

#include

#include

#include



entier principale ( )
{
std :: vecteurvec = { 64 , 61 , 62 , 63 , 60 } ;
entier je = 0 , j = 4 ;
auto itr1 = std :: Suivant ( une chose. commencer ( ) , je ) ;
auto itr2 = std :: Suivant ( une chose. commencer ( ) , j ) ;

std :: iter_swap ( itr1 , itr2 ) ;
pour ( entier je : une chose ) {
std :: cout << je << ' ' ;
}
revenir 0 ;
}

Pour la méthode principale du programme, nous avons déclaré une variable vectorielle 'vec' et lui avons assigné une liste vectorielle de nombres. Ensuite, nous avons spécifié la position d'index aux variables 'i' et 'j'. La méthode std::iter_swap est appelée et prend les iter1 et iter2 comme argument. Les iter1 et iter2 sont déclarés avec le mot clé auto et ont l'opération d'itération. La méthode de la boucle for imprime les valeurs échangées du tableau vectoriel lors de l'exécution.

La méthode std::iter_swap a permuté avec succès les valeurs des vecteurs spécifiés.

Exemple 4 : Programme d'utilisation sans variables temporaires pour échanger

Cet exemple montre une nouvelle façon d'échanger des nombres dans du code C++ sans utiliser de variables temporaires.

#include

en utilisant l'espace de noms std ;

entier principale ( )
{
entier x1 = deux , x2 = 12 ;
cout << 'Avant d'échanger.' << fin ;
cout << 'x1 = ' << x1 << ', x2 = ' << x2 << fin ;

x1 = x1 + x2 ;
x2 = x1 - x2 ;
x1 = x1 * x2 ;

cout << ' \n Après échange.' << fin ;
cout << 'x1 = ' << x1 << ', x2 = ' << x2 << fin ;

revenir 0 ; }

Examinons le fonctionnement de ce programme. Ici, nous avons déclaré x1 et x2, qui sont initialement définis avec le nombre, respectivement. Ensuite, en utilisant la formule x1 = x1+ x2, nous additionnons x1 et x2 et mettons le résultat dans x1. Cela indique que x1 est égal à 2 plus 12. Par conséquent, est maintenant égal à 14. Ensuite, nous appliquons la formule x2 = x1 – x2. Cela indique que x2 = 14 – 12. Par conséquent, x2 est maintenant égal à 2. Une fois de plus, nous appliquons la formule x1 = x1 – x2. Cela indique que x1 = 14 – 2. Par conséquent, x1 = 12 à la fin. En conséquence, les numéros ont été inversés.

Le nombre échangé avant et après s'affiche sur l'écran d'invite suivant.

Conclusion

Ici, nous passons en revue une description complète de swap() en C++, son utilisation et quelques exemples qui montrent comment il fonctionne. En utilisant la fonction std :: swap(), les valeurs de deux variables peuvent être inversées. La STL C++ inclut une fonction intégrée appelée std::swap(). Les appels de fonction swap(T& variable 1, T& variable 2) par référence, et les surcharges C++ swap() en fonction du type de variables de données sont également expliqués dans ce tutoriel.