C++ நிரலாக்கமானது சிறந்த மொழியாகும், ஏனெனில் இது பரந்த அளவிலான செயல்பாடுகள், கட்டமைப்பாளர்கள், தலைப்பு கோப்புகள், வகுப்புகள் மற்றும் பலவற்றை நமக்கு எளிதாக்குகிறது, மேலும் குறியீட்டை மிகவும் சுவாரஸ்யமாகவும் எளிதாகவும் செய்கிறது. C++ நிரலாக்கத்தில் உள்ள கன்ஸ்ட்ரக்டர்களில் ஒன்று 'மூவ்' கன்ஸ்ட்ரக்டர். 'மூவ்' கன்ஸ்ட்ரக்டர் என்பது ஒரு தனித்துவமான கட்டமைப்பாகும், இது மாறும் வகையில் ஒதுக்கப்பட்ட நினைவகம் அல்லது பிற ஆதாரங்களின் உரிமையை ஒரு பொருளிலிருந்து மற்றொரு பொருளுக்கு பயனுள்ள மற்றும் வள உணர்வுள்ள முறையில் மாற்ற அனுமதிக்கிறது.
C++ நிரலாக்கத்தில், 'மூவ்' கன்ஸ்ட்ரக்டர்கள் நகல்களைக் குறைக்கவும், செயல்திறனை அதிகரிக்கவும் அறிமுகப்படுத்தப்பட்டன. நகலெடுக்கும் செயல்பாடுகளைக் குறைப்பதன் மூலம் செயல்திறனை மேம்படுத்துவதில் இது முக்கியப் பங்கு வகிக்கிறது. இந்த வழிகாட்டி C++ நிரலாக்கத்தில் உள்ள 'மூவ்' கட்டமைப்பாளரைப் பற்றி ஆழமாக ஆராய்கிறது.
எடுத்துக்காட்டு 1:
இங்கே குறியீட்டைத் தொடங்க, 'iostream' மற்றும் 'string' தலைப்புக் கோப்புகளை நாங்கள் சேர்க்கிறோம், அவை இந்த தலைப்புக் கோப்புகளில் பல செயல்பாடுகள் அறிவிக்கப்பட்டிருப்பதால், எங்கள் குறியீட்டை சரியாக இயங்கச் செய்யும். நாம் 'cout' அறிக்கையைப் பயன்படுத்த வேண்டியிருக்கும் போது, 'iostream' தலைப்புக் கோப்பு பயன்படுத்தப்படுகிறது, ஏனெனில் இந்த செயல்பாடு இதற்குள் அறிவிக்கப்படுகிறது. சரம் வகை தரவுகளுடன் நாம் வேலை செய்ய வேண்டியிருக்கும் போது, 'ஸ்ட்ரிங்' தலைப்பு கோப்பு அவசியம்.
இதற்குப் பிறகு, இந்த தலைப்புக் கோப்புகளுக்குக் கீழே “namespace std” சேர்க்கப்படும். பின்னர், நாங்கள் இங்கே ஒரு வகுப்பை உருவாக்குகிறோம். வகுப்பின் பெயர் 'நகர்த்து'. இதற்குக் கீழே, 'தனியார்' முக்கிய வார்த்தை சேர்க்கப்பட்டுள்ளது, அதில் 'my_str' பெயருடன் ஒரு தனிப்பட்ட சரம் மாறியை அறிவிக்கிறோம். இப்போது, 'பொது' முக்கிய சொல்லை வைக்கிறோம், அங்கு இயல்புநிலை கட்டமைப்பாளரின் வரையறையைச் சேர்க்கிறோம். 'இது இங்கே இயல்புநிலை சரம்' என்பதை 'my_str' க்கு அளவுருவாகக் கடந்து, இயல்புநிலை கன்ஸ்ட்ரக்டரை காலியாக விடுவோம்.
இதற்குப் பிறகு, நாங்கள் கன்ஸ்ட்ரக்டர் வரையறையை நகலெடுத்து, 'my_str' ஐ 'my_obj.my_str' க்கு துவக்குகிறோம். இதற்கு கீழே, நாங்கள் ஒரு வரியை அச்சிட்டு, பின்னர் 'நகர்த்து' கட்டமைப்பாளரின் வரையறையை வைக்கிறோம். இங்கே, 'my_obj.my_str' உடன் மீண்டும் 'my_str' ஐ துவக்குகிறோம். இதற்குக் கீழே நாங்கள் எந்த அறிக்கையையும் சேர்க்கவில்லை; அது காலியாக உள்ளது. இதற்குப் பிறகு, சரம் வகையின் “displayMyObject()” என்ற செயல்பாட்டை அறிவித்து, “return str” ஐப் பயன்படுத்துகிறோம், அதனால் அது சரத்தை வழங்குகிறது.
உலகளாவிய “நியூ_டெம்ப்” செயல்பாட்டை “மூவ்” வகையாக வைக்கிறோம். அதன் கீழே, நகர்வு வகை பொருளை வழங்கும் 'திரும்ப தற்காலிக' உள்ளது. இப்போது, 'முக்கிய()' இயக்கி குறியீடு மற்றும் 'நகர்வு' வகையின் 'new_obj1' ஆகியவற்றை வைத்து 'rvalue' இலிருந்து 'move' கட்டமைப்பாளரைப் பெறுகிறோம். மேலே உள்ள வரியில், 'lvalue' இலிருந்து 'move' கன்ஸ்ட்ரக்டரைப் பெற 'new_obj1.displayMyObject()' ஐ வைக்கிறோம். இதற்குப் பிறகு, 'my_obj1' பொருளுடன் 'மூவ்' கட்டமைப்பாளரை அழைக்கிறோம். பின்னர், 'my_obj1' இன் உரிமையை 'my_obj2' என்ற மற்ற பொருளுக்கு மாற்றுவோம்.
குறியீடு 1:
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வர்க்கம் நகர்வு
{
தனிப்பட்ட :
சரம் my_str ;
பொது :
நகர்வு ( ) : my_str ( 'இது இங்கே இயல்புநிலை சரம்' )
{
}
நகர்வு ( நிலையான நகர்வு & my_obj ) : my_str ( my_obj. my_str )
{
கூட் << 'நகல் கட்டமைப்பாளர் அழைக்கப்பட்டார், நகர்த்த முடியவில்லை! \n ' ;
}
நகர்வு ( நகர்வு && my_obj ) : my_str ( நகர்வு ( my_obj. my_str ) )
{
}
string displayMyObject ( )
{
திரும்ப my_str ;
}
} ;
புதிய_டெம்பை நகர்த்தவும் ( tmp ஐ நகர்த்தவும் )
{
திரும்ப tmp ;
}
முழு எண்ணாக முக்கிய ( )
{
புதிய_obj1 ஐ நகர்த்தவும் = புதிய_வெப்பநிலை ( நகர்வு ( ) ) ;
கூட் << 'நகர்த்துவதற்கு முன்() அழைப்பு : new_obj1 = ' << புதிய_பொருள்1. என் பொருள் காட்சி ( ) << endl ;
புதிய_obj2 ஐ நகர்த்தவும் = நகர்வு ( புதிய_பொருள்1 ) ;
கூட் << 'பின் நகர்வு() கட்டமைப்பாளர் அழைப்பு : new_obj1 = ' << புதிய_பொருள்1. என் பொருள் காட்சி ( ) << endl ;
கூட் << 'பின் நகர்வு() கட்டமைப்பாளர் அழைப்பு : new_obj2 = ' << new_obj2. என் பொருள் காட்சி ( ) << endl ;
திரும்ப 0 ;
}
வெளியீடு:
வெளியீடு 'move()' முறையை அழைப்பதற்கு முன், 'new_obj1' இயல்புநிலை சரத்தைக் கொண்டுள்ளது. ஆனால் “மூவ்” கிளாஸ் மூவ்() முறையை அழைத்த பிறகு, “my_obj1” வெற்று சரத்தைக் கொண்டுள்ளது மற்றும் “my_obj2” இல் இயல்புநிலை சரம் உள்ளது.
எடுத்துக்காட்டு 2:
இங்கே, “வெக்டார்” தலைப்புக் கோப்பான மேலும் ஒரு தலைப்புக் கோப்பைச் சேர்த்துள்ளோம். வெக்டார்களின் செயல்பாடுகளை நாம் கையாள வேண்டிய போதெல்லாம் இதைச் சேர்க்கிறோம். இங்கே நாம் உருவாக்கும் வகுப்பு 'நகர்த்து' வகுப்பாகும். நாங்கள் இங்கே ஒரு 'பொது' கட்டமைப்பாளரை உருவாக்குகிறோம், அதில் 'int* மதிப்பு' raw pointerஐ வகுப்பு உறுப்பினரின் தரவு என்று அறிவிக்கிறோம். அதன் கீழே, எங்களிடம் 'பொது' உள்ளது, அதில் 'மூவ்' கன்ஸ்ட்ரக்டரை வைத்து அதன் அளவுருவாக 'int v1' ஐ அனுப்புகிறோம்.
இதற்குப் பிறகு, பொருட்களை ஒரு குவியலாக அறிவிக்கிறோம். 'மதிப்பை' 'புதிய எண்ணுடன்' துவக்குகிறோம் மற்றும் '*மதிப்பை' 'v1' உடன் துவக்குகிறோம். பின்னர், குறியீட்டை இயக்கும் போது அச்சிடும் ஒரு வரியைச் சேர்க்கும் இடத்தில் 'cout' ஐ வைக்கவும். இதற்கு கீழே, 'நகல்' கட்டமைப்பாளரைப் பயன்படுத்துகிறோம். இந்த 'நகல்' கட்டமைப்பாளர் ஆழமான நகலை உருவாக்குவதன் மூலம் தரவை நகலெடுக்கிறார். நாங்கள் 'மூவ்' கட்டமைப்பாளரை வைத்து, அதன் அளவுருவாக 'நகர்த்து&& new_source' ஐ அனுப்புகிறோம். அதற்குக் கீழே, தேவையான அறிக்கையைக் காண்பிக்க உதவும் “கவுட்” ஐ வைக்கிறோம்.
குறிப்பைப் பயன்படுத்துவதற்கு முன்பு ஒரு சுட்டி காலியாக உள்ளதா என்பதைத் தீர்மானிக்க “nullptr” முக்கிய சொல்லைச் செருகுவோம். இப்போது, '~Move()' அழிப்பையும் வைக்கிறோம், அதில் 'மதிப்பு' 'nullptr' க்கு சமமாக இல்லையா என்பதைச் சரிபார்க்கும் 'if' நிபந்தனையை வைக்கிறோம். இந்த நிபந்தனை சரிபார்க்கப்பட்டால், இதற்குக் கீழே உள்ள அறிக்கை செயல்படுத்தப்படும். இந்த நிபந்தனை சரிபார்க்கப்படாவிட்டால், அது 'if' நிபந்தனைக்குப் பிறகு இருக்கும் 'cout' அறிக்கையைத் தவிர்த்துவிட்டு 'மற்ற' பகுதியை நோக்கி நகரும்.
இதற்குப் பிறகு, ஒரு பொருளைக் கையாள்வதில் உதவும் 'நீக்கு' முக்கிய சொல்லைப் பயன்படுத்துகிறோம் அல்லது பொருளின் தரவுக் கூறுகளுக்கு ஒதுக்கப்பட்ட நினைவகத்தை அது வெளியிடுகிறது என்று கூறலாம். இப்போது, நாங்கள் இங்கே “main()” முறையைத் தொடங்கி, “my_vec” என்ற பெயரில் எங்கள் “Move” வகுப்பின் திசையனை உருவாக்குகிறோம். இதற்குப் பிறகு, வெக்டரின் இறுதிப் புள்ளியில் மதிப்பைச் செருக உதவும் “புஷ்_பேக்()” செயல்பாட்டைப் பயன்படுத்துகிறோம். 'வெக்டர்' தலைப்பு கோப்பு இந்த செயல்பாட்டைக் கொண்டுள்ளது. முதலில், வெக்டரில் '39' ஐ செருகுவோம். பின்னர், '57' செருகப்பட்டு, 'push_back()' முறையைப் பயன்படுத்தி '91' செருகப்படுகிறது.
குறியீடு 2:
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வர்க்கம் நகர்வு {
தனிப்பட்ட :
முழு எண்ணாக * மதிப்பு ;
பொது :
நகர்வு ( முழு எண்ணாக v1 )
{
மதிப்பு = புதிய முழு எண்ணாக ;
* மதிப்பு = v1 ;
கூட் << 'கட்டமைப்பாளர் அழைக்கப்படுகிறார்'
<< v1 << endl ;
} ;
நகர்வு ( நிலையான நகர்வு & புதிய_மூலம் )
: நகர்வு { * புதிய_மூலம். மதிப்பு }
{
கூட் << 'நகல் கட்டமைப்பாளர் அழைக்கப்படுகிறது -'
<< 'ஆழமான நகல்'
<< * புதிய_மூலம். மதிப்பு
<< endl ;
}
நகர்வு ( நகர்வு && புதிய_மூலம் )
: மதிப்பு { புதிய_மூலம். மதிப்பு }
{
கூட் << 'கட்டமைப்பாளரை நகர்த்தவும்'
<< * புதிய_மூலம். மதிப்பு << endl ;
புதிய_மூலம். மதிப்பு = nullptr ;
}
~ நகர்த்து ( )
{
என்றால் ( மதிப்பு ! = nullptr )
கூட் << 'அழிப்பவர் அழைக்கப்படுகிறது'
<< * மதிப்பு << endl ;
வேறு
கூட் << 'அழிப்பவர் அழைக்கப்படுகிறது'
<< 'nullptrக்கு'
<< endl ;
அழி மதிப்பு ;
}
} ;
முழு எண்ணாக முக்கிய ( )
{
திசையன் < நகர்வு > என்_பொருள் ;
என்_பொருள். பின் தள்ளு ( நகர்வு { 39 } ) ;
என்_பொருள். பின் தள்ளு ( நகர்வு { 57 } ) ;
என்_பொருள். பின் தள்ளு ( நகர்வு { 91 } ) ;
திரும்ப 0 ;
}
வெளியீடு:
“நகல்” செயல்பாட்டைப் பயன்படுத்துவதற்குப் பதிலாக, “நகல்” செயல்பாட்டிற்கு தேவையில்லாத அழைப்பைத் தடுக்க, “நகர்த்து” செயல்பாட்டைப் பயன்படுத்த வேண்டும் என்பதை இது காட்டுகிறது. ஒரு தற்காலிக பொருள் அல்லது அழிக்கப்படும் சில பொருளைக் கொண்டு பொருளைத் துவக்கும்போது 'நகர்வு' கட்டமைப்பாளர் இங்கு செயல்படுத்தப்படுகிறது. கொடுக்கப்பட்ட தரவின் ஆழமான நகலைக் கையாளுவதற்குப் பதிலாக, 'நகர்த்து' கட்டமைப்பாளர் வளங்களின் உரிமையை ஒரு பொருளிலிருந்து மற்றொரு பொருளுக்கு மாற்றுகிறார்.
முடிவுரை
இந்த வழிகாட்டியில், 'மூவ்' கட்டமைப்பாளரைப் பற்றி ஆராய்ந்தோம். C++ நிரலாக்கத்தில் உள்ள 'மூவ்' கன்ஸ்ட்ரக்டர் என்பது ஒரு பொருளின் வளங்களை மற்றொரு பொருளுக்கு திறம்பட இடமாற்றம் செய்வதற்கான ஒரு தனித்துவமான முறையாகும் என்பதை நாங்கள் விளக்கினோம். 'மூவ்' கன்ஸ்ட்ரக்டரை அழைப்பது குறைவான மேல்நிலையைக் கொண்டிருப்பதைக் குறித்து நாங்கள் விவாதித்தோம், மேலும் குறியீட்டை அதிக நினைவக திறன் கொண்டதாக ஆக்குகிறது. C++ நிரலாக்கத்தில் 'மூவ்' கன்ஸ்ட்ரக்டர் ஒரு சக்திவாய்ந்த அம்சம் என்பதை நாங்கள் ஆராய்ந்தோம். 'மூவ்' கன்ஸ்ட்ரக்டரின் கருத்தை விளக்குவதற்கு நடைமுறை உதாரணங்களையும் நாங்கள் பயன்படுத்தினோம், மேலும் C++ நிரலாக்கத்தில் 'மூவ்' கன்ஸ்ட்ரக்டரைப் பயன்படுத்துவதன் செயல்திறன் நன்மைகளை விளக்கினோம்.