AN  איטרטור ב- C ++  הוא אובייקט דמוי מצביע שמצביע על אלמנט של מיכל ה- STL. בדרך כלל הם משמשים לולאה דרך תוכן מיכל ה- STL ב- C ++. היתרון העיקרי של איטרטורים STL הוא שהם הופכים את אלגוריתמי ה- STL ללא תלות בסוג המכולה המשמש. אנו יכולים פשוט להעביר את האיטרטור לאלמנטים המכולתיים במקום למכולה עצמה לאלגוריתמי STL.

הצהרת איטרטור

לכל מיכל ב- C ++ STL יש איטרטור משלו. אז עלינו להכריז על איטרטור כ:

<type>::iterator it; 

אֵיפֹה

• סוּג: סוג המכולה שעבורו מוכרז האיטרטור.
• זֶה: שם שהוקצה לאובייקט iterator.

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

auto it = iter 

אֵיפֹה איטר הוא האיטרטור שהוקצה לאיטרטור ה- IT החדש שנוצר.

שֶׁלָנוּ C ++ קורס מכסה את השימוש באיטרטורים ב- STL ומבטיח שאתה מבין כיצד לחצות סוגי מכולות שונים.

דוגמה לאיטרטורים

התוכנית שלהלן ממחישה כיצד להשתמש באיטרטור כדי לעבור את מיכל הווקטור:

#include    using namespace std; int main() {  vector<int> v = {1 2 3 4 5};  // Defining an iterator pointing to  // the beginning of the vector  vector<int>::iterator first =  v.begin();  // Defining an iterator pointing  // to the end of the vector  vector<int>::iterator last =  v.end();    // Iterating the whole vector  while(first != last) {  cout << *first << ' ';  first++;  }  return 0; } 

1 2 3 4 5 

כפי שאולי שמתם לב שהשתמשנו בו וקטור :: התחל () וקטור :: סוף () פוּנקצִיָה. פונקציות אלה הן פונקציות החברות ל- STD :: וקטור המחזיר את האיטרטור לאלמנט הראשון ואחד אחרי האלמנט האחרון בווקטור. אנו משתמשים בחזרי החזרות הם פונקציות אלה כדי לאתר את הווקטורים.

פונקציות איטרטור מיכל

C ++ STL מספק כמה פונקציות חברים ב מיכל STL זה מחזיר את האיטרטורים לפחות לאלמנט הראשון והאחרון. פונקציות חברים אלה מוגדרות כמעט בכל מיכל ה- STL (משאיר כמה מכולות גישה מוגבלות כמו לַעֲרוֹם תוֹר ) עם אותו שם לעקביות.

הטבלה הבאה מציגה את כל השיטות שמחזיר את האיטרטור למכולות:

למשל אם דבר הוא שם הווקטור אז נוכל להשתמש בשיטות לעיל כמוצג להלן:

vec.begin() vec.rbegin() vec.cbegin() vec.crbegin() vec.end() vec.rend()  vec.cend() vec.crend() 

פעולות איטרטורים

בדיוק כמו אריתמטיקה מצביע יש כמה פעולות שמותרות על איטטורים C ++. הם משמשים לספק פונקציות שונות המגדילות את חשיבותם של איטרטורים. יש 5 תקפים פעולות איטרטור ב- C ++ :

• העברת איטרטורים
• הגדלת/ירידה של איטראטורים
• הוספת/חיסור שלם שלם לאיטורים
• הפחתת איטרטור אחר
• השוואה בין איטרטורים

העברת איטרטורים

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

// Access *it; // Update *it = new_val;  

אֵיפֹה new_val הוא הערך החדש שהוקצה לאלמנט שהצביע על ידי iterator זֶה ו

הגדלת/ירידה של איטראטורים

אנו יכולים להגדיל או להקטין את האיטרטור על ידי 1 באמצעות (++) או (-) מפעילים בהתאמה. פעולת תוספת מעבירה את האיטרטור לאלמנט הבא במיכל ואילו פעולת הירידה מעבירה את האיטרטור לאלמנט הקודם.

it++; // post-increment ++it; // pre-increment it--; // post-decrement --it; // pre-decrement 

הוספת/חיסור שלם שלם לאיטורים

אנו יכולים גם להוסיף או לחסר ערך שלם מהאיטורים. זה יהיה יותר את האיטרטור הבא או המיקום הקודם בהתאם לערך שלם הנוסף.

// Addition it + int_val;  // Subtraction it - int_val;  

אֵיפֹה int_val הוא ערכי מספר שלם שמתווספים או מופרעים מהאיטרטור זֶה ו

הפחתת איטרטור אחר

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

it1 - it2 

השוואה בין איטרטורים

אנו יכולים גם לבדוק את שני האיטורים מאותו סוג זה בזה כדי למצוא את הקשר ביניהם. אנו יכולים להשתמש במפעילי ההתייחסות כמו (==) שוויון ו (! =) מפעילי אי שוויון יחד עם מפעילים יחסיים אחרים כמו< > <= >=.

it1 != it2 // Equal to it1 == it2 // Not equal to it1 > it2 // Greater than it1 < it2 // Less than it1 >= it2 // Greater than equal to it1 <= it2 // Less than equal to 

סוגי איטרטורים ב- C ++

ניתן לחלק את איטרטורי ה- STL על בסיס הפעולות שניתן לבצע עליהם. ישנם 5 סוגים עיקריים של איטרטורים ב- C ++, אשר כמפורט בטבלה שלהלן יחד עם מכולות נתמכות ופעולות איטרטור נתמכות.

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

מתאמי איטרטור

מתאמי איטרטור ב- C ++ הם הסוג המיוחד של איטרטורים הבנויים על פני איטרטורים מסורתיים כדי לספק פונקציונליות מיוחדת. ישנם מתאמי איטרטור רבים ב- C ++ שחלקם ניתנים להלן:

פונקציות שירותי איטרטור ב- C ++

C ++ STL מספקים את הפונקציה השונה כדי לפשט את העבודה עם איטרטורים. הם מופיעים בטבלה שלהלן:

יישומי איטרטורים עם דוגמאות

איטרטורים משמשים בהרחבה ב- C ++ למטרות רבות ושונות תוך עבודה עם מכולות STL ואלגוריתמים. להלן כמה יישומים ראשוניים של איטרטורים ב- C ++ שדוגמאות הקוד שלהם:

חציית מכולות

חציית מכולות STL היא היישום הבסיסי ביותר של איטרטורים. בכך אנו משתמשים בפונקציות התחלה () ובסיום () כדי לגרום לאיטרטורים של התחלה וסוף לחצות את כל המכולה. בעיקרון אנו ממשיכים להגדיל את איטרטור ההתחלה עד שהוא לא שווה לסוף.

דוּגמָה

#include    using namespace std; int main() {  set<int> s = {10 20 30   40 50};  // Iterator to the beginning   // of the set  auto it = s.begin();  // Iterating through the   // entire set  while (it != s.end()) {    // Dereferencing iterator   // to access value  cout << *it << ' ';    // Incrementing the   // iterator  it++;  }    return 0; } 

10 20 30 40 50 

כפי שמוצג בקוד שלמעלה אנו חוצים את מיכל ההגדרה. באופן דומה אנו יכולים להשתמש באותה גישה כדי לעבור כל מיכל.

היפוך מיכל

איטרטורים הפוכים מאפשרים לך לעבור מכולה מהקצה להתחלה מבלי שתצטרך לטפל באופן ידני בהיפוך.

דוּגמָה

#include    using namespace std; int main() {  vector<int> vec = {10 20 30   40 50};  // Defining reverse iterators   // pointing to the reverse   // beginning of vec  auto it = vec.rbegin();  // Iterating the whole   // vector in reverse  while (it != vec.rend()) {  cout << *it << ' ';  it++;  }  return 0; } 

50 40 30 20 10 

אלגוריתמים עצמאיים של מיכל

איטרטורים מאפשרים לאלגוריתמים לעבוד עם כל סוג מכולה המייצרים פונקציות כמו std :: sort () std :: מצא () ו- std :: for_each () גמיש יותר. אתה יכול לעבור איטרטורים במקום המכולה בפועל.

דוּגמָה

#include    using namespace std; int main() {  vector<int> vec = {30 10 40   10 50};  multiset<int> ms = {10 30 10   20 40 10};  // Using the std::count() algorithm to count  // the number of occurences of 10 in vector  // and multiset using iterator  cout << '10s in Vector: '   << count(vec.begin()  vec.end() 10) << endl;  cout << '10s in Multiset: '   << count(ms.begin()  ms.end() 10);  return 0; } 

10s in Vector: 2 10s in Multiset: 3

יישומים נוספים של איטרטורים

ישנם יישומים נוספים של איטרטורי STL:

• חישוב מרחק: השימוש ב- STD :: מרחק () איטרטורים עוזרים לחשב את מספר האלמנטים בין שני עמדות במיכל.
• איטרציה של זרם: איטרטורי זרם מאפשרים לך לטפל בזרמי קלט/פלט כמו מכולות שמקל על הקריאה והכתבים לזרמים באמצעות אלגוריתמי STL.
• העבר סמנטיקה באלגוריתמי STL: Move Iterators מציג את סמנטיקה מהלך באלגוריתמי STL המסייעים בהגברת הביצועים והיעילות על ידי הימנעות מהעתקה מיותרת. הנתונים יועברו על פי כללי סמנטיקה של מעבר.
• איטרטורים מותאמים אישית למבני נתונים: ניתן ליישם איטרטורים מותאמים אישית עבור מבני נתונים שאינם STL כמו עצים או גרפים כדי לספק את התמיכה באלגוריתמי STL ותכונות רבות אחרות. יתכן ונצטרך לעקוב אחר מספר כללים ומוסכמות כדי לספק ירידה מתגברת מתאימה ופעולות אחרות.