Szintaxis:
sablon < T osztály > üres csere ( T & változó_1 , T & változó_2 ) ;Az első és a második változó értékét is fel kell cserélni, mindkettő értéket tárol. A függvény csak a változók értékeit váltja; nincs kimenete.'
A swap() függvény működése C++-ban
A swap függvényt C++ nyelven a következő három sor segítségével valósítjuk meg.
Sablon üres csere ( T & én , T & j ) {
T hőm = std :: mozog ( én ) ;
én = std :: mozog ( j ) ;
j = std :: mozog ( hőm ) ;
}
A „T temp = std::move(i)” utasítás; másolatot készít az „i” elemről, és megkettőzi azt. Itt „i = std::move(j)”; eldobja az „i” eredeti elemeit, és eltárolja a „j” „i” másolatát az eredeti „j” helyett. A képlet „j = std:: move(temp)”; mentse el az „i”-t a temp klónjával, és távolítsa el a temp azonos tartalmát. Ezenkívül törölje a temp változót, miután a swap() függvény végrehajtása befejeződött.
1. példa: Programozás az std::move Method használatával a Swap-ba
Amint alább látható, két objektumot felcserélhetünk a C++11 std::move szolgáltatással.
#include
#include
sablon
üres csere ( T & a , T & b )
{
T hőm = std :: mozog ( a ) ;
a = std :: mozog ( b ) ;
b = std :: mozog ( hőm ) ;
}
int fő- ( )
{
std :: vektor lista = { 10 , 12 , 13 , tizenöt , 16 , 17 } ;
int én = 3 , j = 5 ;
csere ( lista [ én ] , lista [ j ] ) ;
számára ( int én : lista ) {
std :: cout << én << '' ;
}
Visszatérés 0 ; }
Van egy sablondeklarációnk, amelynek „T” objektuma van. Ezt követően létrehoztuk a „swap” funkciót. A függvény a két „T” típusú &a és &b paramétert veszi fel. A T& a, T& b argumentumok hatására, amelyek az átadott változó címére hivatkoznak vagy tárolják, és visszatérés nélkül közvetlenül vonatkoznak rájuk, a swap(T& a, T& b) függvényt hivatkozási hívásnak nevezzük.
A void swap-on belül az std::move metódussal történő csere algoritmust alkalmaztuk. Ezután elkészítettük a program főoldalát. Itt deklaráltuk a „list” változót, és inicializáltuk a numerikus értékek listájával. Beállítottuk az „i” és „j” értékeket a cseréhez. A második indexnél található számértéket az ötödik indexnél lévő számértékre cseréltük. Ezután meghívtuk a swap függvényt, és átadtuk neki az „i” és „j” indexeket csere céljából. A for ciklus a felcserélt lista kinyomtatására szolgál.
A kimenet megjelenítette a módosított listát. Megfigyelhető, hogy az új lista a megadott indexeknek megfelelően felcserélte az értéket.
2. példa: Programozás std::swap módszert használva a Swaphoz
A segédprogram fejlécében (C++11-ben) található std::swap mechanizmus használata a szokásos javítás. Két objektum értéke át van kapcsolva, hogy működjön.
#include#include
#include
int fő- ( )
{
std :: vektorarr = { 3 , 6 , 9 , tizenöt , 13 } ;
int én = 3 , j = 4 ;
std :: csere ( arr [ én ] , arr [ j ] ) ;
számára ( int én : arr ) {
std :: cout << én << '' ;
}
Visszatérés 0 ;
}
A
Az std::swap metódussal végzett csereművelet után kapott lista a következőképpen jelenik meg:
3. példa: Programozás std::iter_swap módszerrel a cseréhez
Az std::iter_swap algoritmus használata, amely az algoritmus fejlécében található, egy további lehetőség. Úgy működik, hogy átkapcsolja azon objektumok értékét, amelyekre a megadott iterátorok mutatnak.
#include#include
#include
#include
int fő- ( )
{
std :: vectorvec = { 64 , 61 , 62 , 63 , 60 } ;
int én = 0 , j = 4 ;
auto itr1 = std :: következő ( Egy dolog. kezdődik ( ) , én ) ;
auto itr2 = std :: következő ( Egy dolog. kezdődik ( ) , j ) ;
std :: iter_swap ( itr1 , itr2 ) ;
számára ( int én : Egy dolog ) {
std :: cout << én << '' ;
}
Visszatérés 0 ;
}
A program fő metódusához deklaráltunk egy „vec” vektorváltozót, és hozzárendeltünk egy számok vektorlistáját. Ezután megadtuk az index pozícióját az „i” és a „j” változónak. Az std::iter_swap metódus meghívásra kerül, amely az iter1-et és az iter2-t veszi argumentumként. Az iter1 és iter2 az auto kulcsszóval deklarálva van, és végrehajtják az iterációs műveletet. A for ciklus metódus végrehajtáskor kiírja a vektortömb felcserélt értékeit.
Az std::iter_swap metódus sikeresen felcserélte a megadott vektorok értékeit.
4. példa: Program ideiglenes változók cseréje nélkül
Ez a példa a számok felcserélésének új módját mutatja be C++ kódban ideiglenes változók használata nélkül.
#includenévtér std használatával ;
int fő- ( )
{
int x1 = két , x2 = 12 ;
cout << – Csere előtt. << endl ;
cout << 'x1 = ' << x1 << ', x2 = ' << x2 << endl ;
x1 = x1 + x2 ;
x2 = x1 - x2 ;
x1 = x1 * x2 ;
cout << ' \n Csere után.' << endl ;
cout << 'x1 = ' << x1 << ', x2 = ' << x2 << endl ;
Visszatérés 0 ; }
Vizsgáljuk meg ennek a programnak a működését. Itt deklaráltuk az x1-et és az x2-t, amelyek kezdetben a számmal vannak beállítva. Ezután az x1 = x1+ x2 képlet segítségével összeadjuk x1-et és x2-t, és az eredményt x1-be írjuk. Ez azt jelzi, hogy x1 egyenlő 2 plusz 12-vel. Ezért most egyenlő 14-gyel. Ezután alkalmazzuk az x2 = x1 – x2 képletet. Ez azt jelzi, hogy x2 = 14 – 12. Ezért x2 egyenlő 2-vel. Még egyszer alkalmazzuk az x1 = x1 – x2 képletet. Ez azt jelzi, hogy x1 = 14 – 2. Ezért x1 = 12 a végén. Ennek eredményeként a számok felcserélődtek.
Az előtte és utána felcserélt szám a következő prompt képernyőn jelenik meg.
Következtetés
Itt áttekintjük a swap() teljes leírását C++-ban, annak használatát, és néhány példát, amelyek bemutatják, hogyan működik. Az std:: swap() függvény használatával két változó értéke váltható. A C++ STL tartalmaz egy std::swap() nevű beépített függvényt. A swap(T& változó 1, T& változó 2) függvény hivatkozással hívja meg, és a C++ túlterheli a swap()-t az adatváltozók típusától függően ebben az oktatóanyagban.