C++ Std இடமாற்று

C Std Itamarru

“இரண்டு அல்லது அதற்கு மேற்பட்ட விஷயங்களை பரிமாறிக்கொள்வது என்பது பரிமாற்றம் ஆகும். நிரலாக்கத்தில் இரண்டு மாறிகளுக்கு இடையிலான தரவு மாறலாம். நிஜ வாழ்க்கையில் இரண்டு நபர்களுக்கிடையேயான விஷயங்களின் பரிமாற்றம் சாத்தியமாகும். C++ இல் உள்ள நிலையான நூலக செயல்பாடு swap() ஐப் பயன்படுத்தி ஏதேனும் இரண்டு பொருட்களின் மதிப்புகளை மாற்றலாம். இது C11 இல் 'பயன்பாட்டு' தலைப்பின் கீழ் வைக்கப்பட்டுள்ளது. C++ இல் உள்ள swap() செயல்பாடு வரிசைகளுக்கு N இன் சிக்கலான தன்மையைக் கொண்டுள்ளது, ஏனெனில் ஒவ்வொரு உறுப்பும் தனித்தனியாக மாற்றப்பட வேண்டும், அதே நேரத்தில் மாறிலிகளுக்கான செயல்பாட்டின் சிரமம் நிலையானது. மாறக்கூடிய உறுப்புகளில் ஏதேனும் தோல்வியுற்றால் swap() செயல்பாடு ஒரு எச்சரிக்கை அல்லது பிழையை எறிகிறது. கீழே உள்ள std::swap()க்கான செயல்பாட்டின் கையொப்பத்தைப் பாருங்கள்:

தொடரியல்:

டெம்ப்ளேட் < வகுப்பு டி > வெற்றிடமானது இடமாற்று ( டி & மாறி_1 , டி & மாறி_2 ) ;

முதல் மாறியின் மதிப்பு மற்றும் இரண்டாவது மாறி இரண்டும், இவை இரண்டும் ஸ்டோர் மதிப்புகள் மாற்றப்பட வேண்டும். செயல்பாடு மாறிகளின் மதிப்புகளை மாற்றுகிறது; அதற்கு வெளியீடு இல்லை.'







C++ இல் swap() செயல்பாட்டின் வேலை

பின்வரும் மூன்று வரிகளைப் பயன்படுத்தி ஸ்வாப் செயல்பாடு C++ இல் செயல்படுத்தப்படுகிறது.



டெம்ப்ளேட் வெற்றிடமானது இடமாற்று ( டி & நான் , டி & ஜே ) {
டி வெப்பநிலை = வகுப்பு :: நகர்வு ( நான் ) ;
நான் = வகுப்பு :: நகர்வு ( ஜே ) ;
ஜே = வகுப்பு :: நகர்வு ( வெப்பநிலை ) ;
}

அறிக்கை “T temp = std::move(i)”; உறுப்பு 'i' இன் நகலை உருவாக்கி அதை நகலெடுக்கிறது. இங்கே, “i = std::move(j)”; 'i' இன் அசல் உருப்படிகளை நிராகரித்து, அசல் 'j' க்கு பதிலாக 'j' இன் 'i' நகலை சேமிக்கிறது. சூத்திரம் “j = std:: move(temp)”; 'i' ஐ ஒரு குளோன் டெம்ப் மூலம் சேமித்து, ஒரே மாதிரியான டெம்ப் உள்ளடக்கங்களை அகற்றவும். மேலும், swap() செயல்பாடு செயல்படுத்தல் முடிந்ததும் தற்காலிக மாறியை நீக்கவும்.



உதாரணம் 1: std::move Method to Swap ஐப் பயன்படுத்தும் நிரல்

கீழே காட்டப்பட்டுள்ளபடி, C++11 அம்சம் std ::move ஐப் பயன்படுத்தி இரண்டு பொருட்களை மாற்றலாம்.





# அடங்கும்

# அடங்கும்



டெம்ப்ளேட்
வெற்றிடமானது இடமாற்று ( டி & , டி & பி )
{
டி வெப்பநிலை = வகுப்பு :: நகர்வு ( ) ;
= வகுப்பு :: நகர்வு ( பி ) ;
பி = வகுப்பு :: நகர்வு ( வெப்பநிலை ) ;
}
முழு எண்ணாக முக்கிய ( )
{
வகுப்பு :: திசையன் பட்டியல் = { 10 , 12 , 13 , பதினைந்து , 16 , 17 } ;
முழு எண்ணாக நான் = 3 , ஜே = 5 ;
இடமாற்று ( பட்டியல் [ நான் ] , பட்டியல் [ ஜே ] ) ;
க்கான ( முழு எண்ணாக நான் : பட்டியல் ) {
வகுப்பு :: கூட் << நான் << '''' ;
}
திரும்ப 0 ; }

எங்களிடம் ஒரு டெம்ப்ளேட் அறிவிப்பு உள்ளது, அதில் ஒரு பொருள் 'டி' உள்ளது. அதன் பிறகு, செயல்பாட்டை 'ஸ்வாப்' என நிறுவியுள்ளோம். செயல்பாடு 'T' வகையின் &a மற்றும் &b ஆகிய இரண்டு அளவுருக்களை எடுக்கும். T& a, T&b ஆகிய வாதங்களின் விளைவாக, கடந்து வந்த மாறியின் முகவரியைக் குறிப்பிடுவது அல்லது சேமித்து வைப்பது மற்றும் திரும்பப் பெறாமல் நேரடியாக அவற்றைப் பயன்படுத்துவதன் விளைவாக, swap(T& a, T&b) செயல்பாடு குறிப்பு மூலம் அழைப்பு என அழைக்கப்படுகிறது.



வெற்றிட இடமாற்றுக்குள், std::move முறையைப் பயன்படுத்தி இடமாற்று வழிமுறையைப் பயன்படுத்தியுள்ளோம். பின்னர், நாங்கள் நிரல் மெயின்களை உருவாக்கினோம். இங்கே, 'பட்டியல்' என்ற மாறியை அறிவித்து, அதை எண் மதிப்புகளின் பட்டியலுடன் துவக்கியுள்ளோம். 'i' மற்றும் 'j' ஆகியவற்றிற்கான மதிப்புகளை மாற்றுவதற்கு அமைத்துள்ளோம். இரண்டாவது குறியீட்டில் உள்ள எண் மதிப்பு ஐந்தாவது குறியீட்டில் உள்ள எண் மதிப்புடன் மாற்றப்பட்டது. பின்னர், ஸ்வாப் செயல்பாட்டை அழைத்தோம் மற்றும் மாற்றுவதற்கு 'i' மற்றும் 'j' குறியீடுகளை அனுப்பினோம். மாற்றப்பட்ட பட்டியலை அச்சிடுவதற்கு for loop பயன்படுத்தப்படுகிறது.

வெளியீடு மாற்றப்பட்ட பட்டியலைக் காட்டுகிறது. குறிப்பிட்ட குறியீடுகளின்படி மதிப்பை மாற்றி உருவாக்கப்பட்ட புதிய பட்டியலை நீங்கள் அவதானிக்கலாம்.

எடுத்துக்காட்டு 2: std:: swap முறையைப் பயன்படுத்தும் நிரல் இடமாற்றம்

பயன்பாட்டுத் தலைப்பில் (C++11 இல்) காணப்படும் std ::swap பொறிமுறையைப் பயன்படுத்துவது வழக்கமான பிழைத்திருத்தமாகும். இரண்டு பொருள்களின் மதிப்புகள் செயல்படுவதற்கு மாற்றப்படுகின்றன.

# அடங்கும்

# அடங்கும்

#உட்பட



முழு எண்ணாக முக்கிய ( )
{
வகுப்பு :: vectorarr = { 3 , 6 , 9 , பதினைந்து , 13 } ;
முழு எண்ணாக நான் = 3 , ஜே = 4 ;

வகுப்பு :: இடமாற்று ( arr [ நான் ] , arr [ ஜே ] ) ;

க்கான ( முழு எண்ணாக நான் : arr ) {
வகுப்பு :: கூட் << நான் << '''' ;
}

திரும்ப 0 ;
}

என்ற தலைப்புக் கோப்பை இறக்குமதி செய்வதன் மூலம், நமது நிரலில் உள்ள swap செயல்பாட்டை அணுகலாம். இங்கே, மேலும் இரண்டு முக்கியமான நூலகங்களுடன் என்ற தலைப்புக் கோப்பைச் சேர்த்துள்ளோம். பின்னர், நாங்கள் int முக்கிய முறையை நிறுவியுள்ளோம். நிரலின் முக்கிய உள்ளே, 'arr' என்ற மாறியை உருவாக்குவதன் மூலம் வெக்டரை அறிவித்துள்ளோம். 'arr' என்ற மாறி முழு எண்ணின் ஐந்து கூறுகளுடன் துவக்கப்படுகிறது. குறியீட்டு நிலைகள் இடமாற்றத்திற்காக 'i' மற்றும் 'j' க்கு ஒதுக்கப்பட்டுள்ளன. 'i' மற்றும் 'j' மாறிகள் பின்னர் குறிப்பிட்ட குறியீட்டின் மதிப்பின் இடமாற்றத்திற்கான std:: swap முறைக்கு அனுப்பப்படும். for loop மூலம், மாற்றப்பட்ட வரிசைகளை அச்சிட்டுள்ளோம்.

std::swap முறையைப் பயன்படுத்தி இடமாற்றுச் செயல்பாட்டிற்குப் பிறகு பெறப்பட்ட பட்டியல் பின்வருமாறு காட்டப்படும்:

எடுத்துக்காட்டு 3: புரோகிராம் std::iter_swap முறையைப் பயன்படுத்தி இடமாற்று

std::iter_swap அல்காரிதத்தைப் பயன்படுத்துதல், இது அல்காரிதத்திற்கான தலைப்பில் பட்டியலிடப்பட்டுள்ளது, இது கூடுதல் விருப்பமாகும். வழங்கப்பட்ட மறு செய்கைகள் சுட்டிக்காட்டும் பொருட்களின் மதிப்புகளை மாற்றுவதன் மூலம் அது செயல்படும் விதம்.

# அடங்கும்

# அடங்கும்

#உள்ளடக்க

# அடங்கும்



முழு எண்ணாக முக்கிய ( )
{
வகுப்பு :: vectorvec = { 64 , 61 , 62 , 63 , 60 } ;
முழு எண்ணாக நான் = 0 , ஜே = 4 ;
ஆட்டோ itr1 = வகுப்பு :: அடுத்தது ( ஒரு விஷயம். தொடங்கும் ( ) , நான் ) ;
ஆட்டோ itr2 = வகுப்பு :: அடுத்தது ( ஒரு விஷயம். தொடங்கும் ( ) , ஜே ) ;

வகுப்பு :: iter_swap ( itr1 , itr2 ) ;
க்கான ( முழு எண்ணாக நான் : ஒரு விஷயம் ) {
வகுப்பு :: கூட் << நான் << '''' ;
}
திரும்ப 0 ;
}

நிரலின் முக்கிய முறைக்கு, வெக்டார் மாறி 'vec' என்று அறிவித்து, அதற்கு எண்களின் வெக்டார் பட்டியலை வழங்கியுள்ளோம். பின்னர், 'i' மற்றும் 'j' மாறிக்கு குறியீட்டு நிலையைக் குறிப்பிட்டோம். std::iter_swap முறையானது iter1 மற்றும் iter2 ஐ ஒரு வாதமாக எடுத்துக்கொள்கிறது. iter1 மற்றும் iter2 ஆகியவை தானியங்குச் சொல்லுடன் அறிவிக்கப்பட்டு மறு செய்கை செயல்பாட்டைக் கொண்டுள்ளன. ஃபார் லூப் முறையானது இயக்கத்தின் போது திசையன் வரிசையின் மாற்றப்பட்ட மதிப்புகளை அச்சிடுகிறது.

std::iter_swap முறை குறிப்பிடப்பட்ட திசையன்களின் மதிப்புகளை வெற்றிகரமாக மாற்றியது.

எடுத்துக்காட்டு 4: இடமாற்றம் செய்ய தற்காலிக மாறிகள் இல்லாமல் பயன்படுத்தும் திட்டம்

தற்காலிக மாறிகளைப் பயன்படுத்தாமல் C++ குறியீட்டில் எண்களை மாற்றுவதற்கான புதிய வழியை இந்த எடுத்துக்காட்டு காட்டுகிறது.

# அடங்கும்

பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;

முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக 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++ இல் உள்ள swap() பற்றிய முழு விளக்கத்தையும், அதன் பயன்பாடு மற்றும் அது எவ்வாறு செயல்படுகிறது என்பதைக் காட்டும் சில எடுத்துக்காட்டுகளையும் பார்க்கலாம். std:: swap() செயல்பாட்டைப் பயன்படுத்துவதன் மூலம், இரண்டு மாறிகளின் மதிப்புகளை மாற்றலாம். C++ STL ஆனது std::swap() எனப்படும் உள்ளமைக்கப்பட்ட செயல்பாட்டை உள்ளடக்கியது. swap(T& variable 1, T& variable 2) function calls reference, மற்றும் C++ overloads swap() தரவு மாறிகளின் வகையைப் பொறுத்து இந்த டுடோரியலில் விளக்கப்பட்டுள்ளது.