C++ Vector Clear vs Erase

לוקטור C++ יש פונקציות איברים רבות. שניים מהם clear() ומחק(). ברור() 'מסיר' את כל האלמנטים של הווקטור. erase() 'מסיר' אלמנט בודד או טווח של אלמנטים. ישנן שתי גרסאות עמוסות יתר של פונקציית האיבר erase() עבור הווקטור.

הכותרת של מאמר זה היא למעשה 'פונקציית חבר ניקוי () וקטור לעומת פונקציית איבר של וקטור () ב-C++. זוהי השוואה של פונקציות שני האיברים. זה עוסק מתי להשתמש באיזה, איך להשתמש באיזה ובאילו תנאים משתמשים בכל אחד מהם.

על מנת להשתמש בוקטור בתוכנת C++, התוכנית צריכה להתחיל ב:

תוכן המאמר

• וקטור ברור ()
• מחק וקטור
• פופ_גב
• הרס וקטור
• סיכום

וקטור ברור ()

הפונקציה clear() איבר 'מסירה' את כל הרכיבים של הווקטור. התחביר שלו הוא:

זה מחזיר ריק. התוכנית הבאה ממחישה את השימוש בה, עם הביטוי 'vtr.clear();':

הפלט הוא השורה האחת:

אם הווקטור לא היה מנוקה, הפלט היה שני קווים מאותו רצף. לא הוצגה שורה שנייה מכיוון שכל הרכיבים נוקו.

const vector ו-clear()

כאשר לפני הצהרת וקטור יש const, זה אומר שלא ניתן למחוק או לשנות את הרכיבים של הווקטור. אם ביטוי מנסה לשנות או למחוק אחד מהרכיבים, התוכנית לא תעשה קומפילציה. בדוק את התוכנה הבאה ושימו לב שהיא לא מהדרת:

אם התוכנית הייתה נבדקת, הייתה מתקבלת הודעת שגיאה, ולא היה שום קומפילציה. מכיוון שהווקטור הוכרז קבוע, הפונקציה clear() לא יכלה לפעול, וכתוצאה מכך הודעת שגיאה מהמהדר.

הערה: clear() מוחק את כל הרכיבים של הווקטור. למעשה, הוא מסמן את כל הרכיבים כמוחקים, כך שקודים אחרים יכולים לתפוס את מיקומי הזיכרון שלהם. אם מיקום הזיכרון של אלמנט כלשהו עדיין לא נקלט בקוד אחר, אז עדיין ניתן לעשות שימוש חוזר באלמנט מטעם אותו וקטור.

מחק וקטור

התחבירים הפשוטים של שתי פונקציות האיברים ()Erase הם:

כאשר a הוא שם הווקטור.

iterator erase(const_iterator position)

זהו התחביר המלא עבור 'a.erase(q)'. זה מחזיר איטרטור המצביע על האלמנט, שהיה ממש מאחורי זה שנמחק. הארגומנט, q הוא איטרטור המצביע על האלמנט שיש למחוק. התוכנית הבאה ממחישה זאת:

הפלט הוא:

'R' נמחק. האיטרטור המוחזר מצביע כעת על 'S', שהיה ממש אחרי 'R'. פונקציית האיבר, begin(), מחזירה איטרטור המצביע על האלמנט הראשון של הווקטור. בקוד, האיטרטור הזה הוגדל פעמיים כדי להצביע על 'R'. 'R' נמחק עם הביטוי, 'vtr.erase(iter)'.

טווח בוקטור

לרשימה,

הרצף, 'Q', 'R', 'S', 'T' הוא טווח. עם זאת, עם מיכלי C++, האלמנט האחרון, 'T' אינו נחשב לחלק מהטווח. זה מצוין במונחים כלליים כ:

'[' במקרה זה, פירושו שהאלמנט הראשון ברצף כלול, ו-')' פירושו שהאלמנט האחרון אינו כלול.

iterator erase(const_iterator ראשון, const_iterator אחרון)

זהו התחביר המלא עבור 'a.erase(q1,q2)'. הוא מחזיר איטרטור המצביע על האלמנט, שהיה ממש מאחורי הטווח שנמחק. הערה: האלמנט האחרון בטווח לא נמחק. אז, האיטרטור המוחזר יצביע על האלמנט האחרון של הטווח. הארגומנטים q1 ו-q2 הם איטרטורים המצביעים על האלמנט הראשון והאחרון של הטווח. התוכנית הבאה ממחישה זאת:

הפלט הוא:

'Q', 'R', 'S' נמחקו. האיטרטור המוחזר מצביע כעת על 'T', שהיה האלמנט האחרון בטווח המכולה. הפונקציה איבר, end(), מחזירה איטרטור שמצביע מיד אחרי האלמנט האחרון של הווקטור. בקוד, האיטרטור הזה ירד פעמיים כדי להצביע על 'T', האלמנט האחרון של הטווח. 'Q', 'R', 'S' נמחקו ללא הרכיב האחרון, 'T' בטווח, עם הביטוי, 'vtr.erase(itB, itE)'.

const וקטור ומחק()

אם להכרזה של וקטור קודמת ל-const, עבור קבוע, אז אף אחד מהאלמנטים שלו לא יכול להימחק. התוכנית הבאה לא תעשה קומפילציה, תוציא הודעת שגיאה עבור הביטוי a.erase(q):

אם הקורא ניסה את התוכנית, הוא היה מקבל הודעת שגיאה. התוכנית לא הייתה מורכבת.

התוכנית הבאה לא תעשה קומפילציה, תוציא הודעת שגיאה עבור הביטוי a.erase(q1,q2):

הערה: erase() מוחק אלמנט או טווח של אלמנטים. למעשה, הוא מסמן אלמנט כמחוק, כך שניתן לתפוס את מיקומי הזיכרון שלו על ידי קודים אחרים. אם מיקום הזיכרון של אלמנט כלשהו עדיין לא נקלט בקוד אחר, אז עדיין ניתן לעשות שימוש חוזר באלמנט מטעם אותו וקטור.

pop_back()

פונקציית האיבר הווקטור pop_back() היא סוג של פונקציית erase() . עם זאת, הוא מוחק רק את האלמנט האחרון של הווקטור. התחביר הוא:

זה לא דורש ויכוח וחוזר ריק. התוכנית הבאה ממחישה את השימוש בה:

הפלט הוא:

האלמנט האחרון, 'U' הוסר (נמחק).

הרס וקטור

האם ניתן להרוס וקטור? - כן! עם זאת, כאשר וקטור מושמד, כל האלמנטים שלו נמחקים מלבד שמו; כלומר, עדיין ניתן לעשות שימוש חוזר בהצהרה הווקטורית, אך עם אי ודאות מסוימת. התחביר להרוס וקטור הוא:

כאשר 'a' הוא שם הווקטור. התוכנית הבאה ממחישה זאת:

הפלט הוא:

מהמחשב של המחבר, עם כמה תווים לא אמינים לשורה השנייה.

סיכום

ניתן להשוות את פונקציית האיבר הוקטור clear() לפונקציית איבר הווקטור erase(). הם לא תחליפים. clear() מוחק את כל הרכיבים של הווקטור. למעשה, הוא מסמן את כל הרכיבים כמוחקים, כך שניתן לתפוס את מיקומי הזיכרון שלהם על ידי קודים אחרים. אם מיקום הזיכרון של אלמנט כלשהו עדיין לא נקלט בקוד אחר, אז עדיין ניתן לעשות שימוש חוזר באלמנט בשם אותו וקטור. erase() מוחק אלמנט או טווח של אלמנטים. למעשה, הוא מסמן אלמנט כמחוק, כך שניתן לתפוס את מיקום הזיכרון על ידי קוד אחר. אם מיקום הזיכרון של רכיב כלשהו שנמחק עדיין לא נקלט על ידי קוד אחר, עדיין ניתן לעשות שימוש חוזר ברכיב בשם אותו וקטור. ל-clear יש דמיון להרוס, ~X().