வரிசையானது பல தரவைச் சேமிக்கப் பயன்படுகிறது, மேலும் வரிசையின் உறுப்புகளின் எண்ணிக்கையை இயக்க நேரத்தில் மாற்ற முடியாது. டைனமிக் வரிசையைப் போல செயல்படும் வெக்டரைப் பயன்படுத்துவதன் மூலம் இந்த சிக்கலை தீர்க்க முடியும். வெக்டரில் இருந்து ஒரு உறுப்பைச் சேர்க்க மற்றும் அகற்ற வெக்டார் வகுப்பில் வெவ்வேறு செயல்பாடுகள் உள்ளன. வெக்டரின் அளவைக் குறைக்கும் இயக்க நேரத்தில் வெக்டரில் இருந்து ஒன்று அல்லது அதற்கு மேற்பட்ட உறுப்புகளை அகற்ற அழிப்பு() செயல்பாடு பயன்படுத்தப்படுகிறது. இந்தச் செயல்பாட்டின் பயன்கள் இந்த டுடோரியலில் விளக்கப்பட்டுள்ளன.
தொடரியல்:
இந்த செயல்பாட்டின் இரண்டு வகையான தொடரியல் கீழே கொடுக்கப்பட்டுள்ளது.
மறு செய்கை அழித்தல் ( மீண்டும் செய்பவர் நிலை ) ;
மேலே உள்ள அழிப்பு() செயல்பாடு வெக்டரில் இருந்து ஒரு தனிமத்தை அகற்றப் பயன்படுகிறது, மேலும் அது மீண்டும் ஒரு உறுப்பைத் தருகிறது, மேலும் அது கடைசியாக அழிக்கப்பட்ட உறுப்பைத் தொடர்ந்து வரும் உறுப்பைச் சுட்டிக்காட்டுகிறது.
மறு செய்கை அழித்தல் ( மறுசெய்பவர் தொடக்க_நிலை, மறுசெய்பவர் முடிவு_நிலை ) ;
இந்த செயல்பாட்டின் முதல் மற்றும் இரண்டாவது வாதங்களில் குறிப்பிடப்பட்டுள்ள நிலையின் அடிப்படையில் வெக்டரில் இருந்து பல கூறுகளை அகற்ற மேலே உள்ள அழிப்பு() செயல்பாடு பயன்படுத்தப்படுகிறது.
முன் தேவை:
இந்த டுடோரியலின் உதாரணங்களைச் சரிபார்க்கும் முன், கணினியில் g++ கம்பைலர் நிறுவப்பட்டுள்ளதா இல்லையா என்பதைச் சரிபார்க்க வேண்டும். நீங்கள் விஷுவல் ஸ்டுடியோ குறியீட்டைப் பயன்படுத்துகிறீர்கள் என்றால், இயங்கக்கூடிய குறியீட்டை உருவாக்க, C++ மூலக் குறியீட்டைத் தொகுக்க தேவையான நீட்டிப்புகளை நிறுவவும். இங்கே, விஷுவல் ஸ்டுடியோ கோட் பயன்பாடு C++ குறியீட்டை தொகுக்கவும் இயக்கவும் பயன்படுத்தப்படுகிறது. வெக்டரில் உறுப்பு(களை) செருக அழித்தல்() செயல்பாட்டின் வெவ்வேறு பயன்பாடுகள் கீழே காட்டப்பட்டுள்ளன.
எடுத்துக்காட்டு-1: முதல் உறுப்பு உறுப்பை அகற்றவும்
வெக்டரின் தொடக்கத்திலிருந்து ஒரு உறுப்பை அகற்ற பின்வரும் குறியீட்டைக் கொண்டு C++ கோப்பை உருவாக்கவும். குறியீட்டில் சரம் மதிப்புகளின் வெக்டார் பயன்படுத்தப்பட்டுள்ளது. வெக்டரின் மதிப்புகள் வெக்டரில் இருந்து முதல் உறுப்பை நீக்குவதற்கு முன்னும் பின்னும் ஒரு அளவுருவுடன் erase() செயல்பாட்டைப் பயன்படுத்தி அச்சிடப்பட்டிருக்கும்.
//தேவையான நூலகங்களைச் சேர்க்கவும்#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
//வெக்டரின் மதிப்புகளைக் காட்டு
வெற்றிடமானது காட்சி_வெக்டர் ( திசையன் < லேசான கயிறு > பழங்கள் )
{
//கவுண்டரை துவக்கவும்
முழு எண்ணாக கவுண்டர் = 1 ;
//லூப்பைப் பயன்படுத்தி திசையன் கூறுகளை மீண்டும் செய்யவும் மற்றும் அச்சிடவும்
க்கான ( ஆட்டோ அவர் = பழங்கள். தொடங்கும் ( ) ; அவர் ! = பழங்கள். முடிவு ( ) ; அவர் ++ )
{
//உறுப்புகள் கடைசி உறுப்புதானா இல்லையா என்பதைச் சரிபார்க்கவும்
என்றால் ( கவுண்டர் ! = பழங்கள். அளவு ( ) )
கூட் << * அவர் << ',' ;
வேறு
கூட் << * அவர் ;
//கவுண்டரை 1 ஆல் அதிகரிக்கவும்
கவுண்டர் ++ ;
}
கூட் << endl ;
}
முழு எண்ணாக முக்கிய ( வெற்றிடமானது ) {
//ஸ்ட்ரிங் டேட்டாவின் வெக்டரை அறிவிக்கவும்
திசையன் < லேசான கயிறு > பழங்கள் = { 'ஆரஞ்சு' , 'வாழை' , 'மாங்கனி' , 'பலா பழம்' , லிச்சி } ;
//வெக்டரின் தற்போதைய மதிப்புகளை அச்சிடவும்
கூட் << 'அகற்றுவதற்கு முன் திசையன் மதிப்புகள்:' << endl ;
காட்சி_வெக்டர் ( பழங்கள் ) ;
//வெக்டரில் இருந்து முதல் உறுப்பை அகற்றவும்
பழங்கள். அழிக்க ( பழங்கள். தொடங்கும் ( ) ) ;
//வெக்டரின் தற்போதைய மதிப்புகளை அகற்றிய பின் அச்சிடவும்
கூட் << ' \n அகற்றிய பின் திசையன் மதிப்புகள்: ' << endl ;
காட்சி_வெக்டர் ( பழங்கள் ) ;
திரும்ப 0 ;
}
வெளியீடு:
மேலே உள்ள குறியீட்டை இயக்கிய பின் பின்வரும் வெளியீடு தோன்றும்.
எடுத்துக்காட்டு-2: பல கூறுகளை அகற்று
erase() செயல்பாட்டைப் பயன்படுத்தி வெக்டரில் இருந்து பல உறுப்புகளை அகற்ற, பின்வரும் குறியீட்டைக் கொண்டு C++ கோப்பை உருவாக்கவும். குறியீட்டில் முழு எண் மதிப்புகளின் திசையன் பயன்படுத்தப்பட்டுள்ளது. வெக்டரில் இருந்து அகற்றப்பட்ட தனிமங்களின் வரம்பை அமைக்க இரண்டு மறு செய்கைகள் இங்கு பயன்படுத்தப்பட்டுள்ளன. வெக்டரில் இருந்து பல கூறுகளை அகற்ற erase() செயல்பாடு இரண்டு அளவுருக்களுடன் பயன்படுத்தப்பட்டது.
//தேவையான நூலகங்களைச் சேர்க்கவும்#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
//வெக்டரைக் காட்டு
வெற்றிடமானது காட்சி_வெக்டர் ( திசையன் < முழு எண்ணாக > எண்கள் )
{
//லூப்பைப் பயன்படுத்தி வெக்டரின் மதிப்புகளை அச்சிடவும்
க்கான ( ஆட்டோ அவர் = எண்கள். தொடங்கும் ( ) ; அவர் ! = எண்கள். முடிவு ( ) ; அவர் ++ )
கூட் << * அவர் << '' ;
//புதிய வரியைச் சேர்க்கவும்
கூட் << ' \n ' ;
}
முழு எண்ணாக முக்கிய ( ) {
//முழு தரவுகளின் வெக்டரை அறிவிக்கவும்
திசையன் < முழு எண்ணாக > intArray { 678 , 435 , 960 , 231 , 800 , 387 , 634 , 267 , 409 , 294 } ;
//வெக்டரின் தற்போதைய மதிப்புகளை அச்சிடவும்
கூட் << 'அகற்றுவதற்கு முன் திசையன் மதிப்புகள்:' << endl ;
காட்சி_வெக்டர் ( intArray ) ;
//வெக்டரில் இருந்து தனிமங்களின் வரம்பை அகற்ற இரண்டு மறு செய்கைகளை அறிவிக்கவும்
திசையன் < முழு எண்ணாக > :: மீண்டும் செய்பவர் startEle, endEle ;
//இடிரேட்டரை முதல் நிலைக்கு அமைக்கவும்
அவற்றைத் தொடங்குங்கள் = intArray. தொடங்கும் ( ) ;
//தொடக்க மறு செய்கையை 2 ஆல் அதிகரிக்கவும்
முன்கூட்டியே ( அவற்றை தொடங்க, 2 ) ;
//இடிரேட்டரை கடைசி நிலைக்கு அமைக்கவும்
endEle = intArray. முடிவு ( ) ;
//முடிவு செய்யும் செயலியை 3 ஆல் குறைக்கவும்
முன்கூட்டியே ( endEle, - 3 ) ;
//உறுப்புகளின் வரம்பை அகற்றவும்
intArray. அழிக்க ( startEle, endEle ) ;
//வெக்டரின் தற்போதைய மதிப்புகளை அகற்றிய பின் அச்சிடவும்
கூட் << ' \n அகற்றிய பின் திசையன் மதிப்புகள்: ' << endl ;
காட்சி_வெக்டர் ( intArray ) ;
திரும்ப 0 ;
}
வெளியீடு:
மேலே உள்ள குறியீட்டை இயக்கிய பின் பின்வரும் வெளியீடு தோன்றும். இடிரேட்டர்களின் வரம்பின்படி, திசையன் 3 வது நிலையிலிருந்து 7 வது நிலை வரையிலான உறுப்புகள் அகற்றப்பட்டுள்ளன.
எடுத்துக்காட்டு-3: குறிப்பிட்ட கூறுகளை அகற்றவும்
erase() செயல்பாட்டைப் பயன்படுத்தி வெக்டரின் குறிப்பிட்ட உறுப்புகளை அகற்ற, பின்வரும் குறியீட்டைக் கொண்டு C++ கோப்பை உருவாக்கவும். குறியீட்டில் 7 முழு எண் உறுப்புகளின் திசையன் அறிவிக்கப்பட்டுள்ளது. அடுத்து, திசையன் கூறுகளை மீண்டும் செய்யவும் மற்றும் 5 ஆல் வகுபடாத வெக்டரில் இருந்து அந்த உறுப்புகளை அகற்றவும் 'for' லூப் பயன்படுத்தப்படுகிறது.
//தேவையான நூலகங்களைச் சேர்க்கவும்#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( )
{
//முழு தரவுகளின் வெக்டரை அறிவிக்கவும்
திசையன் < முழு எண்ணாக > எண்கள் = { 78 , நான்கு. ஐந்து , 67 , 25 , 98 , 75 , 52 } ;
கூட் << 'அகற்றுவதற்கு முன் திசையன் மதிப்புகள்: \n ' ;
க்கான ( முழு எண்ணாக நிலையான & நான் : எண்கள் ) {
கூட் << நான் << '''' ;
}
கூட் << endl ;
//5 ஆல் வகுபடாத எண்களை வெக்டரில் இருந்து நீக்கவும்
க்கான ( ஆட்டோ அவர் = எண்கள். தொடங்கும் ( ) ; அவர் ! = எண்கள். முடிவு ( ) ; அவர் ++ )
{
//எண் 5 ஆல் வகுபடுமா இல்லையா என்பதைச் சரிபார்க்கவும்
என்றால் ( * அவர் % 5 ! = 0 )
{
//இடிரேட்டரின் அடிப்படையில் உறுப்பை அகற்றவும்
எண்கள். அழிக்க ( அவர் -- ) ;
}
}
கூட் << 'அகற்றிய பின் திசையன் மதிப்புகள்: \n ' ;
க்கான ( முழு எண்ணாக நிலையான & நான் : எண்கள் ) {
கூட் << நான் << '''' ;
}
கூட் << endl ;
திரும்ப 0 ;
}
வெளியீடு:
மேலே உள்ள குறியீட்டை இயக்கிய பின் பின்வரும் வெளியீடு தோன்றும். வெக்டரில் வகுபடக்கூடிய தனிமங்கள் 5 ஆல் மட்டுமே இருப்பதாகவும், மற்ற உறுப்புகள் அகற்றப்பட்டதாகவும் வெளியீடு காட்டுகிறது.
முடிவுரை:
வெக்டார் உறுப்புகளை அகற்ற, இந்த டுடோரியலில் erase() செயல்பாட்டின் வெவ்வேறு பயன்பாடுகள் காட்டப்பட்டுள்ளன. C++ ஆனது வெக்டரில் இருந்து உறுப்பை அகற்ற பல செயல்பாடுகளை கொண்டுள்ளது, மேலும் அந்த செயல்பாடுகள் ஒரு நேரத்தில் ஒற்றை உறுப்பை அகற்றும். ஆனால் வெக்டரின் எந்த நிலையிலிருந்தும் ஒற்றை மற்றும் பல கூறுகளை வெக்டார் அழிப்பு() செயல்பாட்டைப் பயன்படுத்தி அகற்றலாம்.