C++ Std:: வரைபடம்:: உதாரணங்களை அழிக்கவும்

'std::map' க்கு கிடைக்கும் பல செயல்பாடுகளில், 'அழித்தல்' செயல்பாடு அவற்றின் விசைகளின் அடிப்படையில் உறுப்புகளை அகற்றுவதற்கான ஒரு முக்கியமான கருவியாக உள்ளது. 'std::map' என்பது முக்கிய மதிப்பு ஜோடிகளைக் கொண்ட ஒரு ஒழுங்கமைக்கப்பட்ட துணை கொள்கலன் ஆகும். 'std::map' க்குள் உள்ள உறுப்புகளின் ஏற்பாடு, அவற்றின் விசைகளின்படி தொடர்ந்து வரிசைப்படுத்தப்பட்டு, முக்கிய மதிப்புகளின் அடிப்படையில் தேடல், செருகுதல் மற்றும் நீக்குதல் போன்ற பயனுள்ள செயல்பாடுகளை எளிதாக்குகிறது.

C++ இன் எல்லைக்குள், 'std::map::erase' செயல்பாடு 'std::map' வகுப்பின் உறுப்பினர் செயல்பாடாக செயல்படுகிறது, இது வரைபடத்தில் இருந்து குறிப்பிட்ட கூறுகளை அகற்ற உதவுகிறது. இது பல்வேறு வடிவங்களில் வருகிறது, எந்த உறுப்புகளை அழிக்க வேண்டும் என்பதைக் குறிப்பிடுவதில் நெகிழ்வுத்தன்மையை வழங்குகிறது. இந்தக் கட்டுரையில், 'std::map::erase' இன் விவரங்களை ஆராய்வோம், அதன் பல்துறைத்திறனை விளக்குவதற்கு பல எடுத்துக்காட்டுகளை வழங்குவோம்.

எடுத்துக்காட்டு 1: விசை மூலம் அழித்தல்

'std::map' இல் உள்ள முக்கிய மூலம் உறுப்புகளை அழிக்கும் திறன் C++ ஸ்டாண்டர்ட் டெம்ப்ளேட் லைப்ரரி மூலம் வழங்கப்படும் அடிப்படை அம்சமாகும். ஒரு நிரலில் உள்ள விசை-மதிப்பு ஜோடிகளை நீங்கள் நிர்வகிக்க மற்றும் கையாள வேண்டிய போது இந்த செயல்பாடு பொதுவாகப் பயன்படுத்தப்படுகிறது, மேலும் இது அவற்றின் விசைகளின் அடிப்படையில் குறிப்பிட்ட கூறுகளை அகற்ற வசதியான வழியை வழங்குகிறது. வரைபடத்தை உருவாக்க, 'std::map' ஐ எவ்வாறு பயன்படுத்துவது, விசை மூலம் ஒரு உறுப்பை அழிப்பது, பின்னர் மாற்றியமைக்கப்பட்ட வரைபடத்தைக் காண்பிப்பது எப்படி என்பதை விளக்குவதற்கு ஒரு உதாரணத்தை உருவாக்குவோம்.

இந்த எடுத்துக்காட்டில், உள்ளீடு/வெளியீட்டு செயல்பாடுகள் மற்றும் 'std::map' கொள்கலனை முறையே பயன்படுத்துவதற்கு தேவையான மற்றும்

வரைபடத்தின் விளைவான நிலையைக் காண்பிக்க, 'மைமேப்' இல் உள்ள ஒவ்வொரு விசை-மதிப்பு ஜோடியின் வழியாகச் செயல்படும் 'ஃபார்' லூப்பைப் பயன்படுத்துகிறோம். ஒவ்வொரு விசை-மதிப்பு ஜோடியையும் கன்சோலில் அச்சிட, லூப்பில் உள்ள “std::cout” பொருளைப் பயன்படுத்துகிறோம். இறுதியாக, 'ரிட்டர்ன் 0' அறிக்கையானது 'முக்கிய' செயல்பாட்டை முடிக்கிறது, இது எங்கள் நிரலின் வெற்றிகரமான செயல்பாட்டைக் குறிக்கிறது.

கீ 2 ('நீலம்') கொண்ட உறுப்பு அழிக்கப்பட்ட பிறகு, 'std::map' இல் மீதமுள்ள விசை-மதிப்பு ஜோடிகளை வெளியீடு காட்டுகிறது, இதன் விளைவாக '1: சிவப்பு' மற்றும் '3: பச்சை' வெளியீடு கிடைக்கும்.

உதாரணம் 2: இட்டரேட்டர் மூலம் அழித்தல்

C++ இல், இட்டேட்டர்கள் என்பது ஒரு கொள்கலனுக்குள் உள்ள உறுப்புகளின் வழிசெலுத்தலை எளிதாக்கும் பொருள்கள், உறுப்புகளை அணுக, மாற்ற அல்லது அகற்றுவதற்கான வழிமுறையை வழங்குகிறது. உறுப்புகளை அகற்ற, 'std::map::erase' செயல்பாட்டை மறு செய்கைகளுடன் பயன்படுத்தலாம்.

இங்கே ஒரு உதாரணம்:

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

நிபந்தனைத் தொகுதியில், 'அழித்தல்' செயல்பாட்டைப் பயன்படுத்தி 'அது' மறு செய்கையால் சுட்டிக்காட்டப்பட்ட உறுப்பை அழிக்கிறோம். இறுதியாக, மாற்றியமைக்கப்பட்ட 'fruitMap' இல் மீதமுள்ள கூறுகளை 'for' லூப்பைப் பயன்படுத்தி மீண்டும் செய்கிறோம்.

இறுதி வெளியீடு அழிக்கப்பட்ட பிறகு மாற்றியமைக்கப்பட்ட 'fruitMap' உள்ளடக்கங்களைக் காட்டுகிறது.

எடுத்துக்காட்டு 3: வரம்பை அழித்தல்

C++ இல் உள்ள “std::map” கண்டெய்னர் குறிப்பிட்ட வரம்பிற்குள் உள்ள உறுப்புகளை அழிக்க வசதியான முறையை வழங்குகிறது. 'அழித்தல்' செயல்பாடு, நீக்கப்பட வேண்டிய வரம்பின் தொடக்கத்தையும் முடிவையும் குறிக்கும் இட்டேட்டர்களின் அடிப்படையில் வரைபடத்திலிருந்து உறுப்புகளை அகற்ற உங்களை அனுமதிக்கிறது.

இப்போது, ​​ஒரு எடுத்துக்காட்டுடன் 'std::map' ஐப் பயன்படுத்தி வரம்பை அழிக்கும் கருத்தை ஆராய்வோம்:

நிரல் 'std::map' என பெயரிடப்பட்ட 'newMap' என அறிவிப்பதன் மூலம் தொடங்குகிறது, இது முழு எண் விசைகளை தொடர்புடைய சர மதிப்புகளுடன் இணைக்கிறது. அதன் பிறகு, சதுர அடைப்புக்குறி ஆபரேட்டரைப் பயன்படுத்தி முக்கிய மதிப்பு ஜோடிகளுடன் வரைபடத்தை விரிவுபடுத்துகிறோம். உதாரணமாக, (1, 'குதிரை'), (2, 'சிங்கம்'), (3, 'புலி'), மற்றும் (4, 'பூனை') ஆகியவற்றின் முக்கிய மதிப்பு ஜோடிகளை 'புதிய வரைபடத்திற்கு' ஒதுக்குகிறோம்.

அடுத்த குறிப்பிடத்தக்க செயல்பாடானது, வரைபடத்தில் உள்ள உறுப்புகளை அழிக்க இட்டேட்டர்களைப் பயன்படுத்துவதாகும். அழித்தல் செயல்பாடு “newMap.lower_bound(2)” மற்றும் “newMap.upper_bound(3)” வாதங்களுடன் பயன்படுத்தப்படுகிறது. இது வரம்பில் (2, 3) விழும் விசைகளைக் கொண்ட உறுப்புகளை அழிக்கிறது. வேறு வார்த்தைகளில் கூறுவதானால், இது வரைபடத்திலிருந்து 'சிங்கம்' மற்றும் 'புலி' உள்ளீடுகளை நீக்குகிறது. இந்த செயல்பாட்டிற்குப் பிறகு, வரைபடத்தில் 'குதிரை' மற்றும் 'பூனை' ஆகியவற்றுடன் தொடர்புடைய 1 மற்றும் 4 விசைகள் கொண்ட கூறுகள் மட்டுமே உள்ளன.

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

இதன் விளைவாக, வெளியீடு பின்வருவனவற்றைக் காட்டுகிறது:

எடுத்துக்காட்டு 4: முன்னறிவிப்பின் அடிப்படையில் அழித்தல்

ஒரு முன்கணிப்பின் அடிப்படையில் அழிப்பது என்பது ஒரு குறிப்பிட்ட நிபந்தனை அல்லது அளவுகோலின் அடிப்படையில் ஒரு கொள்கலன் போன்ற தரவு கட்டமைப்பிலிருந்து கூறுகளை அகற்றுவதைக் குறிக்கிறது. 'std::map::erase' என்பது நிபந்தனையுடன் உறுப்புகளை அகற்ற ஒரு முன்னறிவிப்பு செயல்பாட்டுடன் பயன்படுத்தப்படலாம். பின்வரும் உதாரணத்தைக் கருத்தில் கொள்வோம்:

தேவையான தலைப்பு கோப்புகளைச் சேர்ப்பதன் மூலம் நிரல் தொடங்குகிறது. 'myMap' எனப்படும் 'std::map' அறிவிக்கப்பட்டு 'முக்கிய' செயல்பாட்டில் துவக்கப்படும். இது மாதங்களின் பெயர்கள் மற்றும் அவற்றின் எண் மதிப்புகளைக் குறிக்கும் முக்கிய-மதிப்பு ஜோடிகளைக் கொண்டுள்ளது. பின்னர், ஒரு 'லாம்ப்டா' செயல்பாடு (முன்கணிப்பு) வரையறுக்கப்படுகிறது. இந்த 'லாம்ப்டா' செயல்பாடு 'std::remove_if' அல்காரிதத்திற்கான முன்னறிவிப்பாக செயல்படுகிறது. வரைபட உறுப்புடன் தொடர்புடைய சர மதிப்பின் நீளம் ஐந்து எழுத்துகளுக்குக் குறைவாக உள்ளதா என்பதை இது சரிபார்க்கிறது.

'std::remove_if' அல்காரிதம் 'std::map' இன் 'அழித்தல்' செயல்பாட்டுடன் இணைந்து பயன்படுத்தப்படுகிறது. இந்த கலவையானது முன்னறிவிப்பின் செல்லுபடியின் அடிப்படையில் வரைபடத்திலிருந்து உறுப்புகளை நீக்குகிறது.

நிரலை இயக்கிய பிறகு, ஐந்திற்கும் குறைவான விசைகளைக் கொண்ட கூறுகள் அசல் வரைபடத்திலிருந்து அகற்றப்பட்டு, 'std::map' ஐப் பயன்படுத்தி ஒரு முன்னறிவிப்பின் அடிப்படையில் அழிக்கப்படுவதைக் காட்டுகிறது.

முடிவுரை

முடிவில், 'std::map::erase' செயல்பாடு என்பது 'std::map' இலிருந்து உறுப்புகளை அகற்ற C++ இல் உள்ள பல்துறை கருவியாகும். விசை, செயலி, வரம்பு மூலம் அழித்தாலும் சரி அல்லது முன்னறிவிப்பின் அடிப்படையில் இருந்தாலும் சரி, “std::map::erase” செயல்பாடு நெகிழ்வுத்தன்மையையும் பயன்பாட்டின் எளிமையையும் வழங்குகிறது. இந்தச் செயல்பாட்டை மாஸ்டரிங் செய்வதன் மூலம், C++ டெவலப்பர்கள் 'std::map' கண்டெய்னர்களுக்குள் தரவை திறமையாக நிர்வகிக்கவும் கையாளவும் முடியும், இதனால் அவர்களின் குறியீட்டை வலுவாகவும் எளிதாகவும் பராமரிக்க முடியும்.