בין הפעולות הרבות הזמינות עבור 'std::map', הפונקציה 'מחק' בולטת ככלי חיוני להסרת האלמנטים על סמך המפתחות שלהם. 'std::map' הוא מיכל אסוציאטיבי מאורגן המורכב מזוגות מפתח-ערך. סידור האלמנטים בתוך 'std::map' ממוין באופן עקבי לפי המפתחות שלהם, מה שמקל על הפעולות האפקטיביות כגון חיפוש, הוספה ומחיקה על סמך ערכי מפתח.
בתחום C++, הפונקציה 'std::map::erase' משמשת כפונקציית חבר של המחלקה 'std::map', ומאפשרת ביטול של אלמנטים ספציפיים מהמפה. זה מגיע בצורות שונות, ומספק גמישות בקביעה אילו אלמנטים למחוק. במאמר זה, נעמיק בפרטים של 'std::map::erase', ונספק מספר דוגמאות כדי להמחיש את הרבגוניות שלו.
דוגמה 1: מחיקה באמצעות מפתח
היכולת למחוק את האלמנטים על ידי מפתח ב-'std::map' היא תכונה בסיסית המסופקת על ידי C++ Standard Template Library. פעולה זו משמשת בדרך כלל כאשר אתה צריך לנהל ולתפעל את צמדי המפתח-ערך בתוכנית, והיא מספקת דרך נוחה להסיר את האלמנטים הספציפיים על סמך המפתחות שלהם. ניצור דוגמה כדי להדגים כיצד להשתמש ב-'std::map' כדי ליצור מפה, למחוק אלמנט לפי מקש ולאחר מכן להציג את המפה ששונתה.
#include
#include <מפה>
int main ( ) {
std::map < int, std::string > myMap;
myMap [ 1 ] = 'אָדוֹם' ;
myMap [ 2 ] = 'כְּחוֹל' ;
myMap [ 3 ] = 'ירוק' ;
myMap.erase ( 2 ) ;
ל ( const auto & זוג: myMap ) {
std::cout << זוג.ראשון << ': ' << pair.second << std::endl;
}
לַחֲזוֹר 0 ;
}
בדוגמה זו, אנו מתחילים בכלול את הספריות הסטנדרטיות של C++ הנחוצות כגון
כדי להציג את המצב המתקבל של המפה, אנו משתמשים בלולאת 'עבור' החוזרת דרך כל זוג מפתח-ערך בתוך 'המפה שלי'. אנו משתמשים באובייקט 'std::cout' בתוך הלולאה כדי להדפיס כל זוג מפתח-ערך לקונסולה. לבסוף, ההצהרה 'החזר 0' מסיימת את הפונקציה 'העיקרית' המאותת על ביצוע מוצלח של התוכנית שלנו.
הפלט מציג את צמדי המפתח-ערך הנותרים ב-'std::map' לאחר מחיקת האלמנט עם מפתח 2 ('כחול'), מה שמוביל לפלט '1: אדום' ו-'3: ירוק'.
דוגמה 2: מחיקה על ידי איטרטור
ב-C++, איטרטורים הם אובייקטים המקלים על הניווט של אלמנטים בתוך מיכל, ומציעים אמצעי לגשת, לשנות או להסיר את האלמנטים. ניתן להשתמש בפונקציה 'std::map::erase' גם עם איטרטורים כדי להסיר את האלמנטים.
הנה דוגמה:
#include#include <מפה>
int main ( ) {
std::map < int, std::string > fruitFolder;
fruitFolder [ 1 ] = 'מנגו' ;
fruitFolder [ 2 ] = 'תפוז' ;
fruitFolder [ 3 ] = 'אננס' ;
fruitFolder [ 4 ] = 'ענבים' ;
auto it = fruitMap.find ( 2 ) ;
אם ( זה ! = fruitMap.end ( ) ) {
fruitMap.erase ( זה ) ;
}
ל ( const auto & זוג: fruitMap ) {
std::cout << זוג.ראשון << ': ' << pair.second << std::endl;
}
לַחֲזוֹר 0 ;
}
קוד C++ שסופק מתחיל בהכרזה על 'std::map' בשם 'fruitMap' כדי לאחסן את צמדי המפתח-ערך, לשייך את המספרים השלמים לשמות הפירות המתאימים. אנו מאכלסים את המפה בערכים עבור ארבעה פירות שונים: 'מנגו', 'תפוז', 'אננס' ו'ענבים'. לאחר מכן, אנו משתמשים בפונקציה 'מצא' כדי להשיג איטרטור (it) שמצביע על האלמנט עם ערך המפתח של 2 בתוך ה'fruitMap'. לאחר מכן, אנו בודקים אם האיטרטור אינו שווה ל-'end()' כדי לוודא שהאלמנט עם המפתח שצוין קיים במפה.
בבלוק המותנה, אנו מוחקים את האלמנט שאליו מצביע האיטרטור 'it' באמצעות הפונקציה 'מחק'. לבסוף, אנו חוזרים על הרכיבים הנותרים ב-'fruitMap' שהשתנה באמצעות לולאת 'for'.
הפלט הסופי מציג את תוכן ה-'fruitMap' שהשתנה לאחר המחיקה.
דוגמה 3: מחיקת טווח
המיכל 'std::map' ב-C++ מספק שיטה נוחה למחיקת האלמנטים בטווח מוגדר. הפונקציה 'מחק' מאפשרת להסיר את האלמנטים מהמפה על סמך איטרטורים המייצגים את ההתחלה והסוף של הטווח שיש למחוק.
כעת, בואו נחקור את הרעיון של מחיקת טווח באמצעות 'std::map' עם דוגמה:
#include#include <מפה>
int main ( ) {
std::map < int, std::string > newMap;
מפה חדשה [ 1 ] = 'סוּס' ;
מפה חדשה [ 2 ] = 'אַריֵה' ;
מפה חדשה [ 3 ] = 'נָמֵר' ;
מפה חדשה [ 4 ] = 'חתול' ;
newMap.erase ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
ל ( const auto & זוג: מפה חדשה ) {
std::cout << זוג.ראשון << ': ' << pair.second << std::endl;
}
לַחֲזוֹר 0 ;
}
התוכנית מתחילה בהכרזה על 'std::map' בשם 'newMap' שמשייכת את מפתחות המספרים השלמים לערכי מחרוזת מתאימים. לאחר מכן, אנו מאכלסים את המפה בצמדי מפתח-ערך באמצעות האופרטור של סוגריים מרובעים. לדוגמה, אנו מקצים את צמדי המפתח-ערך של (1, 'סוס'), (2, 'אריה'), (3, 'נמר') ו-(4, 'חתול') ל-'newMap'.
הפעולה המשמעותית הבאה כוללת שימוש באיטרטורים כדי למחוק את האלמנטים מהמפה. פונקציית המחיקה מופעלת עם הארגומנטים 'newMap.lower_bound(2)' ו-'newMap.upper_bound(3)'. זה מוחק את האלמנטים עם מקשים שנופלים בטווח (2, 3). במילים אחרות, זה מסיר את הערכים 'אריה' ו'נמר' מהמפה. לאחר פעולה זו, המפה מכילה רק את האלמנטים עם המקשים 1 ו-4, המתאימים ל'סוס' ו'חתול'.
לבסוף, אנו משתמשים בלולאת 'for' מבוססת טווח כדי לחזור על הרכיבים הנותרים במפה ולהדפיס את צמדי המפתח-ערך שלהם לקונסולה.
כתוצאה מכך, הפלט מציג את הדברים הבאים:
דוגמה 4: מחיקה על סמך פרדיקט
מחיקה על סמך פרדיקט מתייחסת להסרת האלמנטים ממבנה נתונים, כגון מיכל, על סמך תנאי או קריטריונים מוגדרים. ה-'std::map::erase' יכול לשמש גם עם פונקציית פרדיקט כדי להסיר את האלמנטים באופן מותנה. הבה נבחן את הדוגמה הבאה:
#include#include <מפה>
#include <אלגוריתם>
int main ( ) {
std::map < int, std::string > myMap = {
{ 1 , 'יָנוּאָר' } ,
{ 2 , 'פברואר' } ,
{ 3 , 'מרץ' } ,
{ 4 , 'אַפּרִיל' } ,
{ 5 , 'מאי' }
} ;
פרדיקט אוטומטי = [ ] ( const std::pair < int, std::string >& אֵלֵמֶנט ) {
לַחֲזוֹר element.second.length ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( myMap.begin ( ) , myMap.end ( ) , פרידיקט ) , myMap.end ( ) ) ;
std::cout << ' \n מפה לאחר מחיקת אלמנטים על סמך הפרדיקט:' << std::endl;
ל ( const auto & זוג: myMap ) {
std::cout << זוג.ראשון << ': ' << pair.second << std::endl;
}
לַחֲזוֹר 0 ;
}
התוכנית מתחילה על ידי הכללת קבצי הכותרות הדרושים. 'std::map' בשם 'myMap' מוצהרת ומאוחלת בפונקציה 'main'. הוא מכיל את צמדי המפתח-ערך המייצגים את שמות החודשים ואת הערכים המספריים שלהם. לאחר מכן, פונקציית 'למבדה' (פרדיקט) מוגדרת. פונקציית 'lambda' זו משמשת כפרדיקט עבור האלגוריתם 'std::remove_if'. הוא מוודא אם אורך ערך המחרוזת המשויך לרכיב מפה קטן מחמישה תווים.
לאחר מכן נעשה שימוש באלגוריתם 'std::remove_if' בשילוב עם הפונקציה 'מחק' של ה-'std::map'. שילוב זה מסיר את האלמנטים מהמפה בהתבסס על תוקף הפרדיקט.
לאחר הפעלת התוכנית, האלמנטים עם מפתחות פחות מחמישה מוסרים מהמפה המקורית, מה שמדגים את המחיקה על סמך פרדיקט באמצעות 'std::map'.
סיכום
לסיכום, הפונקציה 'std::map::erase' היא כלי רב-תכליתי ב-C++ להסרת האלמנטים מ-'std::map'. בין אם מחיקה על ידי מקש, איטרטור, טווח או על סמך פרדיקט, הפונקציה 'std::map::erase' מספקת גמישות וקלות שימוש. על ידי שליטה בפונקציה זו, מפתחי C++ יכולים לנהל ולתפעל ביעילות את הנתונים בתוך מיכלי 'std::map', מה שהופך את הקוד שלהם לחזק יותר וקל יותר לתחזוקה.