כיצד להשתמש ב- C ++ וקטור

מבוא

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

ל- C ++ יש ספריות רבות שכולן מהוות את הספרייה הסטנדרטית C ++. אחת הספריות הללו היא ספריית המכולות. מיכל הוא אוסף של אובייקטים, וניתן לבצע פעולות מסוימות באוסף. ניתן לקבץ מכולות C ++ לשתי קבוצות: מכולות רצף ומכולות אסוציאטיביות. מיכלי רצף הם וקטור, מערך (לא אותו מערך שנדון בו בעבר), deque, forward_list ורשימה. אלה אוספים שונים (מבני נתונים דמויי מערך), וכל אחד מהם מציע פשרות שונות.

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

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

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

כיתה וחפצים

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

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

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

יצירת אובייקט ממעמד פירושה בניית האובייקט; זה גם אומר לייצר את האובייקט.

מחלקת הווקטורים

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

#לִכלוֹל

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

#לִכלוֹל
#לִכלוֹל

יישום וקטור

intפו[10];

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

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

שעה (ות::וֶקטוֹר <int>vtr(8);

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

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

#לִכלוֹל
#לִכלוֹל
באמצעות מרחב שמות std;

עומס יתר של פונקציה

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

בניית וקטור

בניית וקטור פירושה מייצרות (יצירה) של אובייקט וקטורי. פונקציית הקונסטרוקטור עמוסה באופן הבא:

שם וקטור

זה יוצר וקטור באורך אפס וסוג T. המשפט הבא יוצר וקטור באורך אפס של סוג המצוף עם השם vtr:

וֶקטוֹר<לָצוּף>vtr;

שם וקטור (n)

זה יוצר וקטור עם n יסודות מסוג T. הצהרה על וקטור זה עם ארבעה יסודות צפים היא כדלקמן:

וֶקטוֹר<לָצוּף>vtr(4);

שם וקטור (n, t)

זה יוצר וקטור של n יסודות שמאתחלים לערך t. המשפט הבא יוצר וקטור של 5 אלמנטים, כאשר לכל אלמנט יש את הערך 3.4:

וֶקטוֹר<לָצוּף>vtr(5, 3.4);

בנייה עם אתחול

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

וֶקטוֹר<לָצוּף>vtr= {1.1, 2.2, 3.3, 4.4};

אוֹ

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};

שים לב שאין סוגריים רק אחרי שם האובייקט. סוגריים המשמשים מיד לאחר שם האובייקט צריכים לכלול את רשימת האתחול, כדלקמן:

וֶקטוֹר<לָצוּף>vtr({1.1, 2.2, 3.3, 4.4});

ניתן לבנות ולאתחל וקטור מאוחר יותר עם רשימת האתחול. במקרה זה, אין להשתמש בסוגריים:

וֶקטוֹר<לָצוּף>vtr;
vtr= {1.1, 2.2, 3.3, 4.4};

וקטור V2 (V1)

זהו בונה העתקים. הוא יוצר וקטור V2 כהעתק של הווקטור V1. הקוד הבא ממחיש זאת:

וֶקטוֹר<לָצוּף>vtr1(5, 3.4);
וֶקטוֹר<לָצוּף>vtr2(vtr1);

הקצאת וקטור במהלך הבנייה

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

וֶקטוֹר<לָצוּף>vtr1{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף>vtr2=vtr1;

ההצהרה השנייה מקבילה ל:

וֶקטוֹר<לָצוּף>vtr2= {1.1, 2.2, 3.3, 4.4};

const וקטור

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

קבועוֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};

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

בנייה עם Iterator

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

תבנית<class InputIterator>
וֶקטוֹר(InputIterator תחילה,InputIterator האחרון,קבועמקצה& =מקצה());

זה בונה וקטור לטווח [ראשון, אחרון] באמצעות ההקצאה שצוין, עליו יידונו בהמשך מאמר זה.

הורס וקטור

כדי להרוס וקטור, פשוט אפשר לו לצאת מחוץ להיקף וההרס מטופל באופן אוטומטי.

קיבולת וקטורית

גודל_סוג קיבולת () const noexcept

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

וֶקטוֹר<לָצוּף>vtr(4);
intעל אחד=vtr.קיבולת();
עֲלוּת<<על אחד<< ' n';

הפלט הוא 4.

מילואים (n)

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

וֶקטוֹר<לָצוּף>vtr(4);
vtr.לְהַזמִין(6);
עֲלוּת<<vtr.קיבולת() << ' n';

התפוקה היא 6. אז, שטח הנוסף השמור הוא 6 - 4 = 2 אלמנטים. הפונקציה מחזירה ריק.

size () const noexcept

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

וֶקטוֹר<לָצוּף>vtr(4);
לָצוּףש=vtr.גודל();
עֲלוּת<<ש<< ' n';

הפלט הוא 4.

לכווץ כדי להתאים()

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

וֶקטוֹר<לָצוּף>vtr(4);
vtr.לְהַזמִין(6);
vtr.לכווץ כדי להתאים();
intש=vtr.גודל();
עֲלוּת<<ש<< ' n';

הפלט הוא 4 ולא 6. הפונקציה מחזירה חלל.

שינוי גודל (sz), שינוי גודל (sz, c)

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

וֶקטוֹר<לָצוּף>vtr1{1.1, 2.2, 3.3, 4.4};
vtr1.לשנות את הגודל(2);
עֲלוּת<< 'גודל חדש של vtr1:' <<vtr1.גודל() << ' n';
וֶקטוֹר<לָצוּף>vtr2{1.1, 2.2};
vtr2.לשנות את הגודל(4, 8.8);
עֲלוּת<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << ' n';

הפלט הוא כדלקמן:

גודל חדש של vtr1: 2
vtr2: 1.1 2.2 8.8 8.8

הפונקציות מחזירות ריק.

ריק () const noexcept

פונקציה זו מחזירה 1 עבור true אם אין אלמנטים בווקטור ו- 0 עבור false אם הווקטור ריק. אם לווקטור יש 4 מיקומים עבור סוג מסוים של נתונים, כגון float, ללא כל ערך צף, אז הווקטור הזה אינו ריק. הקוד הבא ממחיש זאת:

וֶקטוֹר<לָצוּף>vtr;
עֲלוּת<<vtr.ריק() << ' n';
וֶקטוֹר<לָצוּף>vt(4);
עֲלוּת<<אז זהריק() << ' n';

וֶקטוֹר<לָצוּף>v(4,3.5);
עֲלוּת<<v.ריק() << ' n';

הפלט הוא כדלקמן:

1
0
0

גישה אלמנט וקטורית

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

vectorName [i]

הפעולה vectorName [i] מחזירה הפניה לרכיב ב- i^האינדקס הווקטור. פלט הקוד הבא 3.3 עבור הווקטור הנ'ל:

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
לָצוּףfl=vtr[2];
עֲלוּת<<fl<< ' n';

vectorName [i] קבוע

הפעולה vectorName [i] const מבוצעת במקום vectorName [i] כאשר הווקטור הוא וקטור קבוע. פעולה זו משמשת בקוד הבא:

קבועוֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
לָצוּףfl=vtr[2];
עֲלוּת<<fl<< ' n';

הביטוי מחזיר התייחסות קבועה ל- i^האלמנט הווקטור.

הקצאת ערך באמצעות Subscript

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

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
vtr[2] = 8.8;
עֲלוּת<<vtr[2] << ' n';

הפלט הוא 8.8.

vectorName.at (i)

vectorName.at (i) הוא כמו vectorName [i], אך vectorName.at (i) אמין יותר. הקוד הבא מראה כיצד יש להשתמש בווקטור זה:

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
לָצוּףfl=vtr.בְּ-(2);
עֲלוּת<<fl<< ' n';
בְּ-()הוא חבר וקטוריפוּנקצִיָה.

vectorName.at (i) const

vectorName.at (i) const הוא כמו vectorName [i] const, אך vectorName.at (i) const הוא אמין יותר. vectorName.at (i) const מבוצע במקום vectorName.at (i) כאשר הווקטור הוא וקטור קבוע. וקטור זה משמש בקוד הבא:

קבועוֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
לָצוּףfl=vtr.בְּ-(2);
עֲלוּת<<fl<< ' n';
בְּ-() קבועהוא חבר וקטוריפוּנקצִיָה.

הקצאת ערך באמצעות הפונקציה at ()

ניתן להקצות ערך לווקטור לא קבוע עם הפונקציה at (), כדלקמן:

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
vtr.בְּ-(2) = 8.8;
עֲלוּת<<vtr[2] << ' n';

הפלט הוא 8.8.

בעיה בתת סקריפטים

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

חֲזִית()

פעולה זו מחזירה הפניה לאלמנט הראשון של הווקטור מבלי להסיר את האלמנט. הפלט של הקוד הבא הוא 1.1.

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
לָצוּףfl=vtr.חֲזִית();
עֲלוּת<<fl<< ' n';

האלמנט אינו מוסר מהווקטור.

קדמית () קבועה

כאשר לבנייה הווקטורית קודמת const, הביטוי front () const מבוצע במקום הקדמי (). זה משמש בקוד הבא:

קבועוֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
לָצוּףfl=vtr.חֲזִית();
עֲלוּת<<fl<< ' n';

הפניה קבועה מוחזרת. האלמנט אינו מוסר מהווקטור.

חזור()

פעולה זו מחזירה הפניה לאלמנט האחרון של הווקטור מבלי להסיר את האלמנט. פלט הקוד הבא הוא 4.4.

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
לָצוּףfl=vtr.חזור();
עֲלוּת<<fl<< ' n';

גב () קבוע

כאשר לבנייה הווקטורית קודמת const, הביטוי back () const מבוצע במקום back (). זה משמש בקוד הבא:

קבועוֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
לָצוּףfl=vtr.חזור();
עֲלוּת<<fl<< ' n';

הפניה קבועה מוחזרת. האלמנט אינו מוסר מהווקטור.

וקטור גישה לנתונים

data () noexcept; data () const noexcept;

כל אחד מאלה מחזיר מצביע כך ש [data (), data () + גודל ()) הוא טווח חוקי.

זה יעסוק בפירוט רב יותר בהמשך המאמר.

איטרטורים חוזרים והווקטור

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

begin () noexcept

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

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף> ::איטרציהאיטר=vtr.התחל();
עֲלוּת<< *איטר<< ' n';

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

begin () const noexcept;

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

קבועוֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף> ::const_iteratorאיטר=vtr.התחל();
עֲלוּת<< *איטר<< ' n';

הפלט הוא 1.1. שים לב כי const_iterator שימש הפעם במקום רק איטרציה לקבלת האיטרור המוחזר.

סוף () noexcept

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

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף> ::איטרציהאיטר=vtr.סוֹף();
עֲלוּת<< *איטר<< ' n';

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

סוף () const noexcept

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

קבועוֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף> ::const_iteratorאיטר=vtr.סוֹף();
עֲלוּת<< *איטר<< ' n';

הפלט הוא 0. שים לב ש- const_iterator שימש הפעם במקום רק איטרציה לקבלת האיטרור המוחזר.

איטרציה הפוכה

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

rbegin () noexcept

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

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף> ::מדריך הפוךתחתית=vtr.התחל מחדש();
עֲלוּת<< *תחתית<< ' n';

הפלט הוא 4.4.

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

rbegin () const noexcept;

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

קבועוֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף> ::const_reverse_iteratorתחתית=vtr.התחל מחדש();
עֲלוּת<< *תחתית<< ' n';

הפלט הוא 4.4.

שים לב כי const_reverse_iterator שימש הפעם, במקום רק reverse_iterator, לקבלת האיטרור המוחזר.

render () noexcept

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

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף> ::מדריך הפוךתחתית=vtr.עושה();
עֲלוּת<< *תחתית<< ' n';

הפלט הוא 0, וזה חסר משמעות, מכיוון שאין אלמנט בטון ממש לפני האלמנט הראשון.

render () const noexcept

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

קבועוֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף> ::const_reverse_iteratorתחתית=vtr.עושה();
עֲלוּת<< *תחתית<< ' n';

הפלט הוא 0.

שים לב כי const_reverse_iterator שימש הפעם, במקום רק reverse_iterator, לקבלת האיטרור המוחזר.

משני וקטורים

משתנה שמשנה את הווקטור יכול לקחת או להחזיר איטרציה.

דוגמה א (עמ ', ארגומנים)

מוסיף אובייקט מסוג T שנבנה עם std :: קדימה (ארגז) ... לפני עמ '.

לפרטים - ראה בהמשך

insert (iteratorPosition, value)

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

וֶקטוֹר<int>vtr{10, עשרים, 30, 40};
וֶקטוֹר<int> ::איטרציהאיטר=vtr.התחל();
++איטר;
++איטר;
vtr.לְהַכנִיס(איטר, 25);
עֲלוּת<<vtr[1] << '' <<vtr[2]<< '
' <<vtr[3] << ' n';

הפלט הוא: 20 25 30.

שים לב שהאיטרטור היה מתקדם (מוגבר) בדיוק כמו מצביע.

ניתן להוסיף גם רשימת אתחול, כפי שהקוד הבא ממחיש:

וֶקטוֹר<int>vtr{10, עשרים, 30, 40};
וֶקטוֹר<int> ::איטרציהאיטר=vtr.התחל();
++איטר;
++איטר;
vtr.לְהַכנִיס(איטר, {25, 28});

עֲלוּת<<vtr[1] << '' <<vtr[2]<< '
' <<vtr[3]<< '' <<vtr[4] << ' n';

הפלט הוא: 20 25 28 30.

מחק (מיקום)

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

וֶקטוֹר<int>vtr{10, עשרים, 30, 40};
וֶקטוֹר<int> ::איטרציהאיטר=vtr.התחל();
++איטר;
++איטר;
vtr.לִמְחוֹק(איטר);
עֲלוּת<<vtr[0] << '' <<vtr[1] << '
' <<vtr[2]<< ' n';

התפוקה היא: 10 20 40

push_back (t), push_back (rv)

משמש להוספת אלמנט אחד בסוף הווקטור. השתמש ב- push_back (t) כדלקמן:

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
vtr.התנגדות(5.5);
לָצוּףfl=vtr[4];
עֲלוּת<<fl<< ' n';

הפלט הוא 5.5.

התנגדות(rv): -נתראה מאוחר יותר.

pop_back ()

מסיר את האלמנט האחרון מבלי להחזיר אותו. גודל הווקטור מצטמצם ב- 1. הקוד הבא ממחיש זאת:

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
vtr.pop_back();
לָצוּףש=vtr.גודל();
עֲלוּת<<ש<< ' n';

הפלט הוא 3.

החלפה (ב)

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

וֶקטוֹר<לָצוּף>vtr1{1.1, 2.2, 3.3, 4.4};
וֶקטוֹר<לָצוּף>vtr2{10, עשרים};
vtr1.לְהַחלִיף(vtr2);
עֲלוּת<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'<<vtr1[2] <<''<<vtr1[3] << ' n';

עֲלוּת<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << ' n';

הפלט הוא:

vtr1: 10 עשרים 0 0
vtr2: 1.1 2.2 3.3 4.4

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

ברור()

מסיר את כל האלמנטים מהווקטור, כפי שמראה קטע הקוד הבא:

וֶקטוֹר<לָצוּף>vtr{1.1, 2.2, 3.3, 4.4};
vtr.ברור();
עֲלוּת<<vtr.גודל() << ' n';

הפלט הוא 0.

מפעילים שוויון ויחסי וקטורים

המפעיל ==

מחזירה 1 עבור true אם לשני הווקטורים אותו גודל והרכיבים המתאימים שווים; אחרת, הוא מחזיר 0 על שקר. לדוגמה:

וֶקטוֹר<int>U{1, 2, 3};
וֶקטוֹר<int>ו{4, 5, 6};
בול bl=U==ו;
עֲלוּת<<bl<< ' n';

הפלט הוא 0.

המפעיל! =

מחזירה 1 עבור true אם לשני הווקטורים אין אותו גודל ו/או שהאלמנטים המתאימים אינם שווים; אחרת, הוא מחזיר 0 על שקר. לדוגמה:

וֶקטוֹר<int>U{1, 2, 3};
וֶקטוֹר<int>ו{4, 5, 6};
בול bl=U! =ו;
עֲלוּת<<bl<< ' n';

הפלט הוא 1.

מחזירה 1 עבור true אם הווקטור הראשון הוא קבוצת המשנה הראשונית של הווקטור השני, כאשר האלמנטים של שני החלקים השווים הם זהים ובאותו הסדר. אם שני הווקטורים הם באותו גודל ונעים משמאל לימין ונתקל אלמנט בווקטור הראשון שהוא פחות מהאלמנט המקביל בווקטור השני, אז 1 עדיין יוחזר. אחרת, 0 עבור false מוחזר. לדוגמה:
וֶקטוֹר<int>U{3, 1, 1};
וֶקטוֹר<int>ו{3, 2, 1};
בול bl=U<ו;
עֲלוּת<<bl<< ' n';
הפלט הוא 1.
המפעיל>

חוזר! (U
ה<= Operator

מחזירה U<= V, where U is the first vector and V is the second vector, according to the above definitions.

מפעיל> =

חוזר! (U<= V), where U is the first vector and V is the second vector, according to the above definitions.

סיכום

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

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

כיצד להשתמש ב- C ++ וקטור

מבוא

כיתה וחפצים

מחלקת הווקטורים

יישום וקטור

עומס יתר של פונקציה

בניית וקטור

בנייה עם אתחול

הקצאת וקטור במהלך הבנייה

const וקטור

בנייה עם Iterator

הורס וקטור

קיבולת וקטורית

הקצאת ערך באמצעות Subscript

הקצאת ערך באמצעות הפונקציה at ()

בעיה בתת סקריפטים

וקטור גישה לנתונים

איטרטורים חוזרים והווקטור

איטרציה הפוכה

משני וקטורים

מפעילים שוויון ויחסי וקטורים

סיכום

קטגוריה

רשום פופולרי