సింటాక్స్:
టెంప్లేట్ < తరగతి T > శూన్యం మార్పిడి ( టి & వేరియబుల్_1 , టి & వేరియబుల్_2 ) ;మొదటి వేరియబుల్ మరియు రెండవ వేరియబుల్ యొక్క విలువ రెండూ, ఈ రెండూ స్టోర్ విలువలను మార్చుకోవాలి. ఫంక్షన్ కేవలం వేరియబుల్స్ యొక్క విలువలను మారుస్తుంది; దీనికి అవుట్‌పుట్ లేదు.'
C++లో swap() ఫంక్షన్ యొక్క పని
స్వాప్ ఫంక్షన్ క్రింది మూడు లైన్లను ఉపయోగించి C++లో అమలు చేయబడుతుంది.
మూస శూన్యం మార్పిడి ( టి & i , టి & j ) {
T ఉష్ణోగ్రత = std :: కదలిక ( i ) ;
i = std :: కదలిక ( j ) ;
j = std :: కదలిక ( ఉష్ణోగ్రత ) ;
}
ప్రకటన “T temp = std::move(i)”; మూలకం 'i' యొక్క కాపీని చేస్తుంది మరియు దానిని నకిలీ చేస్తుంది. ఇక్కడ, “i = std::move(j)”; 'i' యొక్క అసలైన అంశాలను విస్మరిస్తుంది మరియు అసలు 'j' స్థానంలో 'j' యొక్క 'i' కాపీని నిల్వ చేస్తుంది. ఫార్ములా “j = std:: move(temp)”; టెంప్ క్లోన్‌తో 'i'ని సేవ్ చేయండి మరియు టెంప్ యొక్క ఒకేలాంటి కంటెంట్‌లను తీసివేయండి. అలాగే, స్వాప్() ఫంక్షన్ ఎగ్జిక్యూషన్ పూర్తయిన తర్వాత టెంప్ వేరియబుల్‌ను తొలగించండి.
ఉదాహరణ 1: std:: Move మెథడ్‌ని స్వాప్‌కి ఉపయోగించే ప్రోగ్రామ్
క్రింద ప్రదర్శించినట్లుగా, మేము C++11 ఫీచర్ std ::moveని ఉపయోగించి రెండు వస్తువులను మార్చుకోవచ్చు.
#
#
టెంప్లేట్
శూన్యం మార్పిడి ( టి & a , టి & బి )
{
T ఉష్ణోగ్రత = std :: కదలిక ( a ) ;
a = std :: కదలిక ( బి ) ;
బి = std :: కదలిక ( ఉష్ణోగ్రత ) ;
}
int ప్రధాన ( )
{
std :: వెక్టర్ జాబితా = { 10 , 12 , 13 , పదిహేను , 16 , 17 } ;
int i = 3 , j = 5 ;
మార్పిడి ( జాబితా [ i ] , జాబితా [ j ] ) ;
కోసం ( int i : జాబితా ) {
std :: కోట్ << i << '' ;
}
తిరిగి 0 ; }
మేము 'T' వస్తువును కలిగి ఉన్న టెంప్లేట్ ప్రకటనను కలిగి ఉన్నాము. ఆ తరువాత, మేము ఫంక్షన్‌ను “స్వాప్” గా ఏర్పాటు చేసాము. ఫంక్షన్ “T” రకం యొక్క &a మరియు &b అనే రెండు పారామితులను తీసుకుంటుంది. T&a, T&b అనే వాదనల ఫలితంగా ఆమోదించబడిన వేరియబుల్ యొక్క చిరునామాను సూచించడం లేదా నిల్వ చేయడం మరియు తిరిగి ఇవ్వకుండా నేరుగా వాటికి వర్తింపజేయడం, swap(T& a, T&b) ఫంక్షన్‌ను సూచన ద్వారా కాల్ అంటారు.
శూన్యమైన స్వాప్ లోపల, మేము std ::move పద్ధతిని ఉపయోగించి మార్పిడి యొక్క అల్గారిథమ్‌ని వర్తింపజేసాము. అప్పుడు, మేము ప్రోగ్రామ్ మెయిన్‌లను నిర్మించాము. ఇక్కడ, మేము వేరియబుల్ “జాబితా”ని ప్రకటించాము మరియు సంఖ్యా విలువల జాబితాతో దాన్ని ప్రారంభించాము. మేము మార్పిడి కోసం 'i' మరియు 'j' కోసం విలువలను సెట్ చేసాము. రెండవ సూచిక వద్ద ఉన్న సంఖ్యా విలువ ఐదవ సూచిక వద్ద సంఖ్యా విలువతో భర్తీ చేయబడింది. అప్పుడు, మేము స్వాప్ ఫంక్షన్‌ని పిలిచాము మరియు మార్పిడి కోసం దానికి “i” మరియు “j” సూచికలను పంపాము. మార్చబడిన జాబితాను ముద్రించడానికి for loop ఉపయోగించబడుతుంది.
అవుట్‌పుట్ సవరించిన జాబితాను ప్రదర్శిస్తుంది. మీరు రూపొందించిన కొత్త జాబితా నిర్దిష్ట సూచికల ప్రకారం విలువను మార్చడాన్ని గమనించవచ్చు.
ఉదాహరణ 2: std:: స్వాప్ పద్ధతిని ఉపయోగించి ప్రోగ్రామ్
యుటిలిటీ హెడర్‌లో (C++11లో) కనిపించే std ::swap మెకానిజంను ఉపయోగించడం అనేది సాధారణ పరిష్కారం. రెండు వస్తువుల విలువలు పని చేయడానికి మారతాయి.
##
#include
int ప్రధాన ( )
{
std :: వెక్టరర్ = { 3 , 6 , 9 , పదిహేను , 13 } ;
int i = 3 , j = 4 ;
std :: మార్పిడి ( అరె [ i ] , అరె [ j ] ) ;
కోసం ( int i : అరె ) {
std :: కోట్ << i << '' ;
}
తిరిగి 0 ;
}
హెడర్ ఫైల్
std:: swap పద్ధతిని ఉపయోగించి స్వాపింగ్ ఆపరేషన్ తర్వాత పొందిన జాబితా క్రింది విధంగా ప్రదర్శించబడుతుంది:
ఉదాహరణ 3: std::iter_swap పద్ధతిని ఉపయోగించి మార్చుకునే ప్రోగ్రామ్
అల్గోరిథం కోసం హెడర్‌లో జాబితా చేయబడిన std::iter_swap అల్గోరిథం యొక్క ఉపయోగం అదనపు ఎంపిక. అందించిన పునరావృత్తులు సూచించే వస్తువుల విలువలను మార్చడం ద్వారా ఇది పనిచేసే విధానం.
##
#
#
int ప్రధాన ( )
{
std :: వెక్టార్వెక్ = { 64 , 61 , 62 , 63 , 60 } ;
int i = 0 , j = 4 ;
దానంతట అదే itr1 = std :: తరువాత ( ఒక వస్తువు. ప్రారంభం ( ) , i ) ;
దానంతట అదే itr2 = std :: తరువాత ( ఒక వస్తువు. ప్రారంభం ( ) , j ) ;
std :: iter_swap ( itr1 , itr2 ) ;
కోసం ( int i : ఒక వస్తువు ) {
std :: కోట్ << i << '' ;
}
తిరిగి 0 ;
}
ప్రోగ్రామ్ యొక్క ప్రధాన పద్ధతికి, మేము వెక్టర్ వేరియబుల్ “vec”ని ప్రకటించాము మరియు దానికి సంఖ్యల వెక్టర్ జాబితాను కేటాయించాము. అప్పుడు, మేము ఇండెక్స్ స్థానాన్ని వేరియబుల్ 'i' మరియు 'j'కి పేర్కొన్నాము. std::iter_swap పద్ధతిలో iter1 మరియు iter2లను ఆర్గ్యుమెంట్‌గా తీసుకుంటారు. iter1 మరియు iter2 స్వయంచాలక కీవర్డ్‌తో ప్రకటించబడ్డాయి మరియు పునరావృత ఆపరేషన్‌ను కలిగి ఉంటాయి. ఫర్ లూప్ పద్ధతి అమలు చేయబడినప్పుడు వెక్టర్ శ్రేణి యొక్క స్వాప్ చేయబడిన విలువలను ముద్రిస్తుంది.
std::iter_swap పద్ధతి పేర్కొన్న వెక్టార్‌ల విలువలను విజయవంతంగా మార్చుకుంది.
ఉదాహరణ 4: మార్పిడికి తాత్కాలిక వేరియబుల్స్ లేకుండా ఉపయోగించే ప్రోగ్రామ్
ఈ ఉదాహరణ తాత్కాలిక వేరియబుల్స్ ఉపయోగించకుండా C++ కోడ్‌లో సంఖ్యలను మార్చుకునే కొత్త మార్గాన్ని చూపుతుంది.
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
int x1 = రెండు , x2 = 12 ;
కోట్ << 'మార్పిడి చేయడానికి ముందు.' << endl ;
కోట్ << 'x1 =' << x1 << ', x2 = ' << x2 << endl ;
x1 = x1 + x2 ;
x2 = x1 - x2 ;
x1 = x1 * x2 ;
కోట్ << ' \n మార్పిడి తర్వాత.' << endl ;
కోట్ << 'x1 =' << x1 << ', x2 = ' << x2 << endl ;
తిరిగి 0 ; }
ఈ ప్రోగ్రామ్ యొక్క కార్యాచరణను పరిశీలిద్దాం. ఇక్కడ, మేము x1 మరియు x2లను ప్రకటించాము, ఇవి మొదట్లో వరుసగా సంఖ్యతో సెట్ చేయబడ్డాయి. అప్పుడు, ఫార్ములా x1 = x1+ x2ని ఉపయోగించి, మేము x1 మరియు x2ని జోడించి, ఫలితాన్ని x1లో ఉంచుతాము. ఇది x1 అనేది 2 ప్లస్ 12కి సమానం అని సూచిస్తుంది. కాబట్టి, ఇప్పుడు 14కి సమానం. అప్పుడు, మేము x2 = x1 – x2 ఫార్ములాని వర్తింపజేస్తాము. ఇది x2 = 14 – 12 అని సూచిస్తుంది. కాబట్టి, x2 ఇప్పుడు 2కి సమానం. మరోసారి, మేము x1 = x1 – x2 సూత్రాన్ని వర్తింపజేస్తాము. ఇది x1 = 14 – 2 అని సూచిస్తుంది. కాబట్టి, చివరిలో x1 = 12. ఫలితంగా, సంఖ్యలు మారాయి.
ముందు మరియు తర్వాత మార్చుకున్న సంఖ్య క్రింది ప్రాంప్ట్ స్క్రీన్‌లో ప్రదర్శించబడుతుంది.
ముగింపు
ఇక్కడ, మేము C++లో స్వాప్() యొక్క పూర్తి వివరణ, దాని వినియోగం మరియు అది ఎలా పనిచేస్తుందో చూపించే కొన్ని ఉదాహరణలను పరిశీలిస్తాము. std:: swap() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా, రెండు వేరియబుల్స్ విలువలను మార్చవచ్చు. C++ STL std::swap() అనే అంతర్నిర్మిత ఫంక్షన్‌ని కలిగి ఉంటుంది. swap(T& వేరియబుల్ 1, T& వేరియబుల్ 2) ఫంక్షన్ కాల్స్ రిఫరెన్స్, మరియు C++ ఓవర్‌లోడ్ స్వాప్() డేటా వేరియబుల్స్ రకాన్ని బట్టి కూడా ఈ ట్యుటోరియల్‌లో వివరించబడ్డాయి.