C++ இல், வெக்டார் என்பது ஒரு பரிமாண தரவு கட்டமைப்பாகும், இது தேவையின் அடிப்படையில் மாறும் தன்மையை அதிகரிக்கிறது. இந்தத் தரவுக் கட்டமைப்பில் தரவு அமைப்பு (செருக்குதல்/மாற்றம்/நீக்குதல்) திறமையாகச் செய்யப்படலாம். அதன் பயன்பாடுகளில் பின்வருவன அடங்கும்:
- அறிவியல் மற்றும் பொறியியல் பயன்பாடுகளில் கணித திசையன்களைப் பிரதிநிதித்துவப்படுத்துகிறது
- இந்த தரவு கட்டமைப்பைப் பயன்படுத்தி வரிசைகள், அடுக்குகள் போன்றவற்றை செயல்படுத்தலாம்.
இந்தத் தரவுக் கட்டமைப்புடன் தொடர்புடைய பெரும்பாலான பொதுவான CRUD செயல்பாடுகள் மற்றும் செயல்பாடுகள், தொடரியல் மற்றும் குறியீடு துணுக்குகளுடன் காட்சி வாரியாக விரிவாக விவாதிக்கப்படுகின்றன.
உள்ளடக்கத்தின் தலைப்பு:
- ஒரு வெக்டரில் ஒரு உறுப்பைச் செருகவும்
- வெக்டரில் பல கூறுகளைச் செருகவும்
- வெக்டரில் இருந்து உறுப்புகளை அணுகவும்
- வெக்டரில் உள்ள உறுப்பைப் புதுப்பிக்கவும்
- வெக்டரில் இருந்து ஒரு குறிப்பிட்ட உறுப்பை அகற்றவும்
- வெக்டரில் இருந்து அனைத்து கூறுகளையும் அகற்றவும்
- திசையன்களின் ஒன்றியம்
- திசையன்களின் குறுக்குவெட்டு
- வெக்டார் காலியாக உள்ளதா இல்லையா என்பதைச் சரிபார்க்கவும்
- கான்ஸ்ட்_இடரேட்டரைப் பயன்படுத்தி ஒரு திசையன் பயணிக்கவும்
- ரிவர்ஸ்_இட்டரேட்டரைப் பயன்படுத்தி ஒரு திசையனைப் பயணிக்கவும்
- உறுப்புகளை வெக்டருக்குள் தள்ளுங்கள்
- வெக்டரில் இருந்து கூறுகளை பாப் செய்யவும்
- திசையன்களை மாற்றவும்
- வெக்டரிலிருந்து முதல் உறுப்பைப் பெறவும்
- வெக்டரில் இருந்து கடைசி உறுப்பைப் பெறவும்
- ஒரு வெக்டருக்கு புதிய மதிப்புகளை ஒதுக்கவும்
- Emplace()ஐப் பயன்படுத்தி வெக்டரை நீட்டவும்
- Emplace_Back()ஐப் பயன்படுத்தி வெக்டரை நீட்டவும்
- வெக்டரின் அதிகபட்ச உறுப்பு
- ஒரு திசையன் குறைந்தபட்ச உறுப்பு
- வெக்டரில் உள்ள தனிமங்களின் கூட்டுத்தொகை
- இரண்டு திசையன்களின் உறுப்பு வாரியான பெருக்கல்
- இரண்டு திசையன்களின் புள்ளி தயாரிப்பு
- ஒரு தொகுப்பை வெக்டராக மாற்றவும்
- நகல் கூறுகளை அகற்றவும்
- வெக்டரை ஒரு தொகுப்பாக மாற்றவும்
- வெற்று சரங்களை அகற்று
- ஒரு உரை கோப்பில் ஒரு திசையன் எழுதவும்
- ஒரு உரை கோப்பிலிருந்து ஒரு திசையன் உருவாக்கவும்
ஒரு வெக்டரில் ஒரு உறுப்பைச் செருகவும்
தி std::vector::insert() C++ STL இல் உள்ள செயல்பாடு குறிப்பிட்ட நிலையில் உறுப்புகளைச் செருகப் பயன்படுகிறது.
தொடரியல்:
திசையன். செருகு ( நிலை, உறுப்பு ) ;இந்தச் செயல்பாட்டைப் பயன்படுத்தி, முதல் நிலையை ஒரு அளவுருவாக அனுப்புவோம், இது உறுப்பு செருகப்பட வேண்டிய நிலையைக் குறிப்பிடுகிறது மற்றும் உறுப்பை இரண்டாவது அளவுருவாக வழங்குகிறது.
உள்ளீட்டு வெக்டரின் முதல் உறுப்பைக் குறிக்கும் ஒரு மறு செய்கையை திரும்பப் பெறுவதற்கு இங்கே ஆரம்பம்() செயல்பாட்டைப் பயன்படுத்தலாம். இந்தச் செயல்பாட்டிற்கு நிலையைச் சேர்ப்பதன் மூலம், உறுப்பு அந்த நிலையில் செருகப்படுகிறது.
வகை சரத்தின் “மாணவர்_பெயர்கள்” வெக்டரை உருவாக்கி, இன்செர்ட்() செயல்பாட்டைப் பயன்படுத்தி இரண்டு சரங்களை ஒன்றன் பின் ஒன்றாக முதல் மற்றும் இரண்டாவது நிலைகளில் செருகுவோம்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// திசையன் - மாணவர்_பெயர்களை துவக்குதல்
திசையன் < லேசான கயிறு > மாணவர்_பெயர்கள் ;
கூட் << 'தற்போதைய திசையன்: \n ' ;
க்கான ( ஆட்டோ நான் : மாணவர்_பெயர்கள் ) கூட் << நான் << endl ;
// முதல் இடத்தில் 'ஸ்ரவன் குமார்' என்று செருகவும்
மாணவர்_பெயர்கள். செருகு ( மாணவர்_பெயர்கள். தொடங்கும் ( ) + 0 , 'ஷ்ரவன் குமார்' ) ;
// இரண்டாவது இடத்தில் 'ஸ்ரவன் குமார்' என்பதைச் செருகவும்
மாணவர்_பெயர்கள். செருகு ( மாணவர்_பெயர்கள். தொடங்கும் ( ) + 1 , 'லலிதா' ) ;
கூட் << 'இறுதி திசையன்: \n ' ;
க்கான ( ஆட்டோ ஜே : மாணவர்_பெயர்கள் ) கூட் << ஜே << endl ;
}
வெளியீடு:
முன்பு, “மாணவர்_பெயர்கள்” வெக்டார் காலியாக இருந்தது. செருகிய பிறகு, திசையன் இரண்டு கூறுகளை வைத்திருக்கிறது.
வெக்டரில் பல கூறுகளைச் செருகவும்
இந்தச் சூழ்நிலையில் std::vector::insert() என்ற அதே செயல்பாட்டைப் பயன்படுத்துகிறோம். ஆனால் ஒரு வெக்டரில் பல கூறுகளைச் செருக, கூடுதல்/வெவ்வேறு அளவுருக்களை ஒரே செயல்பாட்டிற்கு அனுப்ப வேண்டும்.
காட்சி 1: ஒரு தனிமத்தை பல முறை செருகுதல்
இந்த சூழ்நிலையில், ஒரே உறுப்பை பலமுறை சேர்க்கிறோம்.
தொடரியல்:
திசையன். செருகு ( நிலை, அளவு, உறுப்பு ) ;இதைச் செய்ய, செருகு() செயல்பாட்டிற்கு அளவை இரண்டாவது அளவுருவாக அனுப்ப வேண்டும். இந்த செயல்பாட்டிற்கு அனுப்பப்படும் மொத்த அளவுருக்கள் மூன்று.
இங்கே:
- நிலை அளவுரு செருகப்பட வேண்டிய உறுப்பு நிலையைக் குறிப்பிடுகிறது. அளவு 1 ஐ விட அதிகமாக இருந்தால், தொடக்க நிலை குறியீடு நிலையாக இருக்கும்.
- அளவு அளவுரு ஒரு உறுப்பு எத்தனை முறை செருகப்பட வேண்டும் என்பதைக் குறிப்பிடுகிறது.
- உறுப்பு அளவுரு ஒரு வெக்டரில் செருகப்படும் உறுப்பை எடுக்கும்.
இரண்டு சரங்களைக் கொண்ட “மாணவர்_பெயர்கள்” வெக்டரைக் கவனியுங்கள். இரண்டாவது நிலையில் 'லாவண்யா' சரங்களை ஐந்து முறை செருகவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// திசையன் - மாணவர்_பெயர்களை துவக்குதல்
திசையன் < லேசான கயிறு > மாணவர்_பெயர்கள் { 'ஷ்ரவன் குமார்' , 'லலிதா' } ;
கூட் << 'தற்போதைய திசையன்: \n ' ;
க்கான ( ஆட்டோ நான் : மாணவர்_பெயர்கள் ) கூட் << நான் << endl ;
// 'லாவண்யா' என்பதை இரண்டாவது இடத்தில் 5 முறை செருகவும்
மாணவர்_பெயர்கள். செருகு ( மாணவர்_பெயர்கள். தொடங்கும் ( ) + 1 , 5 , 'லாவண்யா' ) ;
கூட் << ' \n இறுதி திசையன்: \n ' ;
க்கான ( ஆட்டோ ஜே : மாணவர்_பெயர்கள் ) கூட் << ஜே << endl ;
}
வெளியீடு:
தற்போதுள்ள வெக்டரில், 'ஸ்ரவன் குமார்' முதல் இடத்திலும், 'லலிதா' இரண்டாவது இடத்திலும் உள்ளனர். 'லாவண்யா' ஐ ஐந்து முறை (இரண்டாவது இடத்தில் இருந்து ஆறாவது இடத்திற்கு) செருகிய பிறகு, 'லலிதா' ஏழாவது இடத்திற்கு (கடைசி) சென்றார்.
காட்சி 2: பல கூறுகளைச் செருகுதல்
இந்த சூழ்நிலையில், மற்றொரு திசையனிலிருந்து ஒரு நேரத்தில் வெவ்வேறு கூறுகளைச் சேர்க்கிறோம். நாங்கள் இங்கே அதே செயல்பாட்டைப் பயன்படுத்துகிறோம், ஆனால் தொடரியல் மற்றும் அளவுருக்கள் மாறும்.
தொடரியல்:
திசையன். செருகு ( நிலை, முதல்_இடிரேட்டர், இரண்டாவது_இடரேட்டர் ) ;இதைச் செய்ய, செருகு() செயல்பாட்டிற்கு அளவை இரண்டாவது அளவுருவாக அனுப்ப வேண்டும். இந்த செயல்பாட்டிற்கு அனுப்பப்படும் மொத்த அளவுருக்கள் மூன்று.
இங்கே:
- நிலை அளவுரு செருகப்பட வேண்டிய உறுப்பு நிலையைக் குறிப்பிடுகிறது.
- 'first_iterator' என்பது உறுப்புகள் செருகப்பட வேண்டிய தொடக்க நிலையைக் குறிப்பிடுகிறது (அடிப்படையில், ஆரம்பம்() செயல்பாட்டைப் பயன்படுத்தி, ஒரு மறு செய்கை திரும்பப் பெறப்படுகிறது, இது கொள்கலனில் இருக்கும் முதல் உறுப்பைக் குறிக்கிறது).
- 'second_iterator' இறுதி நிலையைக் குறிப்பிடுகிறது, அது வரை உறுப்புகள் செருகப்பட வேண்டும் (அடிப்படையில், முடிவு() செயல்பாட்டைப் பயன்படுத்தி, ஒரு மறு செய்கை திரும்பப் பெறப்படுகிறது, இது கொள்கலனில் உள்ள கடைசி புள்ளிக்கு அடுத்ததாக உள்ளது).
முழு எண் வகையின் இரண்டு திசையன்களை உருவாக்கவும், 'மார்க்ஸ்1' மற்றும் 'மார்க்ஸ்2'. 'மார்க்ஸ்2' வெக்டரில் இருக்கும் அனைத்து உறுப்புகளையும் 'மார்க்ஸ்1' வெக்டரின் முதல் நிலையில் செருகவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை துவக்குதல் - மதிப்பெண்கள்1
திசையன் < முழு எண்ணாக > மதிப்பெண்கள்1 { 100 , 89 , 90 , 78 , 98 } ;
கூட் << 'முதல் திசையன்: \n ' ;
க்கான ( ஆட்டோ நான் : மதிப்பெண்கள்1 ) கூட் << நான் << endl ;
// வெக்டரை துவக்குதல் - மதிப்பெண்கள்2
திசையன் < முழு எண்ணாக > மதிப்பெண்கள்2 { 56 , நான்கு. ஐந்து , 65 } ;
கூட் << 'இரண்டாவது திசையன்: \n ' ;
க்கான ( ஆட்டோ ஜே : மதிப்பெண்கள்2 ) கூட் << ஜே << endl ;
மதிப்பெண்கள்1. செருகு ( தொடங்கும் ( மதிப்பெண்கள்1 ) , தொடங்கு ( மதிப்பெண்கள்2 ) , முடிவு ( மதிப்பெண்கள்2 ) ) ;
// இறுதி திசையன்
கூட் << 'முதல்-இறுதி திசையன்: \n ' ;
க்கான ( ஆட்டோ எக்ஸ் : மதிப்பெண்கள்1 )
கூட் << எக்ஸ் << '' ;
}
வெளியீடு:
முதல் திசையன் (மார்க்ஸ்1) ஐந்து தனிமங்களையும், இரண்டாவது திசையன் (மார்க்ஸ்2) மூன்று கூறுகளையும் கொண்டுள்ளது. 'செருகு' செயல்பாட்டிற்கு ஆரம்பம் (மதிப்பீடுகள் 1), தொடக்கம் (மார்க்ஸ்2), முடிவு (மார்க்ஸ்2) அளவுருக்களை நாங்கள் கடந்துவிட்டோம், அதாவது இரண்டாவது திசையனில் இருக்கும் அனைத்து கூறுகளும் தொடக்கத்தில் முதல் திசையனுக்குள் மீண்டும் செருகப்படுகின்றன. எனவே, முதல் திசையன் எட்டு கூறுகளைக் கொண்டுள்ளது.
வெக்டரில் இருந்து உறுப்புகளை அணுகவும்
1. [] ஆபரேட்டரைப் பயன்படுத்துதல்
சில சூழ்நிலைகளில், வெக்டரில் இருந்து குறிப்பிட்ட உறுப்புகளை மட்டும் திருப்பி அனுப்ப வேண்டிய தேவை உங்களுக்கு இருக்கலாம். அனைத்து கூறுகளையும் திரும்பப் பெற தேவையில்லை. எனவே, குறியீட்டின் அடிப்படையில் குறிப்பிட்ட கூறுகளை மட்டுமே திரும்பப் பெற, குறியீட்டு ஆபரேட்டர் மற்றும் at() செயல்பாடுகள் பயன்படுத்தப்படுகின்றன.
தொடரியல்:
திசையன் [ குறியீட்டு_நிலை ]C++ இல், எந்த தரவு கட்டமைப்பிற்கும் அட்டவணைப்படுத்தல் 0 இலிருந்து தொடங்குகிறது. உறுப்பு இல்லை என்றால், அது காலியாகத் திரும்பும் (பிழை இல்லை அல்லது எச்சரிக்கை எழுப்பப்படவில்லை).
ஐந்து உருப்படிகளுடன் 'தயாரிப்புகள்' திசையன் கருதுகின்றனர். குறியீட்டு நிலையைப் பயன்படுத்தி அனைத்து உறுப்புகளையும் ஒவ்வொன்றாக அணுகவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - 5 சரங்களைக் கொண்ட தயாரிப்புகள்
திசையன் < லேசான கயிறு > தயாரிப்புகள் { 'வழலை' , 'ஷாம்பு' , 'எண்ணெய்' , 'பழங்கள்' , 'காய்கறிகள்' } ;
//தயாரிப்புகளிலிருந்து கூறுகளை அணுகுதல்
கூட் << 'முதல் உறுப்பு:' << தயாரிப்புகள் [ 0 ] << endl ;
கூட் << 'இரண்டாம் உறுப்பு:' << தயாரிப்புகள் [ 1 ] << endl ;
கூட் << 'மூன்றாவது உறுப்பு:' << தயாரிப்புகள் [ 2 ] << endl ;
கூட் << 'நான்காவது உறுப்பு:' << தயாரிப்புகள் [ 3 ] << endl ;
கூட் << 'ஐந்தாவது உறுப்பு:' << தயாரிப்புகள் [ 4 ] << endl ;
// 9வது உறுப்பை அணுக முயற்சிக்கவும்
கூட் << 'ஒன்பதாவது உறுப்பு:' << தயாரிப்புகள் [ 8 ] << endl ;
}
வெளியீடு:
குறியீட்டு 8 இல் எந்த உறுப்பும் இல்லை. எனவே, காலியானது திரும்பும்.
2. At() செயல்பாட்டைப் பயன்படுத்துதல்
At() என்பது ஒரு உறுப்பினர் செயல்பாடாகும், இது முந்தைய பயன்பாட்டு வழக்கைப் போலவே உள்ளது, ஆனால் அது வரம்பிற்கு வெளியே உள்ள அட்டவணையை வழங்கும்போது 'std::out_of_range' விதிவிலக்கை வழங்கும்.
தொடரியல்:
திசையன். மணிக்கு ( குறியீட்டு_நிலை )இந்தச் செயல்பாட்டிற்கு நாம் குறியீட்டு நிலையை அனுப்ப வேண்டும்.
ஐந்து உருப்படிகளுடன் 'தயாரிப்புகள்' திசையன் கருதுகின்றனர். குறியீட்டு நிலையைப் பயன்படுத்தி அனைத்து உறுப்புகளையும் ஒவ்வொன்றாக அணுகி, 9 வது நிலையில் இருக்கும் உறுப்பை அணுக முயற்சிக்கவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - 5 சரங்களைக் கொண்ட தயாரிப்புகள்
திசையன் < லேசான கயிறு > தயாரிப்புகள் { 'வழலை' , 'ஷாம்பு' , 'எண்ணெய்' , 'பழங்கள்' , 'காய்கறிகள்' } ;
//தயாரிப்புகளிலிருந்து கூறுகளை அணுகுதல்
கூட் << 'முதல் உறுப்பு:' << தயாரிப்புகள். மணிக்கு ( 0 ) << endl ;
கூட் << 'இரண்டாம் உறுப்பு:' << தயாரிப்புகள். மணிக்கு ( 1 ) << endl ;
கூட் << 'மூன்றாவது உறுப்பு:' << தயாரிப்புகள். மணிக்கு ( 2 ) << endl ;
கூட் << 'நான்காவது உறுப்பு:' << தயாரிப்புகள். மணிக்கு ( 3 ) << endl ;
கூட் << 'ஐந்தாவது உறுப்பு:' << தயாரிப்புகள். மணிக்கு ( 4 ) << endl ;
//வெக்டரில் இல்லாத உறுப்புகளை அணுகுதல்
கூட் << 'ஒன்பதாவது உறுப்பு:' << தயாரிப்புகள். மணிக்கு ( 8 ) << endl ;
}
வெளியீடு:
9வது உறுப்பை அணுகுவதில் பிழை ஏற்பட்டது:
ஒரு நிகழ்வை எறிந்த பிறகு அழைக்கப்படும் 'std::out_of_range'என்ன ( ) : திசையன் :: _M_range_சரிபார்ப்பு : __n ( எது 8 ) >= இது - > அளவு ( ) ( எது 5 )
வெக்டரில் ஒரு உறுப்பைப் புதுப்பிக்கவும்
1. [] ஆபரேட்டரைப் பயன்படுத்துதல்
குறியீட்டு நிலையைப் பயன்படுத்தி, வெக்டரில் உள்ள உறுப்பைப் புதுப்பிக்கலாம். புதுப்பிக்கப்பட வேண்டிய உறுப்பின் குறியீட்டு நிலையை [] ஆபரேட்டர் எடுக்கிறார். இந்த ஆபரேட்டருக்கு புதிய உறுப்பு ஒதுக்கப்படும்.
தொடரியல்:
திசையன் [ குறியீட்டு_நிலை ] = உறுப்புஐந்து மதிப்புகளைக் கொண்ட “ஸ்டூடண்ட்_மார்க்ஸ்” வெக்டரைக் கவனியுங்கள். குறியீடுகள் 1 மற்றும் 3 இல் உள்ள உறுப்புகளைப் புதுப்பிக்கவும்.
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// திசையன் - மாணவர்_மதிப்பெண்களை உருவாக்கவும்
திசையன் < முழு எண்ணாக > மாணவர்_மதிப்பெண்கள் { 98 , 78 , 90 , 67 , 89 } ;
கூட் << 'தற்போதைய மதிப்பெண்கள்:' << endl ;
க்கான ( முழு எண்ணாக itr : மாணவர்_மதிப்பெண்கள் )
கூட் << itr << endl ;
// இன்டெக்ஸ்-3 இல் உள்ள உறுப்பை 100 உடன் புதுப்பிக்கவும்
மாணவர்_மதிப்பெண்கள் [ 3 ] = 100 ;
// இன்டெக்ஸ்-1ல் உறுப்பை 60 உடன் புதுப்பிக்கவும்
மாணவர்_மதிப்பெண்கள் [ 1 ] = 60 ;
கூட் << 'இறுதி மதிப்பெண்கள்:' << endl ;
க்கான ( முழு எண்ணாக itr : மாணவர்_மதிப்பெண்கள் )
கூட் << itr << endl ;
}
வெளியீடு:
இறுதி திசையன் 1 மற்றும் 3 குறியீடுகளில் புதுப்பிப்பு கூறுகளை வைத்திருப்பதை நாம் காணலாம்.
2. At() செயல்பாட்டைப் பயன்படுத்துதல்
குறியீட்டு ஆபரேட்டரைப் போலவே, at() என்பது ஒரு உறுப்பினர் செயல்பாடாகும், இது மறு செய்கையில் உள்ள குறியீட்டின் அடிப்படையில் மதிப்பைப் புதுப்பிக்கிறது. இந்தச் செயல்பாட்டிற்குள் குறிப்பிடப்பட்டுள்ள குறியீடு இல்லை என்றால், 'std::out_of_range' விதிவிலக்கு எறியப்படும்.
திசையன். மணிக்கு ( குறியீட்டு_நிலை ) = உறுப்புஐந்து உருப்படிகளுடன் 'தயாரிப்புகள்' திசையன் கருதுகின்றனர். வெக்டரில் உள்ள அனைத்து உறுப்புகளையும் மற்ற உறுப்புகளுடன் புதுப்பிக்கவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - 5 சரங்களைக் கொண்ட தயாரிப்புகள்
திசையன் < லேசான கயிறு > தயாரிப்புகள் { 'வழலை' , 'ஷாம்பு' , 'எண்ணெய்' , 'பழங்கள்' , 'காய்கறிகள்' } ;
கூட் << 'தற்போதுள்ள தயாரிப்புகள்:' << endl ;
க்கான ( சரம் itr : தயாரிப்புகள் )
கூட் << itr << endl ;
//எல்லா சரங்களையும் புதுப்பிக்கிறது
தயாரிப்புகள். மணிக்கு ( 0 ) = 'கேக்' ;
தயாரிப்புகள். மணிக்கு ( 1 ) = 'சாக்லேட்' ;
தயாரிப்புகள். மணிக்கு ( 2 ) = 'பழங்கள்' ;
தயாரிப்புகள். மணிக்கு ( 3 ) = 'வெங்காயம்' ;
தயாரிப்புகள். மணிக்கு ( 4 ) = 'மென் பானங்கள்' ;
கூட் << ' \n இறுதி தயாரிப்புகள்: ' << endl ;
க்கான ( சரம் itr : தயாரிப்புகள் )
கூட் << itr << endl ;
}
வெளியீடு:
வெக்டரில் இருந்து ஒரு குறிப்பிட்ட உறுப்பை அகற்றவும்
C++ இல், தி std::vector::erase() ஒரு வெக்டரில் இருந்து ஒரு குறிப்பிட்ட உறுப்பு / தனிமங்களின் வரம்புகளை அகற்ற செயல்பாடு பயன்படுத்தப்படுகிறது. மறு செய்கையின் நிலைகளின் அடிப்படையில் உறுப்புகள் அகற்றப்படுகின்றன.
தொடரியல்:
திசையன். அழிக்க ( மீண்டும் செய்பவர் நிலை )வெக்டரில் இருந்து குறிப்பிட்ட உறுப்பை அகற்றுவதற்கான தொடரியலைப் பார்ப்போம். அகற்றப்பட வேண்டிய வெக்டரில் இருக்கும் தனிமத்தின் நிலையைப் பெற ஆரம்பம்() அல்லது முடிவு() செயல்பாடுகளைப் பயன்படுத்தலாம்.
ஐந்து உருப்படிகளுடன் 'தயாரிப்புகள்' திசையன் கருதுகின்றனர்.
- தொடக்க() ஐடிரேட்டரைக் குறிப்பிடுவதன் மூலம் மூன்றாவது உறுப்பை அகற்றவும். தொடங்கு() என்பது திசையிலுள்ள முதல் உறுப்பைக் குறிக்கிறது. இந்தச் செயல்பாட்டில் இரண்டைச் சேர்த்தால், அது மூன்றாவது உறுப்பைக் குறிக்கிறது.
- இறுதி() ஐடிரேட்டரைக் குறிப்பிடுவதன் மூலம் கடைசி உறுப்பை அகற்றவும். எண்ட்() என்பது வெக்டரின் கடைசி உறுப்பைக் குறிக்கிறது.
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - 5 சரங்களைக் கொண்ட தயாரிப்புகள்
திசையன் < லேசான கயிறு > தயாரிப்புகள் { 'வழலை' , 'ஷாம்பு' , 'எண்ணெய்' , 'பழங்கள்' , 'காய்கறிகள்' } ;
கூட் << 'தற்போதுள்ள தயாரிப்புகள்:' << endl ;
க்கான ( சரம் itr : தயாரிப்புகள் )
கூட் << itr << endl ;
// 3வது உறுப்பை அகற்று
தயாரிப்புகள். அழிக்க ( தயாரிப்புகள். தொடங்கும் ( ) + 2 ) ;
கூட் << ' \n 3வது உறுப்பை நீக்கிய பின்: \n ' ;
க்கான ( சரம் itr : தயாரிப்புகள் )
கூட் << itr << endl ;
// கடைசி உறுப்பை அகற்று
தயாரிப்புகள். அழிக்க ( தயாரிப்புகள். முடிவு ( ) ) ;
கூட் << ' \n கடைசி உறுப்பை நீக்கிய பின்: \n ' ;
க்கான ( சரம் itr : தயாரிப்புகள் )
கூட் << itr << endl ;
}
வெளியீடு:
இப்போது, 'பொருட்கள்' வெக்டரில் மூன்று கூறுகள் மட்டுமே உள்ளன ('சோப்பு', 'ஷாம்பு', 'பழங்கள்').
வெக்டரில் இருந்து அனைத்து கூறுகளையும் அகற்றவும்
காட்சி 1: வெக்டரில் இருந்து தனிமங்களின் வரம்பை அகற்றவும்
வரம்பில் உள்ள பல கூறுகளை அகற்ற, std::vector::erase() செயல்பாட்டைப் பயன்படுத்துவோம்.
தொடரியல்:
திசையன். அழிக்க ( முதலில் இடிரேட்டர், கடைசியாக மீண்டும் செய்பவர் )வரம்பைக் குறிப்பிட இரண்டு மறு செய்கைகள் (தொடங்கு() புள்ளிகள் முதல் உறுப்பு மற்றும் முடிவு() கடைசி உறுப்பு செயல்பாடுகளுக்கான புள்ளிகள்) பயன்படுத்தப்படுகின்றன.
ஐந்து உருப்படிகளுடன் 'தயாரிப்புகள்' திசையன் கருதி, இரண்டாவது நிலையில் இருந்து அனைத்து உறுப்புகளையும் அகற்றவும். இதை அடைய, முதல் மறு செய்கை தொடக்கம் (தயாரிப்புகள்)+1 ஆகும், இது இரண்டாவது உறுப்பைக் குறிக்கிறது மற்றும் இரண்டாவது மறு செய்கை முடிவு (தயாரிப்புகள்) ஆகும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - 5 சரங்களைக் கொண்ட தயாரிப்புகள்
திசையன் < லேசான கயிறு > தயாரிப்புகள் { 'வழலை' , 'ஷாம்பு' , 'எண்ணெய்' , 'பழங்கள்' , 'காய்கறிகள்' } ;
கூட் << 'தற்போதுள்ள தயாரிப்புகள்:' << endl ;
க்கான ( சரம் itr : தயாரிப்புகள் )
கூட் << itr << endl ;
// அனைத்து கூறுகளையும் இரண்டாவது நிலையில் இருந்து அகற்றவும்
தயாரிப்புகள். அழிக்க ( தொடங்கும் ( தயாரிப்புகள் ) + 1 ,முடிவு ( தயாரிப்புகள் ) ) ;
கூட் << ' \n இறுதி தயாரிப்புகள்: \n ' ;
க்கான ( சரம் itr : தயாரிப்புகள் )
கூட் << itr << endl ;
}
வெளியீடு:
இப்போது, 'பொருட்கள்' வெக்டரில் ஒரே ஒரு தனிமம் ('சோப்பு') உள்ளது.
காட்சி 2: வெக்டரில் இருந்து அனைத்து கூறுகளையும் அகற்றவும்
பயன்படுத்துவோம் std::vector::clear() வெக்டரில் இருந்து அனைத்து உறுப்புகளையும் அகற்றும் செயல்பாடு.
தொடரியல்:
திசையன். தெளிவானது ( )இந்தச் செயல்பாட்டிற்கு எந்த அளவுருக்களும் அனுப்பப்படவில்லை.
முதல் சூழ்நிலையில் பயன்படுத்தப்பட்ட அதே திசையன் மற்றும் தெளிவான() செயல்பாட்டைப் பயன்படுத்தி அனைத்து உறுப்புகளையும் அகற்றவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - 5 சரங்களைக் கொண்ட தயாரிப்புகள்
திசையன் < லேசான கயிறு > தயாரிப்புகள் { 'வழலை' , 'ஷாம்பு' , 'எண்ணெய்' , 'பழங்கள்' , 'காய்கறிகள்' } ;
கூட் << 'தற்போதுள்ள தயாரிப்புகள்:' << endl ;
க்கான ( சரம் itr : தயாரிப்புகள் )
கூட் << itr << endl ;
// தயாரிப்புகளிலிருந்து அனைத்து கூறுகளையும் அகற்றவும்
தயாரிப்புகள். தெளிவானது ( ) ;
கூட் << ' \n இறுதி தயாரிப்புகள்: \n ' ;
க்கான ( சரம் itr : தயாரிப்புகள் )
கூட் << itr << endl ;
}
வெளியீடு:
'தயாரிப்புகள்' வெக்டரில் கூறுகள் இல்லை என்பதை நாம் காணலாம்.
திசையன்களின் ஒன்றியம்
std::set_union() செயல்பாட்டைப் பயன்படுத்தி வெக்டர்களில் UNION செயல்பாட்டைச் செய்ய முடியும். யூனியன் நகல் கூறுகளைப் புறக்கணிப்பதன் மூலம் வெக்டார்களில் இருந்து தனித்துவமான கூறுகளை வழங்குகிறது. இந்தச் செயல்பாட்டிற்கு நாம் இரண்டு இரேட்டர்களையும் அனுப்ப வேண்டும். இதனுடன், இரண்டு மறு செய்கையாளர்களாலும் வழங்கப்பட்ட முடிவைச் சேமிக்கும் ஒரு வெளியீட்டுத் தூண்டி அனுப்பப்பட வேண்டும்.
தொடரியல்:
அமைப்பு_ஒன்றியம் ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator ரெஸ் ) ;இங்கே:
- 'முதல்1' என்பது முதல் மறு செய்கையின் (திசையன்) முதல் உறுப்பைக் குறிக்கிறது.
- 'கடைசி 1' என்பது முதல் மறு செய்கையின் (திசையன்) கடைசி உறுப்பைக் குறிக்கிறது.
- 'முதல்2' இரண்டாவது மறு செய்கையின் (திசையன்) முதல் உறுப்பைக் குறிக்கிறது.
- 'கடைசி 2' இரண்டாவது மறு செய்கையின் (திசையன்) கடைசி உறுப்பைக் குறிக்கிறது.
இரண்டு திசையன்களை உருவாக்கவும் - 'subjects1' மற்றும் 'subjects2' - வகை முழு எண்.
- இரண்டு திசையன்களை வரிசைப்படுத்து () செயல்பாட்டைப் பயன்படுத்தி மறு செய்கைகளைக் கடந்து வரிசைப்படுத்தவும்.
- ஒரு வெளியீட்டு திசையன் (இடரேட்டர்) உருவாக்கவும்.
- std::set_union() செயல்பாட்டைப் பயன்படுத்தி இந்த இரண்டு திசையன்களின் ஒன்றியத்தைக் கண்டறியவும். தொடக்கம்() ஐ முதல் செயலியாகவும், end() ஐ கடைசி செயலியாகவும் பயன்படுத்தவும்.
- செயல்பாட்டின் மூலம் திரும்பிய உறுப்புகளைக் காட்ட, வெளியீட்டு திசையனை மீண்டும் செய்யவும்.
#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - மதிப்பெண்கள்1
திசையன் < முழு எண்ணாக > மதிப்பெண்கள்1 = { 100 , 90 , 80 , 70 , 60 } ;
// வெக்டரை உருவாக்கவும் - மதிப்பெண்கள்2
திசையன் < முழு எண்ணாக > மதிப்பெண்கள்2 = { 80 , 90 , 60 , 70 , 100 } ;
// இரண்டு திசையன்களையும் வரிசைப்படுத்தவும்
வகைபடுத்து ( மதிப்பெண்கள்1. தொடங்கும் ( ) , மதிப்பெண்கள்1. முடிவு ( ) ) ;
வகைபடுத்து ( மதிப்பெண்கள்2. தொடங்கும் ( ) , மதிப்பெண்கள்2. முடிவு ( ) ) ;
திசையன் < முழு எண்ணாக > வெளியீடு திசையன் ( மதிப்பெண்கள்1. அளவு ( ) + மதிப்பெண்கள்2. அளவு ( ) ) ;
திசையன் < முழு எண்ணாக > :: மீண்டும் செய்பவர் இருக்கிறது ;
நான் = அமைப்பு_ஒன்றியம் ( மதிப்பெண்கள்1. தொடங்கும் ( ) , மதிப்பெண்கள்1. முடிவு ( ) ,
மதிப்பெண்கள்2. தொடங்கும் ( ) , மதிப்பெண்கள்2. முடிவு ( ) ,
வெளியீடு திசையன். தொடங்கும் ( ) ) ;
கூட் << ' \n மதிப்பெண்கள்1 U மதிப்பெண்கள்2: \n ' ;
க்கான ( கள் = வெளியீடு திசையன். தொடங்கும் ( ) ; கள் ! = நான் ; ++ கள் )
கூட் << * கள் << '' << ' \n ' ;
}
வெளியீடு:
இரண்டு திசையன்களிலும் ஐந்து தனித்துவமான தனிமங்கள் மட்டுமே உள்ளன (பாடங்கள்1 மற்றும் பாடங்கள்2).
திசையன்களின் குறுக்குவெட்டு
இரண்டு திசையன்களின் குறுக்குவெட்டைக் கண்டறிவது std::set_intersection() செயல்பாட்டைப் பயன்படுத்தி சாத்தியமாகும். குறுக்குவெட்டு இரண்டு திசையன்களிலும் இருக்கும் தனிமங்களை வழங்குகிறது.
தொடரியல்:
வெட்டு_செட் ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator ரெஸ் ) ;set_union() செயல்பாட்டிற்கு அனுப்பப்படும் அளவுருக்கள் இந்த set_intersection() செயல்பாட்டிற்கும் அனுப்பப்படலாம்.
இரண்டு திசையன்களை உருவாக்கவும் - 'subjects1' மற்றும் 'subjects2' - வகை முழு எண்.
- இரண்டு திசையன்களை வரிசைப்படுத்து () செயல்பாட்டைப் பயன்படுத்தி மறு செய்கைகளைக் கடந்து வரிசைப்படுத்தவும்.
- ஒரு வெளியீட்டு திசையன் (இடரேட்டர்) உருவாக்கவும்.
- std::set_intersection() செயல்பாட்டைப் பயன்படுத்தி இந்த இரண்டு திசையன்களின் குறுக்குவெட்டைக் கண்டறியவும். தொடக்கம்() ஐ முதல் செயலியாகவும், end() ஐ கடைசி செயலியாகவும் பயன்படுத்தவும்.
- செயல்பாட்டின் மூலம் திரும்பிய உறுப்புகளைக் காட்ட, வெளியீட்டு திசையனை மீண்டும் செய்யவும்.
#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - மதிப்பெண்கள்1
திசையன் < முழு எண்ணாக > மதிப்பெண்கள்1 = { 100 , 10 , 80 , 40 , 60 } ;
// வெக்டரை உருவாக்கவும் - மதிப்பெண்கள்2
திசையன் < முழு எண்ணாக > மதிப்பெண்கள்2 = { ஐம்பது , 90 , 60 , 10 , 100 } ;
// இரண்டு திசையன்களையும் வரிசைப்படுத்தவும்
வகைபடுத்து ( மதிப்பெண்கள்1. தொடங்கும் ( ) , மதிப்பெண்கள்1. முடிவு ( ) ) ;
வகைபடுத்து ( மதிப்பெண்கள்2. தொடங்கும் ( ) , மதிப்பெண்கள்2. முடிவு ( ) ) ;
திசையன் < முழு எண்ணாக > வெளியீடு திசையன் ( மதிப்பெண்கள்1. அளவு ( ) + மதிப்பெண்கள்2. அளவு ( ) ) ;
திசையன் < முழு எண்ணாக > :: மீண்டும் செய்பவர் இருக்கிறது ;
நான் = வெட்டு_செட் ( மதிப்பெண்கள்1. தொடங்கும் ( ) , மதிப்பெண்கள்1. முடிவு ( ) ,
மதிப்பெண்கள்2. தொடங்கும் ( ) , மதிப்பெண்கள்2. முடிவு ( ) ,
வெளியீடு திசையன். தொடங்கும் ( ) ) ;
கூட் << ' \n மதிப்பெண்கள்1 ∩ மதிப்பெண்கள்2: \n ' ;
க்கான ( கள் = வெளியீடு திசையன். தொடங்கும் ( ) ; கள் ! = நான் ; ++ கள் )
கூட் << * கள் << '' << ' \n ' ;
}
வெளியீடு:
இரண்டு திசையன்களிலும் மூன்று கூறுகள் மட்டுமே உள்ளன (பாடங்கள் 1 மற்றும் பாடங்கள் 2).
வெக்டார் காலியாக உள்ளதா இல்லையா என்பதைச் சரிபார்க்கவும்
திசையன்களில் பணிபுரியும் முன், திசையன் காலியாக உள்ளதா இல்லையா என்பதைச் சரிபார்க்க வேண்டியது அவசியம். CRUD செயல்பாடுகள் போன்ற செயல்பாடுகளைச் செய்வதற்கு முன், வெக்டார் காலியாக உள்ளதா இல்லையா என்பதைச் சரிபார்ப்பது மென்பொருள் திட்டங்களில் ஒரு நல்ல நடைமுறையாகும்.
1. Std::vector::empty()ஐப் பயன்படுத்துதல்
திசையன் காலியாக இருந்தால் (எந்த உறுப்பும் இல்லை) இந்தச் செயல்பாடு 1ஐ வழங்கும். இல்லையெனில், 0 திரும்பும். இந்த செயல்பாட்டிற்கு எந்த அளவுருவும் அனுப்பப்படவில்லை.
2. பயன்படுத்தி வகுப்பு::வெக்டர்:: அளவு()
std::vector::size() செயல்பாடு திசையனில் உள்ள மொத்த உறுப்புகளின் எண்ணிக்கையைக் குறிக்கும் முழு எண்ணை வழங்குகிறது.
இரண்டு திசையன்களை உருவாக்கவும் - 'கல்லூரி1' மற்றும் 'கல்லூரி2'. 'கல்லூரி1' ஐந்து கூறுகளைக் கொண்டுள்ளது மற்றும் 'கல்லூரி2' காலியாக உள்ளது. இரண்டு வெக்டார்களிலும் இரண்டு செயல்பாடுகளையும் பயன்படுத்தவும் மற்றும் வெளியீட்டைச் சரிபார்க்கவும்.
#அடங்கும் <அல்காரிதம்>#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - கல்லூரி1
திசையன் < லேசான கயிறு > கல்லூரி1 = { 'கல்லூரி-ஏ' , 'கல்லூரி-பி' , 'கல்லூரி-சி' , 'கல்லூரி-டி' , 'கல்லூரி-இ' } ;
// வெக்டரை உருவாக்கவும் - கல்லூரி2
திசையன் < லேசான கயிறு > கல்லூரி2 ;
// காலியாக()
கூட் << கல்லூரி1. காலியாக ( ) << endl ;
கூட் << கல்லூரி2. காலியாக ( ) << endl ;
// அளவு ()
கூட் << கல்லூரி1. அளவு ( ) << endl ;
கூட் << கல்லூரி2. அளவு ( ) << endl ;
}
வெளியீடு:
காலி() செயல்பாடு 'கல்லூரி1'க்கு 0 மற்றும் 'கல்லூரி2'க்கு 1ஐ வழங்கும். அளவு() செயல்பாடு 'கல்லூரி1'க்கு ஐந்து மற்றும் 'கல்லூரி2'க்கு 0ஐ வழங்குகிறது.
கான்ஸ்ட்_இடரேட்டரைப் பயன்படுத்தி ஒரு வெக்டரைப் பயணிக்கவும்
செட், வெக்டர்கள் போன்ற C++ கண்டெய்னர்களில் நீங்கள் பணிபுரியும் போது, கண்டெய்னரில் இருக்கும் அனைத்து உறுப்புகளையும் மாற்றாமல் மீண்டும் மீண்டும் செய்ய முடியும். தி const_iterator இந்த சூழ்நிலையை அடையும் செயலிகளில் ஒன்றாகும். cbegin() (வெக்டரில் உள்ள முதல் உறுப்புக்கான புள்ளிகள்) மற்றும் cend() (வெக்டரில் உள்ள கடைசி உறுப்புக்கான புள்ளிகள்) ஆகியவை ஒவ்வொரு கொள்கலனாலும் வழங்கப்படும் இரண்டு செயல்பாடுகள் ஆகும், இது நிலையான மறு செய்கையை தொடக்கத்திற்கும் இறுதிக்கும் திருப்பி அனுப்ப பயன்படுகிறது. கொள்கலன். வெக்டரை மீண்டும் செய்யும் போது, இந்த இரண்டு செயல்பாடுகளையும் நாம் பயன்படுத்தலாம்.
- ஐந்து சரங்களைக் கொண்ட 'டிபார்ட்மென்ட்ஸ்' என்ற வெக்டரை உருவாக்குவோம்.
- ஒரு const_iterator - ctr வகை
ஐ அறிவிக்கவும். - 'For' லூப்பைப் பயன்படுத்தி முந்தைய இட்டேட்டரைப் பயன்படுத்தி டிபார்ட்மென்ட்களுக்கு மேல் திரும்பவும் அதைக் காண்பிக்கவும்.
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// திசையன் - துறைகளை உருவாக்கவும்
திசையன் < லேசான கயிறு > துறைகள் = { 'விற்பனை' , 'சேவை' ,
'HR' , 'IT' , 'மற்றவைகள்' } ;
திசையன் < லேசான கயிறு > :: const_iterator ctr ;
// const_iterator - ctr ஐப் பயன்படுத்தி டிபார்ட்மென்ட்களை மீண்டும் செய்யவும்.
க்கான ( ctr = துறைகள். cbegin ( ) ; ctr ! = துறைகள். ஒரு சில ( ) ; ctr ++ ) {
கூட் << * ctr << endl ;
}
}
வெளியீடு:
ரிவர்ஸ்_இடரேட்டரைப் பயன்படுத்தி ஒரு திசையனைப் பயணிக்கவும்
தி தலைகீழ்_இடிரேட்டர் இது const_iterator ஐப் போன்ற ஒரு மறுசெலுத்தியாகும், ஆனால் அது உறுப்புகளை தலைகீழாகத் தருகிறது. rbegin() (வெக்டரில் உள்ள கடைசி உறுப்புக்கான புள்ளிகள்) மற்றும் ரெண்ட்() (வெக்டரில் முதல் உறுப்புக்கான புள்ளிகள்) ஆகியவை ஒவ்வொரு கொள்கலனாலும் வழங்கப்படும் இரண்டு செயல்பாடுகள் ஆகும், இது நிலையான மறு செய்கையை முடிவு மற்றும் தொடக்கத்திற்குத் திருப்பப் பயன்படுகிறது. கொள்கலன்.
- ஐந்து சரங்களைக் கொண்ட 'டிபார்ட்மென்ட்ஸ்' என்ற வெக்டரை உருவாக்குவோம்.
- ஒரு reverse_iterator - rtr வகை
ஐ அறிவிக்கவும். - 'For' லூப்பைப் பயன்படுத்தி முந்தைய இட்டேட்டரைப் பயன்படுத்தி டிபார்ட்மென்ட்களுக்கு மேல் திரும்பவும் அதைக் காண்பிக்கவும்.
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// திசையன் - துறைகளை உருவாக்கவும்
திசையன் < லேசான கயிறு > துறைகள் = { 'விற்பனை' , 'சேவை' ,
'HR' , 'ஐ.டி' , 'மற்றவைகள்' } ;
திசையன் < லேசான கயிறு > :: தலைகீழ்_இடிரேட்டர் rtr ;
// reverse_iterator - rtr ஐப் பயன்படுத்தி டிபார்ட்மென்ட்களுக்கு மேல் மீண்டும் செய்யவும்.
க்கான ( rtr = துறைகள். rbegin ( ) ; rtr ! = துறைகள். செய்கிறது ( ) ; rtr ++ ) {
கூட் << * rtr << endl ;
}
}
வெளியீடு:
உறுப்புகளை வெக்டருக்குள் தள்ளுங்கள்
ஒரு திசையனுக்குள் உறுப்புகளைத் தள்ளுவது அல்லது சேர்ப்பது என்பது ஒரு வழிச் செருகல் ஆகும். திசையன் :: push_back() செயல்பாடு.
தொடரியல்:
திசையன். பின் தள்ளு ( உறுப்பு )ஒரு அளவுருவாக வெக்டருக்குள் தள்ளப்படும் ஒரு உறுப்பு தேவைப்படுகிறது.
ஐந்து சரங்களைக் கொண்ட 'டிபார்ட்மெண்ட்ஸ்' என்ற வெற்று வெக்டரை உருவாக்கி, புஷ்_பேக்() செயல்பாட்டைப் பயன்படுத்தி இரண்டு சரங்களை ஒன்றன் பின் ஒன்றாக தள்ளுவோம்.
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// திசையன் - துறைகளை துவக்கவும்
திசையன் < லேசான கயிறு > துறைகள் ;
கூட் << 'உண்மையான துறைகள்:' << endl ;
க்கான ( ஆட்டோ itr = துறைகள். தொடங்கும் ( ) ; itr ! = துறைகள். முடிவு ( ) ; ++ itr )
கூட் << * itr << endl ;
// 'விற்பனை' தள்ளு
துறைகள். பின் தள்ளு ( 'விற்பனை' ) ;
// அதை தள்ளு'
துறைகள். பின் தள்ளு ( 'ஐ.டி' ) ;
கூட் << ' \n இறுதி துறைகள்:' << endl ;
க்கான ( ஆட்டோ itr = துறைகள். தொடங்கும் ( ) ; itr ! = துறைகள். முடிவு ( ) ; ++ itr )
கூட் << * itr << endl ;
}
வெளியீடு:
முதலில், நாங்கள் 'விற்பனையை' தள்ளுகிறோம். அதன் பிறகு, 'IT' திசையன் மீது தள்ளப்படுகிறது. இப்போது, 'துறைகள்' திசையன் இரண்டு கூறுகளை வைத்திருக்கிறது.
வெக்டரில் இருந்து கூறுகளை பாப் செய்யவும்
வெக்டரில் இருக்கும் கடைசி உருப்படியை நீக்க விரும்பினால், இதைப் பயன்படுத்தவும் திசையன் ::pop_back() செயல்பாடு சிறந்த அணுகுமுறை. இது வெக்டரில் இருக்கும் கடைசி உறுப்பை நீக்குகிறது.
தொடரியல்:
திசையன். பாப்_பேக் ( )இந்த செயல்பாட்டிற்கு எந்த அளவுருவும் தேவையில்லை. வெற்று வெக்டரில் இருந்து கடைசி உறுப்பை நீக்க முயற்சித்தால் அது வரையறுக்கப்படாத நடத்தையைக் காட்டுகிறது.
ஐந்து சரங்களுடன் 'துறைகள்' என்ற வெற்று வெக்டரை உருவாக்கி, முந்தைய செயல்பாட்டைப் பயன்படுத்தி கடைசி உறுப்பை நீக்குவோம். இரண்டு சந்தர்ப்பங்களிலும் வெக்டரைக் காட்டவும்.
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// திசையன் - துறைகளை துவக்கவும்
திசையன் < லேசான கயிறு > துறைகள் = { 'விற்பனை' , 'ஐ.டி' , 'சேவை' , 'சந்தைப்படுத்தல்' , 'HR' } ;
கூட் << 'உண்மையான துறைகள்:' << endl ;
க்கான ( ஆட்டோ itr = துறைகள். தொடங்கும் ( ) ; itr ! = துறைகள். முடிவு ( ) ; ++ itr )
கூட் << * itr << endl ;
// கடைசி உறுப்பை நீக்கவும்
துறைகள். பாப்_பேக் ( ) ;
கூட் << ' \n இறுதி துறைகள்:' << endl ;
க்கான ( ஆட்டோ itr = துறைகள். தொடங்கும் ( ) ; itr ! = துறைகள். முடிவு ( ) ; ++ itr )
கூட் << * itr << endl ;
}
வெளியீடு:
'HR' என்பது 'துறைகள்' வெக்டரில் இருக்கும் கடைசி உறுப்பு ஆகும். எனவே, இது வெக்டரில் இருந்து அகற்றப்பட்டு இறுதி திசையன் 'விற்பனை', 'ஐடி', 'சேவை' மற்றும் 'மார்க்கெட்டிங்' ஆகியவற்றைக் கொண்டுள்ளது.
திசையன்களை மாற்றவும்
தி திசையன் :: swap() C++ STL இல் உள்ள செயல்பாடு இரண்டு திசையன்களில் இருக்கும் அனைத்து உறுப்புகளையும் மாற்ற பயன்படுகிறது.
தொடரியல்:
முதல்_வெக்டர். இடமாற்று ( இரண்டாவது_வெக்டார் )இது திசையன்களின் அளவைக் கருத்தில் கொள்ளாது, ஆனால் திசையன்கள் ஒரே வகையாக இருக்க வேண்டும் (வெக்டார் வகைகள் வேறுபட்டால் பிழை வீசப்படும்).
இரண்டு வெக்டார்களை உருவாக்குவோம் - 'பழங்கள்' மற்றும் 'காய்கறிகள்' - வெவ்வேறு அளவுகளுடன் சரம் வகை. அவை ஒவ்வொன்றையும் மாற்றி இரண்டு சந்தர்ப்பங்களிலும் வெக்டார்களைக் காட்டவும்.
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// திசையன் - பழங்களை துவக்கவும்
திசையன் < லேசான கயிறு > பழங்கள் = { 'ஆப்பிள்' , 'மாங்கனி' } ;
கூட் << 'உண்மையான பழங்கள்:' << endl ;
க்கான ( ஆட்டோ itr = பழங்கள். தொடங்கும் ( ) ; itr ! = பழங்கள். முடிவு ( ) ; ++ itr )
கூட் << * itr << endl ;
// வெக்டரை துவக்கவும் - காய்கறிகள்
திசையன் < லேசான கயிறு > காய்கறிகள் = { 'உருளைக்கிழங்கு' , 'தக்காளி' , 'கத்தரி' } ;
கூட் << ' \n உண்மையான காய்கறிகள்:' << endl ;
க்கான ( ஆட்டோ itr = காய்கறிகள். தொடங்கும் ( ) ; itr ! = காய்கறிகள். முடிவு ( ) ; ++ itr )
கூட் << * itr << endl ;
// இரண்டு திசையன்களிலும் உள்ள உறுப்புகளை மாற்றவும்
பழங்கள். இடமாற்று ( காய்கறிகள் ) ;
கூட் << ' \n மாற்றிய பின் பழங்கள்:' << endl ;
க்கான ( ஆட்டோ itr = பழங்கள். தொடங்கும் ( ) ; itr ! = பழங்கள். முடிவு ( ) ; ++ itr )
கூட் << * itr << endl ;
கூட் << ' \n மாற்றிய பின் காய்கறிகள்:' << endl ;
க்கான ( ஆட்டோ itr = காய்கறிகள். தொடங்கும் ( ) ; itr ! = காய்கறிகள். முடிவு ( ) ; ++ itr )
கூட் << * itr << endl ;
}
வெளியீடு:
முன்னதாக, 'பழங்கள்' திசையன் இரண்டு கூறுகளையும் 'காய்கறிகள்' திசையன் மூன்று கூறுகளையும் கொண்டுள்ளது. மாற்றிய பின், 'பழங்கள்' திசையன் மூன்று கூறுகளையும் 'காய்கறிகள்' திசையன் இரண்டு கூறுகளையும் வைத்திருக்கிறது.
வெக்டரிலிருந்து முதல் உறுப்பைப் பெறவும்
சில சந்தர்ப்பங்களில், திசையன் இருந்து முதல் உறுப்பு மட்டுமே திரும்ப வேண்டும். C++ STL இல் உள்ள திசையன் ::front() செயல்பாடு வெக்டரில் இருந்து முதல் உறுப்பை மட்டுமே பெறுகிறது.
தொடரியல்:
திசையன். முன் ( )இந்த செயல்பாடு எந்த அளவுருவையும் எடுக்காது. திசையன் காலியாக இருந்தால், ஒரு பிழை வீசப்படுகிறது.
இரண்டு திசையன்களை உருவாக்குவோம் - 'பழங்கள்' மற்றும் 'காய்கறிகள்' - சரம் வகை மற்றும் இரண்டு திசையன்களிலிருந்து தனித்தனியாக முதல் உறுப்பைப் பெற முயற்சிப்போம்.
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - 2 கூறுகள் கொண்ட பழங்கள்
திசையன் < லேசான கயிறு > பழங்கள் = { 'ஆப்பிள்' , 'மாங்கனி' } ;
// முதல் உறுப்பு திரும்ப
கூட் << பழங்கள். முன் ( ) << endl ;
// வெக்டரை துவக்கவும் - காய்கறிகள்
திசையன் < லேசான கயிறு > காய்கறிகள் ;
// முதல் உறுப்பு திரும்ப முயற்சிக்கவும்
கூட் << காய்கறிகள். முன் ( ) ;
}
வெளியீடு:
'ஆப்பிள்' என்பது 'பழங்கள்' வெக்டரில் இருக்கும் முதல் உறுப்பு ஆகும். எனவே, அது திரும்பப் பெறப்படுகிறது. ஆனால் 'காய்கறிகள்' வெக்டார் காலியாக இருப்பதால் முதல் உறுப்பைப் பெற முயலும்போது ஒரு பிழை ஏற்படுகிறது.
வெக்டரிலிருந்து கடைசி உறுப்பைப் பெறவும்
C++ STL இல் உள்ள திசையன்::end() செயல்பாடு திசையனிலிருந்து கடைசி உறுப்பை மட்டுமே பெறுகிறது.
தொடரியல்:
திசையன். மீண்டும் ( )இந்த செயல்பாடு எந்த அளவுருவையும் எடுக்காது. திசையன் காலியாக இருந்தால், ஒரு பிழை வீசப்படும்.
இரண்டு திசையன்களை உருவாக்குவோம் - 'பழங்கள்' மற்றும் 'காய்கறிகள்' - சரம் வகை மற்றும் இரண்டு திசையன்களிலிருந்து தனித்தனியாக கடைசி உறுப்பைப் பெற முயற்சிப்போம்.
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - 2 கூறுகள் கொண்ட பழங்கள்
திசையன் < லேசான கயிறு > பழங்கள் = { 'ஆப்பிள்' , 'மாங்கனி' } ;
// கடைசி உறுப்பை எடுக்கவும்
கூட் << பழங்கள். மீண்டும் ( ) << endl ;
// வெக்டரை துவக்கவும் - காய்கறிகள்
திசையன் < லேசான கயிறு > காய்கறிகள் ;
// கடைசி உறுப்பைப் பெற முயற்சிக்கவும்
கூட் << காய்கறிகள். மீண்டும் ( ) ;
}
வெளியீடு:
'மாம்பழம்' என்பது 'பழங்கள்' வெக்டரில் இருக்கும் கடைசி உறுப்பு ஆகும். எனவே, அது திரும்பப் பெறப்படுகிறது. ஆனால் 'காய்கறிகள்' வெக்டரில் இருந்து கடைசி உறுப்பைப் பெற முயற்சிக்கும் போது அது காலியாக இருப்பதால் ஒரு பிழை ஏற்படுகிறது.
ஒரு வெக்டருக்கு புதிய மதிப்புகளை ஒதுக்கவும்
சில சூழ்நிலைகளில், நீங்கள் அனைத்து மதிப்புகளையும் புதிய மதிப்புடன் புதுப்பிக்க விரும்பினால் அல்லது அதே மதிப்புகளுடன் ஒரு திசையன் உருவாக்க விரும்பினால், திசையன் :: assign() செயல்பாட்டைப் பயன்படுத்துவது சிறந்த அணுகுமுறையாகும். இந்த செயல்பாட்டைப் பயன்படுத்தி, நாம்:
- அனைத்து ஒத்த உறுப்புகளுடன் திசையன் உருவாக்கவும்
- அதே உறுப்புடன் இருக்கும் திசையனை மாற்றவும்
தொடரியல்:
திசையன். ஒதுக்க ( அளவு, மதிப்பு )இந்த செயல்பாட்டிற்கு இரண்டு அளவுருக்கள் தேவை.
இங்கே:
- ஒதுக்கப்பட வேண்டிய உறுப்புகளின் எண்ணிக்கையை அளவு குறிப்பிடுகிறது.
- மதிப்பானது ஒதுக்கப்பட வேண்டிய உறுப்பைக் குறிப்பிடுகிறது.
ஐந்து மதிப்புகளுடன் 'marks1' என்ற பெயருடைய ஒரு திசையனை உருவாக்கி, இந்த திசையனை நான்கு கூறுகளுடன் புதுப்பிப்போம், அதாவது புதுப்பிக்கப்பட்ட திசையனில் உள்ள அனைத்து கூறுகளும் 20 க்கு சமமாக இருக்கும்.
#அடங்கும் <அல்காரிதம்>#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - மதிப்பெண்கள்1
திசையன் < முழு எண்ணாக > மதிப்பெண்கள்1 = { 100 , 90 , 80 , 70 , 60 } ;
கூட் << 'உண்மையான திசையன்:' << endl ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < மதிப்பெண்கள்1. அளவு ( ) ; நான் ++ )
கூட் << மதிப்பெண்கள்1 [ நான் ] << endl ;
மதிப்பெண்கள்1. ஒதுக்க ( 4 , இருபது ) ;
கூட் << ' \n புதுப்பிக்கப்பட்ட திசையன்:' << endl ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < மதிப்பெண்கள்1. அளவு ( ) ; நான் ++ )
கூட் << மதிப்பெண்கள்1 [ நான் ] << endl ;
}
வெளியீடு:
முன்னதாக, திசையன் ஐந்து வெவ்வேறு கூறுகளைக் கொண்டுள்ளது. இப்போது, இது நான்கு கூறுகளை மட்டுமே கொண்டுள்ளது மற்றும் அனைத்தும் 20 க்கு சமம்.
Emplace()ஐப் பயன்படுத்தி வெக்டரை நீட்டவும்
ஒரு வெக்டரில் எந்த நிலையிலும் புதிய உறுப்புகள் மாறும் வகையில் செருகப்படுகின்றன என்பதை நாம் ஏற்கனவே அறிவோம். திசையன் :: emplace() செயல்பாட்டைப் பயன்படுத்தி இது சாத்தியமாகும். இந்தச் செயல்பாட்டால் ஏற்றுக்கொள்ளப்பட்ட தொடரியல் மற்றும் அளவுருக்களை விரைவாகப் பார்ப்போம்.
தொடரியல்:
திசையன். இடம் ( const_iterator நிலை, உறுப்பு )இந்த செயல்பாட்டிற்கு இரண்டு கட்டாய அளவுருக்கள் அனுப்பப்படுகின்றன.
இங்கே:
- முதல் அளவுரு நிலையை எடுக்கிறது, இதன் மூலம் நாம் எந்த நிலையிலும் உறுப்பைச் செருக முடியும். ஆரம்பம்() அல்லது முடிவு() இடிரேட்டர் செயல்பாட்டைப் பயன்படுத்தி நாம் நிலையைப் பெறலாம்.
- இரண்டாவது அளவுரு என்பது வெக்டரில் செருகப்பட வேண்டிய உறுப்பு ஆகும்.
இரண்டு கூறுகளைக் கொண்ட 'ரசாயனங்கள்' வெக்டரைக் கவனியுங்கள்.
- முதல் நிலையில் 'மாங்கனீசு' ஐச் செருகவும் - தொடங்கவும் (ரசாயனங்கள்)
- கடைசி நிலையில் 'செம்பு' - இறுதியில் (ரசாயனங்கள்) செருகவும்
- மூன்றாவது இடத்தில் ‘கந்தகத்தை’ செருகவும் - ஆரம்பம்(ரசாயனங்கள்)+2
#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - இரசாயனங்கள்
திசையன் < லேசான கயிறு > இரசாயனங்கள் = { 'ஆக்ஸிஜன்' , 'CO' } ;
கூட் << 'உண்மையான இரசாயனங்கள்:' << endl ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < இரசாயனங்கள். அளவு ( ) ; நான் ++ )
கூட் << இரசாயனங்கள் [ நான் ] << endl ;
// முதல் நிலையில் உறுப்பைச் செருகவும்
இரசாயனங்கள். இடம் ( தொடங்கும் ( இரசாயனங்கள் ) , 'மாங்கனீஸ்' ) ;
// கடைசி நிலையில் உறுப்பைச் செருகவும்
இரசாயனங்கள். இடம் ( முடிவு ( இரசாயனங்கள் ) , 'செம்பு' ) ;
// மூன்றாவது இடத்தில் உறுப்பைச் செருகவும்
இரசாயனங்கள். இடம் ( தொடங்கும் ( இரசாயனங்கள் ) + 2 , 'கந்தகம்' ) ;
கூட் << ' \n இறுதி இரசாயனங்கள்:' << endl ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < இரசாயனங்கள். அளவு ( ) ; நான் ++ )
கூட் << இரசாயனங்கள் [ நான் ] << endl ;
}
வெளியீடு:
இப்போது, இறுதி திசையன் ஐந்து கூறுகளை வைத்திருக்கிறது (பின்வரும் ஸ்கிரீன்ஷாட்டில் கொடுக்கப்பட்டுள்ளது).
Emplace_Back()ஐப் பயன்படுத்தி வெக்டரை நீட்டவும்
ஒரு உறுப்பு இணைக்கப்படலாம் (வெக்டரின் முடிவில் சேர்ப்பது) இதைப் பயன்படுத்தி செய்யலாம் திசையன் ::emplace_back() செயல்பாடு.
தொடரியல்:
திசையன். emplace_back ( உறுப்பு )வெக்டருடன் இணைக்கப்பட வேண்டிய உறுப்பை அளவுருவாக அனுப்புவது கட்டாயமாகும்.
emplace_back() செயல்பாட்டைப் பயன்படுத்தி ஒன்றன் பின் ஒன்றாக இரண்டு கூறுகளைச் சேர்ப்போம்.
#அடங்கும் <அல்காரிதம்>#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - இரசாயனங்கள்
திசையன் < லேசான கயிறு > இரசாயனங்கள் = { 'ஆக்ஸிஜன்' , 'CO' } ;
கூட் << 'உண்மையான இரசாயனங்கள்:' << endl ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < இரசாயனங்கள். அளவு ( ) ; நான் ++ )
கூட் << இரசாயனங்கள் [ நான் ] << endl ;
// வெக்டரின் முடிவில் மாங்கனீஸைச் செருகவும்
இரசாயனங்கள். emplace_back ( 'மாங்கனீஸ்' ) ;
// வெக்டரின் முடிவில் மாங்கனீஸைச் செருகவும்
இரசாயனங்கள். emplace_back ( 'செம்பு' ) ;
கூட் << ' \n இறுதி இரசாயனங்கள்:' << endl ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < இரசாயனங்கள். அளவு ( ) ; நான் ++ )
கூட் << இரசாயனங்கள் [ நான் ] << endl ;
}
வெளியீடு:
இப்போது, இறுதி திசையன் 'மாங்கனீசு' மற்றும் 'தாமிரம்' ஆகியவற்றைச் சேர்த்த பிறகு நான்கு கூறுகளைக் கொண்டுள்ளது.
வெக்டரின் அதிகபட்ச உறுப்பு
- சில கூறுகளுடன் ஒரு திசையன் உருவாக்கவும்.
- வெக்டரில் இருக்கும் அதிகபட்ச உறுப்பைக் கண்டறிய, *max_element() செயல்பாட்டைப் பயன்படுத்தவும், இது இரண்டு மறு செய்கைகளை வாதங்களாக ஏற்றுக்கொள்கிறது. இந்த இரண்டு அளவுருக்கள் வரம்பாக செயல்படுகின்றன மற்றும் அதிகபட்ச உறுப்பு வழங்கப்பட்ட வரம்பிற்குள் திரும்பும். தொடக்க நிலை ஆரம்பம் () மற்றும் கடைசி நிலை முடிவு ().
ஐந்து முழு எண் வகை மதிப்புகளைக் கொண்ட 'item_costs' என்ற வெக்டரைக் கருத்தில் கொள்வோம் மற்றும் அதிகபட்ச உறுப்பைத் தருவோம்.
##
#அடங்கும் <அல்காரிதம்>
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - item_costs
திசையன் < முழு எண்ணாக > பொருள்_செலவுகள் = { 8900 , 5677 , 200 , 1000 , 2300 } ;
கூட் << 'பொருட்களின் விலை: \n ' ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < பொருள்_செலவுகள். அளவு ( ) ; நான் ++ )
கூட் << பொருள்_செலவுகள் [ நான் ] << endl ;
// மேலே உள்ள வெக்டரில் இருந்து அதிகபட்ச உறுப்பைத் திருப்பி அனுப்பவும் - item_costs
கூட் << ' \n அதிகபட்ச செலவு: ' << * அதிகபட்ச_உறுப்பு ( தொடங்கும் ( பொருள்_செலவுகள் ) ,முடிவு ( பொருள்_செலவுகள் ) ) ;
}
வெளியீடு:
இங்கே, 'item_costs' வெக்டரில் உள்ள அனைத்து உறுப்புகளிலும் அதிகபட்ச உறுப்பு 8900 ஆகும்.
ஒரு திசையன் குறைந்தபட்ச உறுப்பு
- சில கூறுகளுடன் ஒரு திசையன் உருவாக்கவும்.
- வெக்டரில் இருக்கும் குறைந்தபட்ச உறுப்பைக் கண்டுபிடிக்க, *min_element() செயல்பாட்டைப் பயன்படுத்தவும், இது இரண்டு மறு செய்கைகளை வாதங்களாக ஏற்றுக்கொள்கிறது. இந்த இரண்டு அளவுருக்கள் வரம்பாகச் செயல்படுகின்றன மற்றும் வழங்கப்பட்ட வரம்பிற்குள் குறைந்தபட்ச உறுப்பு (மற்ற எல்லா உறுப்புகளையும் விட குறைவாக) திரும்பும். தொடக்க நிலை ஆரம்பம் () மற்றும் கடைசி நிலை முடிவு ().
அதிகபட்ச உறுப்பைக் கண்டறிய உருவாக்கப்பட்ட அதே வெக்டரைப் பயன்படுத்தவும் மற்றும் *min_element() செயல்பாட்டைப் பயன்படுத்தி குறைந்தபட்ச உறுப்பைக் கண்டறியவும்.
##
#அடங்கும் <அல்காரிதம்>
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - item_costs
திசையன் < முழு எண்ணாக > பொருள்_செலவுகள் = { 8900 , 5677 , 200 , 1000 , 2300 } ;
கூட் << 'பொருட்களின் விலை: \n ' ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < பொருள்_செலவுகள். அளவு ( ) ; நான் ++ )
கூட் << பொருள்_செலவுகள் [ நான் ] << endl ;
// மேலே உள்ள வெக்டரில் இருந்து குறைந்தபட்ச உறுப்பைத் திருப்பி விடுங்கள் - item_costs
கூட் << ' \n குறைந்தபட்ச செலவு: ' << * சிறிய_உறுப்பு ( தொடங்கும் ( பொருள்_செலவுகள் ) ,முடிவு ( பொருள்_செலவுகள் ) ) ;
}
வெளியீடு:
இங்கே, 200 என்பது 'item_costs' வெக்டரில் உள்ள அனைத்து உறுப்புகளிலும் குறைந்தபட்ச உறுப்பு ஆகும்.
ஒரு வெக்டரில் உள்ள தனிமங்களின் கூட்டுத்தொகை
வெக்டரில் இருக்கும் அனைத்து தனிமங்களின் கூட்டுத்தொகையை வழங்க, தி திரட்டு() C++ STL இல் செயல்பாடு பயன்படுத்தப்படுகிறது. இது மூன்று அளவுருக்களை ஏற்றுக்கொள்கிறது. முதல் அளவுரு, வரம்பில் உள்ள தொடக்க உறுப்பைக் குறிக்கும் முதல் குறியீட்டை எடுத்துக்கொள்கிறது (தொடக்க() செயலியைக் குறிப்பிடவும்) மற்றும் இரண்டாவது அளவுரு வரம்பில் உள்ள இறுதி உறுப்பைக் குறிக்கும் கடைசி குறியீட்டை எடுக்கிறது (முடிவு() மறு செய்கையைக் குறிப்பிடவும்) . கடைசியாக, நாம் தொகையின் ஆரம்ப மதிப்பை அனுப்ப வேண்டும் (எங்கள் விஷயத்தில், அது 0 ஆகும்).
குவிக்க ( முதல்_இண்டெக்ஸ், கடைசி_இண்டெக்ஸ், ஆரம்ப_வால் ) ;ஐந்து முழு எண் வகை உறுப்புகளுடன் 'item_costs' என்ற வெக்டரை உருவாக்கி, தொகையைக் கணக்கிடவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - item_costs
திசையன் < முழு எண்ணாக > பொருள்_செலவுகள் = { 8900 , 5677 , 200 , 1000 , 2300 } ;
கூட் << 'பொருட்களின் விலை: \n ' ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < பொருள்_செலவுகள். அளவு ( ) ; நான் ++ )
கூட் << பொருள்_செலவுகள் [ நான் ] << endl ;
// மேலே உள்ள வெக்டரில் உள்ள அனைத்து உறுப்புகளின் கூட்டுத்தொகை - item_costs
கூட் << ' \n மொத்த செலவு: ' << குவிக்க ( தொடங்கும் ( பொருள்_செலவுகள் ) ,முடிவு ( பொருள்_செலவுகள் ) , 0 ) ;
}
வெளியீடு:
8900, 5677, 200, 1000, 2300 ஆகியவற்றின் கூட்டுத்தொகை 18077 ஆகும்.
இரண்டு திசையன்களின் உறுப்பு வாரியான பெருக்கல்
- வகை எண்களுடன் இரண்டு திசையன்களை உருவாக்கவும் மற்றும் இரண்டு திசையன்கள் ஒரே அளவில் இருக்க வேண்டும் (முதல் திசையனில் உள்ள தனிமங்களின் மொத்த எண்ணிக்கை = இரண்டாவது திசையனில் உள்ள உறுப்புகளின் மொத்த எண்ணிக்கை).
- புதிய வெக்டரை அறிவித்து, பயன்படுத்தவும் வளையத்திற்கு , ஒவ்வொரு மறு செய்கையிலும் இரண்டு உறுப்புகளில் பெருக்கல் செயல்பாட்டைச் செய்து, புஷ்_பேக்() செயல்பாட்டைப் பயன்படுத்தி உருவாக்கப்பட்ட வெக்டரில் மதிப்பைச் சேமிக்கவும். க்கான ( முழு எண்ணாக itr = 0 ; நான் < முதல்_வெக். அளவு ( ) ; itr ++ )
- விளைந்த திசையன்களில் இருக்கும் தனிமங்களை மீண்டும் செய்வதன் மூலம் காட்டவும்.
{
முடிவு_வெக்டர். பின் தள்ளு ( முதல்_வெக் [ itr ] * நொடி_விஷயம் [ itr ] ) ;
}
ஐந்து முழு எண் வகை உறுப்புகளுடன் 'item_costs' என்ற வெக்டரை உருவாக்கி, தொகையைக் கணக்கிடவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// இரண்டு திசையன்களை உருவாக்கவும் - பொருட்கள்1 மற்றும் தயாரிப்புகள்2 ஒவ்வொன்றும் 5 கூறுகளைக் கொண்டவை
திசையன் < முழு எண்ணாக > தயாரிப்புகள்1 = { 10 , இருபது , 30 , 40 , ஐம்பது } ;
திசையன் < முழு எண்ணாக > தயாரிப்புகள்2 = { ஐம்பது , 40 , 30 , 70 , 60 } ;
திசையன் < முழு எண்ணாக > முடிவு_தயாரிப்புகள் ;
// உறுப்பு வாரியாக பெருக்கலைச் செய்யவும்
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < தயாரிப்புகள்1. அளவு ( ) ; நான் ++ ) {
முடிவு_தயாரிப்புகள். பின் தள்ளு ( தயாரிப்புகள்1 [ நான் ] * தயாரிப்புகள்2 [ நான் ] ) ;
}
// விளைவாக வெக்டரைக் காட்டு
கூட் << 'வெக்டார் பெருக்கல்: \n ' ;
க்கான ( முழு எண்ணாக ரெஸ் : முடிவு_தயாரிப்புகள் )
கூட் << ரெஸ் << endl ;
}
வெளியீடு:
மறு செய்கை - 1 : 10 * ஐம்பது => 500மறு செய்கை - 2 : இருபது * 40 => 800
மறு செய்கை - 3 : 30 * 30 => 900
மறு செய்கை - 4 : 40 * 70 => 2800
மறு செய்கை - 5 : ஐம்பது * 60 => 3000
இரண்டு திசையன்களின் புள்ளி தயாரிப்பு
C++ திசையன்களின் விஷயத்தில், புள்ளி தயாரிப்பு என்பது 'வெக்டார்களின் இரண்டு வரிசைகளின் தொடர்புடைய உள்ளீடுகளின் தயாரிப்புகளின் கூட்டுத்தொகை' என வரையறுக்கப்படுகிறது.
தொடரியல்:
உள் தயாரிப்பு ( Vector1 முதலில், Vector1 கடைசி, Vector2 முதலில், Initial_Val )டாட் தயாரிப்பை திரும்பப் பெற inner_product() செயல்பாட்டைப் பயன்படுத்தவும். இந்த செயல்பாடு நான்கு தேவையான அளவுருக்களை எடுக்கும்.
இங்கே:
- முதல் அளவுரு என்பது முதல் திசையனின் தொடக்கத்தைக் குறிக்கும் ஒரு மறுசெயல் கருவியைக் குறிக்கிறது (தொடக்க() செயல்பாட்டைப் பயன்படுத்தி குறிப்பிடவும்).
- இரண்டாவது அளவுரு, முதல் திசையனின் முடிவைக் குறிக்கும் ஒரு மறு செய்கையைக் குறிக்கிறது (முடிவு() செயல்பாட்டைப் பயன்படுத்தி குறிப்பிடவும்).
- மூன்றாவது அளவுரு இரண்டாவது திசையனின் தொடக்கத்தைக் குறிக்கும் ஒரு மறுசெலுத்தியைக் குறிக்கிறது (தொடக்க() செயல்பாட்டைப் பயன்படுத்தி குறிப்பிடவும்).
- தொடக்க மதிப்பை கடைசி அளவுருவாக அனுப்ப வேண்டும், இது புள்ளி உற்பத்தியின் திரட்சிக்கான முழு எண்ணாகும்.
இரண்டு திசையன்களின் பெருக்கத்திற்காக உருவாக்கப்பட்ட அதே நிரலைப் பயன்படுத்தவும் மற்றும் இரண்டு திசையன்களின் புள்ளிப் பெருக்கத்தைக் கண்டறிய innsr_product() செயல்பாட்டைப் பயன்படுத்தவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// இரண்டு திசையன்களை உருவாக்கவும் - பொருட்கள்1 மற்றும் தயாரிப்புகள்2 ஒவ்வொன்றும் 5 கூறுகளைக் கொண்டவை
திசையன் < முழு எண்ணாக > தயாரிப்புகள்1 = { 10 , இருபது , 30 , 40 , ஐம்பது } ;
திசையன் < முழு எண்ணாக > தயாரிப்புகள்2 = { ஐம்பது , 40 , 30 , 70 , 60 } ;
// விளைவாக வெக்டரைக் காட்டு
கூட் << 'தயாரிப்புகள்1 மற்றும் தயாரிப்புகள்2 இன் புள்ளி தயாரிப்பு:' ;
கூட் << உள் தயாரிப்பு ( தொடங்கும் ( தயாரிப்புகள்1 ) ,முடிவு ( தயாரிப்புகள்1 ) , தொடங்கு ( தயாரிப்புகள்2 ) , 0 ) ;
}
வெளியீடு:
( 10 * ஐம்பது ) + ( இருபது * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( ஐம்பது * 60 )=> 500 + 800 + 900 + 2800 + 3000
=> 8000
ஒரு தொகுப்பை வெக்டராக மாற்றவும்
ஒரு தொகுப்பில் எழுப்பப்படும் அனைத்து தனிமங்களையும் ஒரு திசையனாக மாற்றுவதன் மூலம் ஒரு தொகுப்பை திசையனாக மாற்ற பல வழிகள் உள்ளன. std ::copy() செயல்பாட்டைப் பயன்படுத்துவது சிறந்த மற்றும் எளிமையான வழி.
தொடரியல்
வகுப்பு :: நகல் ( முதலில் sourceIterator, sourceIterator கடைசி, destinationIterator முதலில் )பயன்படுத்த வகுப்பு::நகல்() ஒரு தொகுப்பிலிருந்து உறுப்புகளை வெக்டரில் செருகும் செயல்பாடு. இது மூன்று அளவுருக்களை எடுக்கும்.
இங்கே:
- முதல் அளவுருவானது, இட்டேட்டரில் உள்ள முதல் உறுப்பைக் குறிக்கும் மூலச் செயலியைக் குறிக்கிறது. இங்கே, set என்பது தொடக்க() செயல்பாட்டைப் பயன்படுத்தி குறிப்பிடப்படும் மூல இட்டேட்டர் ஆகும்.
- இதேபோல், இரண்டாவது அளவுரு கடைசி உறுப்பு (இறுதி() செயல்பாடு) ஐ குறிக்கிறது.
- மூன்றாவது அளவுருவானது, திரும்பும் கருவியில் உள்ள முதல் உறுப்பை (தொடக்க() செயல்பாட்டைப் பயன்படுத்தி குறிப்பிடப்படும்) குறிக்கும் டெஸ்டினேஷன் இட்டேட்டரைக் குறிக்கிறது.
ஐந்து மாணவர்களுடன் ஒரு தொகுப்பை உருவாக்கி, முந்தைய செயல்பாட்டைப் பயன்படுத்தி அனைத்து உறுப்புகளையும் ஒரு வெக்டரில் நகலெடுக்கலாம்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// ஒரு தொகுப்பை உருவாக்கவும் - 5 கூறுகளைக் கொண்ட மாணவர்கள்
அமைக்கப்பட்டது < லேசான கயிறு > மாணவர்கள் = { 'ஸ்ரவன்' , 'பாபி' , 'மது' , 'மேகனா' , 'லாவண்யா' } ;
கூட் << 'அமைவு: \n ' ;
க்கான ( சரம் i : மாணவர்கள் )
கூட் << நான் << endl ;
// வெக்டரை உருவாக்கவும் - student_vcof அளவு தொகுப்பின் அளவிற்கு சமம்
திசையன் < லேசான கயிறு > மாணவர்_விசி ( மாணவர்கள். அளவு ( ) ) ;
// ஒரு தொகுப்பிலிருந்து கூறுகளை - மாணவர்களை வெக்டரில் செருகவும் - student_vc.
நகல் ( மாணவர்கள். தொடங்கும் ( ) , மாணவர்கள். முடிவு ( ) , student_vc. தொடங்கும் ( ) ) ;
கூட் << ' \n திசையன்: \n ' ;
க்கான ( சரம் i : மாணவர்_விசி )
கூட் << நான் << endl ;
}
வெளியீடு:
இப்போது, 'மாணவர்கள்' தொகுப்பில் உள்ள அனைத்து கூறுகளும் 'students_vc' திசையனுக்குள் நகலெடுக்கப்படுகின்றன.
நகல் கூறுகளை அகற்றவும்
- முதலில், வெக்டரில் உள்ள உறுப்புகளை வரிசைப்படுத்த வேண்டும், இதன் மூலம் அனைத்து நகல் கூறுகளும் ஒன்றோடொன்று இணைந்திருக்கும் std::sort() செயல்பாடு. வகுப்பு :: வகைபடுத்து ( முதலில் திசையன், கடைசி திசையன் ) ;
- std::unique() செயல்பாட்டைப் பயன்படுத்தவும், இதனால் நகல் கூறுகள் தேர்ந்தெடுக்கப்படும். அதே நேரத்தில், std::unique() செயல்பாட்டின் மூலம் திருப்பியளிக்கப்படும் நகல்களை அகற்ற, erase() செயல்பாட்டைப் பயன்படுத்தவும். இறுதி வெக்டரில் உறுப்புகளின் வரிசை மாறலாம். திசையன். அழிக்க ( வகுப்பு :: தனித்துவமான ( முதலில் திசையன், கடைசி திசையன் ) , கடைசி திசையன் ) )
10 உறுப்புகளுடன் 'மாணவர்கள்' திசையனை உருவாக்கவும் மற்றும் நகல்களை அகற்றுவதன் மூலம் திசையன் திரும்பவும்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// ஒரு வெக்டரை உருவாக்கவும் - 10 கூறுகளைக் கொண்ட மாணவர்கள்
திசையன் < லேசான கயிறு > மாணவர்கள் = { 'ஸ்ரவன்' , 'பாபி' , 'மது' , 'மேகனா' , 'லாவண்யா' ,
'ஸ்ரவன்' , 'பாபி' , 'மது' , 'மேகனா' , 'லாவண்யா' } ;
கூட் << 'மாணவர்கள்: \n ' ;
க்கான ( சரம் i : மாணவர்கள் )
கூட் << நான் << '' ;
// மாணவர்கள் வெக்டரில் உள்ள அனைத்து கூறுகளையும் வரிசைப்படுத்தவும்.
வகைபடுத்து ( தொடங்கும் ( மாணவர்கள் ) , முடிவு ( மாணவர்கள் ) ) ;
// அழித்தல்() செயல்பாட்டுடன் நகல்களை அகற்ற தனித்துவமான() செயல்பாட்டைப் பயன்படுத்தவும்
மாணவர்கள். அழிக்க ( தனித்துவமான ( தொடங்கும் ( மாணவர்கள் ) , முடிவு ( மாணவர்கள் ) ) , முடிவு ( மாணவர்கள் ) ) ;
கூட் << ' \n \n தனித்துவமான மாணவர்கள்: \n ' ;
க்கான ( ஆட்டோ itr = cbegin ( மாணவர்கள் ) ; itr ! = ஒரு சில ( மாணவர்கள் ) ; ++ itr ) {
கூட் << * itr << '' ;
}
}
வெளியீடு:
இப்போது, அனைத்து உறுப்புகளும் வெக்டரில் தனித்துவமானது.
வெக்டரை ஒரு தொகுப்பாக மாற்றவும்
செட் நகல் கூறுகளை அனுமதிக்காது. நகல்களைக் கொண்ட தொகுப்பில் திசையன் செருகுவதற்கு நீங்கள் தட்டச்சு செய்தால், அவை புறக்கணிக்கப்படும். தொகுப்பை வெக்டராக மாற்றிய முந்தைய சூழ்நிலையில் பயன்படுத்தப்பட்ட அதே std::copy() செயல்பாட்டைப் பயன்படுத்துகிறோம்.
இந்த சூழ்நிலையில்:
- முதல் அளவுரு, தொடக்கம்() செயல்பாட்டைப் பயன்படுத்தி குறிப்பிடப்படும் மூல மறுசெயலியாக வெக்டரை எடுத்துக்கொள்கிறது.
- இரண்டாவது அளவுரு, எண்ட்() செயல்பாட்டைப் பயன்படுத்தி குறிப்பிடப்படும் மூல மறுசெய்பவராக திசையன் எடுத்துக்கொள்கிறது.
- std::inseter() செயல்பாட்டினை அனுப்பவும், இது தொகுப்பில் உள்ள ஒரு குறிப்பிட்ட நிலையில் உறுப்புகளை தானாகவே மேலெழுத/நகல் செய்ய பயன்படும் செட் மற்றும் இட்ரேட்டரை வழங்குவதன் மூலம் செட்டின் முடிவை அளவுருக்களாகக் குறிப்பிடுகிறது.
10 முழு எண்களுடன் ஒரு வெக்டரை உருவாக்கி, உறுப்புகளை ஒரு தொகுப்பாக நகலெடுப்போம்.
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// ஒரு தொகுப்பை உருவாக்கவும் - 10 மதிப்புகளுடன் மதிப்பெண்கள்
திசையன் < முழு எண்ணாக > மதிப்பெண்கள் = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;
கூட் << 'வெக்டார்: \n ' ;
க்கான ( முழு எண்ணாக நான் : மதிப்பெண்கள் )
கூட் << நான் << '' ;
// செட் உருவாக்கு - வெக்டரின் அளவிற்கு சமமான அளவு மார்க்ஸ்_செட்
அமைக்கப்பட்டது < முழு எண்ணாக > மதிப்பெண்கள்_தொகுப்பு ;
// ஒரு தொகுப்பிலிருந்து கூறுகளை - மாணவர்களை வெக்டரில் செருகவும் - student_vc.
நகல் ( தொடங்கும் ( மதிப்பெண்கள் ) ,முடிவு ( மதிப்பெண்கள் ) , செருகி ( மதிப்பெண்கள்_செட், முடிவு ( மதிப்பெண்கள்_தொகுப்பு ) ) ) ;
கூட் << ' \n \n அமை: \n ' ;
க்கான ( முழு எண்ணாக நான் : மதிப்பெண்கள்_தொகுப்பு )
கூட் << நான் << '' ;
}
வெளியீடு:
'மார்க்ஸ்' என்ற பெயரிடப்பட்ட வெக்டருக்கு 10 மதிப்புகள் உள்ளன. 'marks_set' தொகுப்பில் அதை நகலெடுத்த பிறகு, மற்ற நான்கு கூறுகளும் நகல் எடுக்கப்பட்டதால், ஆறு கூறுகளை மட்டுமே கொண்டுள்ளது.
வெற்று சரங்களை அகற்று
வெக்டரில் இருக்கும் வெற்று சரங்களைப் பயன்படுத்துவதில்லை. வெக்டரில் இருக்கும் வெற்று சரங்களை அகற்றுவது நல்ல நடைமுறை. C++ வெக்டரில் இருந்து வெற்று சரங்களை எவ்வாறு அகற்றுவது என்று பார்ப்போம்:
- 'for' லூப்பைப் பயன்படுத்தி திசையனை மீண்டும் செய்யவும்.
- ஒவ்வொரு மறு செய்கையிலும், உறுப்பு காலியாக உள்ளதா (“”) அல்லது at() உறுப்பினர் செயல்பாட்டுடன் “==” ஆபரேட்டரைப் பயன்படுத்தவில்லையா என்பதைச் சரிபார்க்கவும்.
- std::erase() செயல்பாட்டைப் பயன்படுத்தி, முந்தைய நிலையைச் சரிபார்த்த பிறகு வெற்று சரங்களை அகற்றவும்.
- திசையன் முடியும் வரை படி2 மற்றும் படி 3 ஐ மீண்டும் செய்யவும்.
10 சரங்களைக் கொண்ட 'நிறுவனங்கள்' வெக்டரை உருவாக்குவோம். அவற்றில், ஐந்து காலியாக உள்ளன, முந்தைய அணுகுமுறையை செயல்படுத்துவதன் மூலம் அவற்றை அகற்றுவோம்.
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( ) {
திசையன் < லேசான கயிறு > நிறுவனங்கள் { 'கம்பெனி-ஏ' , '' , 'கம்பெனி-பி' ,
'' , 'கம்பெனி-சி' , '' , 'கம்பெனி-டி' , '' , '' , '' } ;
// நிறுவனங்களைப் பற்றி மீண்டும் சொல்லுங்கள்
// மற்றும் அழித்தல்() ஐப் பயன்படுத்தி வெற்று உறுப்புகளை அகற்றவும்
க்கான ( முழு எண்ணாக itr = 1 ; itr < நிறுவனங்கள். அளவு ( ) ; ++ itr ) {
என்றால் ( நிறுவனங்கள். மணிக்கு ( itr ) == '' ) {
நிறுவனங்கள். அழிக்க ( நிறுவனங்கள். தொடங்கும் ( ) + itr ) ;
-- itr ;
}
}
// வெக்டரைக் காட்டு
க்கான ( ஆட்டோ & நான் : நிறுவனங்கள் ) {
கூட் << நான் << endl ;
}
}
வெளியீடு:
இப்போது, 'நிறுவனங்கள்' வெக்டார் காலியாக இல்லாத சரங்களை வைத்திருக்கிறது.
ஒரு உரை கோப்பில் ஒரு திசையன் எழுதவும்
திசையன் குறியீடுகளைப் பயன்படுத்தி ஒரு கோப்பில் வெக்டரில் இருக்கும் அனைத்து கூறுகளையும் எவ்வாறு எழுதுவது என்று விவாதிப்போம். fstream .
- வெக்டரை துவக்கிய பின் புஷ்_பேக் செயல்பாட்டைப் பயன்படுத்தி சில கூறுகளை அதில் தள்ளவும்.
- 'fstream' நூலகத்திலிருந்து திறந்த() செயல்பாட்டைப் பயன்முறையில் பயன்படுத்தவும்.
- வெக்டரில் இருக்கும் ஒவ்வொரு உறுப்பையும் 'ஃபார்' லூப்பில் உள்ள குறியீடுகளைப் பயன்படுத்திக் கடந்து, வழங்கப்பட்ட கோப்பில் ஒவ்வொரு உறுப்பையும் எழுதவும்.
- இறுதியாக, கோப்பை மூடவும்.
C++ குறியீட்டை இயக்குவதன் மூலம் முந்தைய அணுகுமுறையை செயல்படுத்துவோம்.
##
#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// வெக்டரை உருவாக்கவும் - v_data
// மற்றும் இரண்டு கூறுகளை அதில் தள்ளுங்கள்.
திசையன் < லேசான கயிறு > v_data ;
v_data. பின் தள்ளு ( 'வரவேற்பு' ) ;
v_data. பின் தள்ளு ( 'LinuxHint க்கு' ) ;
ஸ்ட்ரீம் எஃப் ;
// கோப்பைத் திறக்கவும்
f. திறந்த ( 'written_file.txt' ,ios_base :: வெளியே ) ;
// வெக்டரின் ஒவ்வொரு உறுப்பையும் மீண்டும் செய்து, கோப்பில் ஒவ்வொன்றாக எழுதவும்.
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < v_data. அளவு ( ) ; நான் ++ )
{
f << v_data [ நான் ] << endl ;
}
// கோப்பை மூடு
f. நெருக்கமான ( ) ;
}
வெளியீடு:
'v_data' திசையன் இரண்டு கூறுகளை வைத்திருக்கிறது மற்றும் நிரல் இயக்கப்படும் பாதையில் வெக்டரில் இருக்கும் உறுப்புகளுடன் ஒரு கோப்பு உருவாக்கப்படுகிறது.
ஒரு உரை கோப்பிலிருந்து ஒரு திசையன் உருவாக்கவும்
வெக்டரில் இருக்கும் உறுப்புகளை டெக்ஸ்ட் கோப்பில் எழுதுவது எப்படி என்று கற்றுக்கொண்டோம். இங்கே, உரை கோப்பில் உள்ள உள்ளடக்கத்திலிருந்து ஒரு திசையன் உருவாக்குவோம்.
- உருவாக்கவும் ' ifstream' நாம் கோப்பிலிருந்து திசையன் உருவாக்கும் உரைக் கோப்பிலிருந்து தகவலைப் படிக்கப் பயன்படும் மாறி.
- கோப்பு உள்ளடக்கத்தைச் சேமிக்க வெற்று வெக்டரை உருவாக்கவும் மற்றும் கோப்பின் முடிவைச் சரிபார்க்க வெற்று சரம் மாறியை கொடியாகப் பயன்படுத்தவும்.
- கோப்பிலிருந்து அடுத்த வரியை அது இறுதி வரை படிக்கவும் (அடிப்படையில் 'while' loop ஐப் பயன்படுத்தவும்). புஷ்_பேக்() செயல்பாட்டைப் பயன்படுத்தி அடுத்த வரியைப் படித்து வெக்டரில் தள்ளவும்.
- கன்சோலில் வெக்டரில் இருக்கும் தனிமங்களைக் காண, வரியில் இருக்கும் வரியைத் தனித்தனியாகக் காட்டவும்.
C++ குறியீட்டை இயக்குவதன் மூலம் முந்தைய அணுகுமுறையை செயல்படுத்துவோம். பின்வரும் உள்ளடக்கத்துடன் “data.txt” கோப்பைக் கருத்தில் கொள்வோம். இங்கே, வெக்டரின் பெயர் “v_data”.
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முக்கிய ( )
{
// உரை கோப்பைத் திறக்கவும் - தரவு
ifstream கோப்பு ( 'data.txt' ) ;
// வெக்டரை உருவாக்கவும் - v_data of type - string
திசையன் < லேசான கயிறு > v_data ;
தாங் இருந்தது ;
// data.txt இலிருந்து அடுத்த வரியைப் படிக்கவும்
//அது முடிவடையும் வரை.
போது ( கோப்பு >> இருந்தது ) {
// அடுத்த வரியைப் படித்து, v_dataவில் அழுத்தவும்
v_data. பின் தள்ளு ( இருந்தது ) ;
}
// வரியில் இருக்கும் வரியை தனித்தனியாகக் காட்டவும்.
நகல் ( v_data. தொடங்கும் ( ) , v_data. முடிவு ( ) , ostream_iterator < லேசான கயிறு > ( கூட் , ' \n ' ) ) ;
}
வெளியீடு:
'v_data' ஆனது கோப்பிலிருந்து வந்த ஐந்து கூறுகளைக் கொண்டிருப்பதைக் காணலாம்.
முடிவுரை
இந்த நீண்ட கட்டுரையில், C++ நிரலாக்க மொழியில் திசையன்கள் தொடர்பான நிகழ்நேர பயன்பாடுகளில் பயன்படுத்தப்படும் சாத்தியமான அனைத்து எடுத்துக்காட்டுகளையும் நாங்கள் ஆராய்ந்தோம். ஒவ்வொரு எடுத்துக்காட்டும் தொடரியல், அளவுருக்கள் மற்றும் எடுத்துக்காட்டுடன் விளக்கப்பட்டுள்ளது. குறியீட்டைப் பற்றிய தெளிவான புரிதலைப் பெற ஒவ்வொரு குறியீட்டிலும் கருத்துகள் சேர்க்கப்படுகின்றன.