ב-C++, וקטור הוא מבנה נתונים חד מימדי אשר מגדיל את עצמו באופן דינמי בהתבסס על הדרישה. ארגון נתונים (הוספה/שינוי/מחיקה) יכול להיעשות ביעילות במבנה נתונים זה. היישומים שלה כוללים את הדברים הבאים:
- ייצוג הווקטורים המתמטיים ביישומים מדעיים והנדסיים
- ניתן ליישם תורים, ערימות באמצעות מבנה נתונים זה וכו'.
רוב הפעולות והפונקציות הנפוצות של CRUD הקשורות למבנה נתונים זה נדונות באופן מפורט בתרחישים עם תחביר וקטעי קוד.
נושא התוכן:
- הכנס אלמנט לוקטור
- הוסף אלמנטים מרובים לוקטור
- גש לאלמנטים מ-Vector
- עדכן את האלמנט בוקטור
- הסר אלמנט ספציפי מוקטור
- הסר את כל האלמנטים מוקטור
- איגוד הוקטורים
- צומת של וקטורים
- בדוק אם הוקטור ריק או לא
- חצו וקטור באמצעות Const_Iterator
- חצו וקטור באמצעות Reverse_Iterator
- דחוף את האלמנטים לתוך הוקטור
- פופ את האלמנטים מהווקטור
- החלף את הוקטורים
- קבל את האלמנט הראשון מהווקטור
- קבל את האלמנט האחרון מהווקטור
- הקצה ערכים חדשים לוקטור
- הרחב את הווקטור באמצעות Emplace()
- הרחב את הווקטור באמצעות Emplace_Back()
- אלמנט מקסימלי של וקטור
- מינימום אלמנט של וקטור
- סכום האלמנטים בוקטור
- כפל אלמנט של שני וקטורים
- תוצר נקודה של שני וקטורים
- המר סט לוקטור
- הסר את הרכיבים הכפולים
- המר וקטור לסט
- הסר את המחרוזות הריקות
- כתוב וקטור לקובץ טקסט
- צור וקטור מקובץ טקסט
הכנס אלמנט לוקטור
ה std::vector::insert() הפונקציה ב-C++ STL משמשת להכנסת האלמנטים במיקום שצוין.
תחביר:
וֶקטוֹר. לְהַכנִיס ( מיקום, אלמנט ) ;בואו נשתמש בפונקציה זו ונעביר את המיקום הראשון כפרמטר המציין את המיקום שבו יש להכניס את האלמנט ונספק את האלמנט כפרמטר השני.
ניתן להשתמש בפונקציה begin() כאן כדי להחזיר איטרטור המצביע על האלמנט הראשון של וקטור הקלט. על ידי הוספת המיקום לפונקציה זו, האלמנט מוכנס במיקום זה.
בואו ניצור את הווקטור 'תלמיד_שמות' מסוג מחרוזת ונכניס שתי מחרוזות במיקום הראשון והשני, בזו אחר זו, באמצעות הפונקציה insert() .
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// אתחול הווקטור - שמות_תלמידים
וֶקטוֹר < חוּט > שמות_תלמידים ;
cout << 'וקטור קיים: \n ' ;
ל ( אוטומטי אני : שמות_תלמידים ) cout << אני << endl ;
// הכנס את 'Sravan Kumar' בעמדה הראשונה
שמות_תלמידים. לְהַכנִיס ( שמות_תלמידים. התחל ( ) + 0 , 'שרוואן קומאר' ) ;
// הכנס את 'Sravan Kumar' בעמדה השנייה
שמות_תלמידים. לְהַכנִיס ( שמות_תלמידים. התחל ( ) + 1 , 'לליתה' ) ;
cout << 'וקטור סופי: \n ' ;
ל ( אוטומטי י : שמות_תלמידים ) cout << י << endl ;
}
תְפוּקָה:
בעבר, הוקטור 'שמות_תלמידים' היה ריק. לאחר ההכנסה, הווקטור מחזיק שני אלמנטים.
הוסף אלמנטים מרובים לוקטור
אנו משתמשים באותה פונקציה שהיא std::vector::insert() בתרחיש זה. אבל אנחנו צריכים להעביר את הפרמטרים הנוספים/שונים לאותה פונקציה כדי להכניס אלמנטים מרובים לווקטור.
תרחיש 1: הכנסת אלמנט בודד מספר פעמים
בתרחיש זה, אנו מוסיפים את אותו אלמנט מספר פעמים.
תחביר:
וֶקטוֹר. לְהַכנִיס ( מיקום, גודל, אלמנט ) ;לשם כך, עלינו להעביר את הגודל כפרמטר השני לפונקציה insert() . סך הפרמטרים המועברים לפונקציה זו הוא שלושה.
כאן:
- פרמטר המיקום מציין את מיקום האלמנט שיש להוסיף. אם הגודל גדול מ-1, אינדקס מיקום ההתחלה יהיה המיקום.
- פרמטר הגודל מציין את מספר הפעמים שיש להכניס אלמנט.
- פרמטר האלמנט לוקח את האלמנט שיוכנס לווקטור.
שקול את הווקטור 'שמות_תלמידים' עם שתי מחרוזות. הכנס את מיתרי 'לבניה' חמש פעמים במיקום השני.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// אתחול הווקטור - שמות_תלמידים
וֶקטוֹר < חוּט > שמות_תלמידים { 'שרוואן קומאר' , 'לליתה' } ;
cout << 'וקטור קיים: \n ' ;
ל ( אוטומטי אני : שמות_תלמידים ) cout << אני << endl ;
// הכנס 'לבניה' בעמדה השנייה 5 פעמים
שמות_תלמידים. לְהַכנִיס ( שמות_תלמידים. התחל ( ) + 1 , 5 , 'לבניה' ) ;
cout << ' \n וקטור סופי: \n ' ;
ל ( אוטומטי י : שמות_תלמידים ) cout << י << endl ;
}
תְפוּקָה:
בוקטור הקיים, 'Sravan Kumar' נמצא במיקום הראשון ו-'Llitha' במיקום השני. לאחר הכנסת 'לבניה' חמש פעמים (מהמיקום השני למיקום השישי), 'לליתה' עברה למיקום השביעי (אחרון).
תרחיש 2: הוספת אלמנטים מרובים
בתרחיש זה, נוסיף את האלמנטים השונים בכל פעם מוקטור אחר. אנחנו גם משתמשים באותה פונקציה כאן אבל התחביר והפרמטרים ישתנו.
תחביר:
וֶקטוֹר. לְהַכנִיס ( מיקום, ראשון_איטרטור, שני_איטרטור ) ;לשם כך, עלינו להעביר את הגודל כפרמטר השני לפונקציה insert() . סך הפרמטרים המועברים לפונקציה זו הוא שלושה.
כאן:
- פרמטר המיקום מציין את מיקום האלמנט שיש להוסיף.
- ה-'first_iterator' מציין את מיקום ההתחלה שממנו יש להכניס את האלמנטים (בעצם, באמצעות הפונקציה begin() מוחזר איטרטור שמצביע על האלמנט הראשון שקיים במיכל).
- ה-'second_iterator' מציין את מיקום הסיום עד אליו יש להכניס את האלמנטים (בעצם, באמצעות הפונקציה end() מוחזר איטרטור שמצביע ליד הנקודה האחרונה שקיימת במיכל).
צור שני וקטורים, 'marks1' ו-'marks2', מסוג מספר שלם. הכנס את כל האלמנטים הקיימים בווקטור 'marks2' למיקום הראשון של וקטור 'marks1'.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// אתחול הווקטור - סימנים1
וֶקטוֹר < int > סימנים 1 { 100 , 89 , 90 , 78 , 98 } ;
cout << 'וקטור ראשון: \n ' ;
ל ( אוטומטי אני : סימנים 1 ) cout << אני << endl ;
// אתחול הווקטור - סימנים2
וֶקטוֹר < int > סימנים 2 { 56 , ארבע חמש , 65 } ;
cout << 'וקטור שני: \n ' ;
ל ( אוטומטי י : סימנים 2 ) cout << י << endl ;
סימנים 1. לְהַכנִיס ( התחל ( סימנים 1 ) , התחל ( סימנים 2 ) , סוף ( סימנים 2 ) ) ;
// וקטור סופי
cout << 'וקטור ראשון-סופי: \n ' ;
ל ( אוטומטי איקס : סימנים 1 )
cout << איקס << '' ;
}
תְפוּקָה:
הווקטור הראשון (marks1) מכיל חמישה אלמנטים והווקטור השני (marks2) מחזיק שלושה אלמנטים. העברנו את הפרמטרים begin (marks1), begin(marks2), end(marks2) לפונקציה 'insert' כך שכל האלמנטים שקיימים בווקטור השני עוברים איטרציה ומוכנסים לוקטור הראשון בהתחלה. אז, הווקטור הראשון מכיל שמונה אלמנטים.
גש לאלמנטים מ-Vector
1. שימוש באופרטור []
בתרחישים מסוימים, ייתכן שתהיה לך דרישה להחזיר רק את האלמנטים הספציפיים מהווקטור. אין צורך בהחזרת כל האלמנטים. לכן, כדי להחזיר רק את האלמנטים הספציפיים המבוססים על האינדקס, נעשה שימוש באופרטור האינדקס ו-at() .
תחביר:
וֶקטוֹר [ index_position ]ב-C++, האינדקס מתחיל מ-0 עבור כל מבנה נתונים. אם האלמנט לא קיים, הוא מחזיר ריק (אין שגיאה או אזהרה מועלית).
שקול את וקטור 'מוצרים' עם חמישה פריטים. גש לכל האלמנטים אחד אחד באמצעות מיקום האינדקס.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - מוצרים עם 5 מחרוזות
וֶקטוֹר < חוּט > מוצרים { 'סַבּוֹן' , 'שַׁמפּוֹ' , 'שמן' , 'פירות' , 'ירקות' } ;
//גישה לאלמנטים מהמוצרים
cout << 'אלמנט ראשון:' << מוצרים [ 0 ] << endl ;
cout << 'אלמנט שני: ' << מוצרים [ 1 ] << endl ;
cout << 'אלמנט שלישי:' << מוצרים [ 2 ] << endl ;
cout << 'אלמנט רביעי:' << מוצרים [ 3 ] << endl ;
cout << 'אלמנט חמישי:' << מוצרים [ 4 ] << endl ;
// נסה לגשת לאלמנט ה-9
cout << 'אלמנט תשיעי:' << מוצרים [ 8 ] << endl ;
}
תְפוּקָה:
לא קיים אלמנט באינדקס 8. אז, ריק מוחזר.
2. שימוש בפונקציה At()
At() היא פונקציית חבר הדומה למקרה השימוש הקודם אך היא מחזירה את החריג 'std::out_of_range' כאשר האינדקס מחוץ לטווח מסופק לה.
תחביר:
וֶקטוֹר. בְּ- ( index_position )אנחנו צריכים להעביר את מיקום האינדקס לפונקציה הזו.
שקול את וקטור 'מוצרים' עם חמישה פריטים. גש לכל האלמנטים אחד אחד באמצעות מיקום האינדקס ונסה לגשת לאלמנט הקיים במיקום ה-9.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - מוצרים עם 5 מחרוזות
וֶקטוֹר < חוּט > מוצרים { 'סַבּוֹן' , 'שַׁמפּוֹ' , 'שמן' , 'פירות' , 'ירקות' } ;
//גישה לאלמנטים מהמוצרים
cout << 'אלמנט ראשון:' << מוצרים. בְּ- ( 0 ) << endl ;
cout << 'אלמנט שני: ' << מוצרים. בְּ- ( 1 ) << endl ;
cout << 'אלמנט שלישי:' << מוצרים. בְּ- ( 2 ) << endl ;
cout << 'אלמנט רביעי:' << מוצרים. בְּ- ( 3 ) << endl ;
cout << 'אלמנט חמישי:' << מוצרים. בְּ- ( 4 ) << endl ;
//גישה לאלמנטים שאינם בווקטור
cout << 'אלמנט תשיעי:' << מוצרים. בְּ- ( 8 ) << endl ;
}
תְפוּקָה:
מתרחשת שגיאה בגישה לאלמנט ה-9:
terminate נקרא לאחר זריקת מופע של 'std::out_of_range'מה ( ) : וֶקטוֹר :: _M_range_check : __n ( שהוא 8 ) >= זֶה - > גודל ( ) ( שהוא 5 )
עדכן אלמנט בוקטור
1. שימוש באופרטור []
באמצעות מיקום האינדקס, נוכל לעדכן את האלמנט בווקטור. האופרטור [] לוקח את מיקום האינדקס של האלמנט שיש לעדכן. הרכיב החדש יוקצה לאופרטור זה.
תחביר:
וֶקטוֹר [ index_position ] = אֵלֵמֶנטשקול את וקטור 'תלמיד_סימני' עם חמישה ערכים. עדכן את האלמנטים הקיימים במדדים 1 ו-3.
#include#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - student_marks
וֶקטוֹר < int > תלמיד_סימני { 98 , 78 , 90 , 67 , 89 } ;
cout << 'סימנים קיימים:' << endl ;
ל ( int itr : תלמיד_סימני )
cout << itr << endl ;
// עדכן את הרכיב ב-index-3 עם 100
תלמיד_סימני [ 3 ] = 100 ;
// עדכון אלמנט ב- index-1 עם 60
תלמיד_סימני [ 1 ] = 60 ;
cout << 'ציונים סופיים:' << endl ;
ל ( int itr : תלמיד_סימני )
cout << itr << endl ;
}
תְפוּקָה:
אנו יכולים לראות שהווקטור הסופי מחזיק את רכיבי העדכון במדדים 1 ו-3.
2. שימוש בפונקציה At()
בדומה לאופרטור האינדקס, at() היא בעצם פונקציית חבר אשר מעדכנת את הערך על סמך האינדקס באיטרטור. אם האינדקס שצוין בתוך הפונקציה הזו לא קיים, החריג 'std::out_of_range' נזרק.
וֶקטוֹר. בְּ- ( index_position ) = אֵלֵמֶנטשקול את וקטור 'מוצרים' עם חמישה פריטים. עדכן את כל האלמנטים הקיימים בוקטור עם אלמנטים אחרים.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - מוצרים עם 5 מחרוזות
וֶקטוֹר < חוּט > מוצרים { 'סַבּוֹן' , 'שַׁמפּוֹ' , 'שמן' , 'פירות' , 'ירקות' } ;
cout << 'מוצרים קיימים:' << endl ;
ל ( מחרוזת itr : מוצרים )
cout << itr << endl ;
//עדכון כל המחרוזות
מוצרים. בְּ- ( 0 ) = 'עוגה' ;
מוצרים. בְּ- ( 1 ) = 'שוקולד' ;
מוצרים. בְּ- ( 2 ) = 'פירות' ;
מוצרים. בְּ- ( 3 ) = 'בצלים' ;
מוצרים. בְּ- ( 4 ) = 'משקאות קלים' ;
cout << ' \n מוצרים סופיים: ' << endl ;
ל ( מחרוזת itr : מוצרים )
cout << itr << endl ;
}
תְפוּקָה:
הסר אלמנט ספציפי מוקטור
ב-C++, ה std::vector::erase() הפונקציה משמשת להסרת אלמנט/טווח אלמנטים ספציפיים מווקטור. האלמנטים מוסרים על סמך מיקומי האיטרטור.
תחביר:
וֶקטוֹר. לִמְחוֹק ( מיקום איטרטור )בוא נראה את התחביר להסרת האלמנט הספציפי מווקטור. אנו יכולים להשתמש בפונקציות begin() או end() כדי לקבל את המיקום של האלמנט שקיים בוקטור להסרה.
שקול את וקטור 'מוצרים' עם חמישה פריטים.
- הסר את האלמנט השלישי על ידי ציון האיטרטור begin(). Begin() מצביע על האלמנט הראשון בווקטור. אם נוסיף שניים לפונקציה הזו, זה מצביע על האלמנט השלישי.
- הסר את האלמנט האחרון על ידי ציון האיטרטור end() . End() מצביע על האלמנט האחרון בווקטור.
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - מוצרים עם 5 מחרוזות
וֶקטוֹר < חוּט > מוצרים { 'סַבּוֹן' , 'שַׁמפּוֹ' , 'שמן' , 'פירות' , 'ירקות' } ;
cout << 'מוצרים קיימים:' << endl ;
ל ( מחרוזת itr : מוצרים )
cout << itr << endl ;
// הסר אלמנט שלישי
מוצרים. לִמְחוֹק ( מוצרים. התחל ( ) + 2 ) ;
cout << ' \n לאחר הסרת הרכיב השלישי: \n ' ;
ל ( מחרוזת itr : מוצרים )
cout << itr << endl ;
// הסר את האלמנט האחרון
מוצרים. לִמְחוֹק ( מוצרים. סוֹף ( ) ) ;
cout << ' \n לאחר הסרת האלמנט האחרון: \n ' ;
ל ( מחרוזת itr : מוצרים )
cout << itr << endl ;
}
תְפוּקָה:
כעת, ישנם רק שלושה אלמנטים ('סבון', 'שמפו', 'פירות') שקיימים בוקטור 'מוצרים'.
הסר את כל האלמנטים מוקטור
תרחיש 1: הסר טווח של אלמנטים מהוקטור
בואו נשתמש בפונקציה std::vector::erase() כדי להסיר מספר אלמנטים בטווח.
תחביר:
וֶקטוֹר. לִמְחוֹק ( איטרטור ראשון, איטרטור אחרון )שני האיטרטורים (begin() מצביעים על האלמנט הראשון ו-end() מצביעים על פונקציות האלמנט האחרון) משמשים לציון הטווח.
שקול את וקטור 'מוצרים' עם חמישה פריטים והסר את כל האלמנטים מהמיקום השני. כדי להשיג זאת, האיטרטור הראשון הוא begin (products)+1 שמצביע על האלמנט השני והאיטרטור השני הוא end (products).
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - מוצרים עם 5 מחרוזות
וֶקטוֹר < חוּט > מוצרים { 'סַבּוֹן' , 'שַׁמפּוֹ' , 'שמן' , 'פירות' , 'ירקות' } ;
cout << 'מוצרים קיימים:' << endl ;
ל ( מחרוזת itr : מוצרים )
cout << itr << endl ;
// הסר את כל האלמנטים מהמיקום השני
מוצרים. לִמְחוֹק ( התחל ( מוצרים ) + 1 ,סוֹף ( מוצרים ) ) ;
cout << ' \n מוצרים סופיים: \n ' ;
ל ( מחרוזת itr : מוצרים )
cout << itr << endl ;
}
תְפוּקָה:
כעת, יש רק אלמנט אחד ('סבון') שקיים בווקטור 'מוצרים'.
תרחיש 2: הסר את כל האלמנטים מהווקטור
בואו נשתמש ב- std::vector::clear() פונקציה להסיר את כל האלמנטים מהווקטור.
תחביר:
וֶקטוֹר. ברור ( )לא מועברים פרמטרים לפונקציה זו.
שקול את אותו וקטור שהיה בשימוש בתרחיש הראשון והסר את כל האלמנטים באמצעות הפונקציה clear() .
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - מוצרים עם 5 מחרוזות
וֶקטוֹר < חוּט > מוצרים { 'סַבּוֹן' , 'שַׁמפּוֹ' , 'שמן' , 'פירות' , 'ירקות' } ;
cout << 'מוצרים קיימים:' << endl ;
ל ( מחרוזת itr : מוצרים )
cout << itr << endl ;
// הסר את כל האלמנטים מהמוצרים
מוצרים. ברור ( ) ;
cout << ' \n מוצרים סופיים: \n ' ;
ל ( מחרוזת itr : מוצרים )
cout << itr << endl ;
}
תְפוּקָה:
אנו יכולים לראות שאין אלמנטים בווקטור 'מוצרים'.
איגוד הוקטורים
אפשר לבצע את פעולת UNION בוקטורים באמצעות הפונקציה std::set_union() . האיחוד מחזיר את האלמנטים הייחודיים מהווקטורים על ידי התעלמות מהאלמנטים הכפולים. אנחנו צריכים להעביר את שני האיטרטורים לפונקציה הזו. יחד עם זה, יש לעבור איטרטור פלט המאחסן את התוצאה שמוחזרת על ידי שני האיטרטורים.
תחביר:
set_union ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator res ) ;כאן:
- ה-'first1' מצביע על האלמנט הראשון של האיטרטור הראשון (וקטור).
- ה-'last1' מצביע על האלמנט האחרון של האיטרטור הראשון (וקטור).
- ה-'first2' מצביע על האלמנט הראשון של האיטרטור השני (וקטור).
- ה-'last2' מצביע על האלמנט האחרון של האיטרטור השני (וקטור).
צור שני וקטורים - 'נושאים1' ו'נושאים2' - מסוג מספר שלם.
- מיין את שני הוקטורים באמצעות הפונקציה sort() על ידי העברת האיטרטורים.
- צור וקטור פלט (איטרטור).
- מצא את האיחוד של שני הוקטורים הללו באמצעות הפונקציה std::set_union() . השתמש ב-begin() בתור האיטרטור הראשון וב-end() בתור האיטרטור האחרון.
- חזרו על וקטור הפלט כדי להציג את האלמנטים המוחזרים על ידי הפונקציה.
#include
#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - סימנים1
וֶקטוֹר < int > סימנים 1 = { 100 , 90 , 80 , 70 , 60 } ;
// צור וקטור - סימנים2
וֶקטוֹר < int > סימנים 2 = { 80 , 90 , 60 , 70 , 100 } ;
// מיין את שני הוקטורים
סוג ( סימנים 1. התחל ( ) , סימן 1. סוֹף ( ) ) ;
סוג ( סימנים 2. התחל ( ) , סימנים 2. סוֹף ( ) ) ;
וֶקטוֹר < int > פלט וקטור ( סימנים 1. גודל ( ) + סימנים 2. גודל ( ) ) ;
וֶקטוֹר < int > :: איטרטור אני, ס ;
אני = set_union ( סימנים 1. התחל ( ) , סימן 1. סוֹף ( ) ,
סימנים 2. התחל ( ) ,סימנים2. סוֹף ( ) ,
פלט וקטור. התחל ( ) ) ;
cout << ' \n סימנים1 U סימנים2: \n ' ;
ל ( ס = פלט וקטור. התחל ( ) ; ס ! = אני ; ++ ס )
cout << * ס << '' << ' \n ' ;
}
תְפוּקָה:
ישנם רק חמישה אלמנטים ייחודיים בשני הוקטורים (נושאים1 ונושאים2).
צומת של וקטורים
ניתן למצוא את החתך של שני וקטורים באמצעות הפונקציה std::set_intersection() . צומת מחזירה את האלמנטים הקיימים בשני הוקטורים.
תחביר:
set_intersection ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator res ) ;את הפרמטרים המועברים לפונקציה set_union() ניתן להעביר גם לפונקציה set_intersection() זו.
צור שני וקטורים - 'נושאים1' ו'נושאים2' - מסוג מספר שלם.
- מיין את שני הוקטורים באמצעות הפונקציה sort() על ידי העברת האיטרטורים.
- צור וקטור פלט (איטרטור).
- מצא את החתך של שני הוקטורים הללו באמצעות הפונקציה std::set_intersection() . השתמש ב-begin() בתור האיטרטור הראשון וב-end() בתור האיטרטור האחרון.
- חזרו על וקטור הפלט כדי להציג את האלמנטים המוחזרים על ידי הפונקציה.
#include
#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - סימנים1
וֶקטוֹר < int > סימנים 1 = { 100 , 10 , 80 , 40 , 60 } ;
// צור וקטור - סימנים2
וֶקטוֹר < int > סימנים 2 = { חמישים , 90 , 60 , 10 , 100 } ;
// מיין את שני הוקטורים
סוג ( סימנים 1. התחל ( ) , סימן 1. סוֹף ( ) ) ;
סוג ( סימנים 2. התחל ( ) , סימנים 2. סוֹף ( ) ) ;
וֶקטוֹר < int > פלט וקטור ( סימנים 1. גודל ( ) + סימנים 2. גודל ( ) ) ;
וֶקטוֹר < int > :: איטרטור אני, ס ;
אני = set_intersection ( סימנים 1. התחל ( ) , סימן 1. סוֹף ( ) ,
סימנים 2. התחל ( ) ,סימנים2. סוֹף ( ) ,
פלט וקטור. התחל ( ) ) ;
cout << ' \n סימנים1 ∩ סימנים2: \n ' ;
ל ( ס = פלט וקטור. התחל ( ) ; ס ! = אני ; ++ ס )
cout << * ס << '' << ' \n ' ;
}
תְפוּקָה:
קיימים רק שלושה אלמנטים בשני הוקטורים (נושאים1 ונושאים2).
בדוק אם הוקטור ריק או לא
לפני עבודה על וקטורים, חשוב לבדוק האם הווקטור ריק או לא. זה גם תרגול טוב בפרויקטי תוכנה לבדוק אם הווקטור ריק או לא לפני ביצוע הפעולות כמו פעולות CRUD וכו'.
1. שימוש ב-Std::vector::empty()
פונקציה זו מחזירה 1 אם הווקטור ריק (אינו מכיל אלמנט כלשהו). אחרת, 0 מוחזר. שום פרמטר לא מועבר לפונקציה זו.
2. שימוש ב Std::vector::size()
הפונקציה std::vector::size() מחזירה את המספר השלם המייצג את המספר הכולל של האלמנטים הקיימים בווקטור.
צור שני וקטורים - 'מכללה1' ו'מכללה2'. 'College1' מכיל חמישה אלמנטים ו-'college2' ריק. החל את שתי הפונקציות על שני הוקטורים ובדוק את הפלט.
#include <אלגוריתם>#include
#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - מכללה1
וֶקטוֹר < חוּט > מכללה 1 = { 'מכללה-א' , 'מכללה ב'' , 'מכללה-ג' , 'מכללה-D' , 'מכללה-E' } ;
// צור וקטור - מכללה2
וֶקטוֹר < חוּט > מכללה 2 ;
// ריק()
cout << מכללה 1. ריק ( ) << endl ;
cout << מכללה 2. ריק ( ) << endl ;
// גודל()
cout << מכללה 1. גודל ( ) << endl ;
cout << מכללה 2. גודל ( ) << endl ;
}
תְפוּקָה:
הפונקציה empty() מחזירה 0 עבור 'college1' ו-1 עבור 'college2'. הפונקציה size() מחזירה חמש עבור 'college1' ו-0 עבור 'college2'.
חצו וקטור באמצעות Const_Iterator
כאשר אתה עובד על קונטיינרים של C++ כמו סטים, וקטורים וכו', ניתן לבצע איטרציה על כל האלמנטים שקיימים בקונטיינר מבלי לשנות אותם. ה const_iterator הוא אחד האיטרטורים שמשיגים תרחיש זה. ה-cbegin() (מצביע על האלמנט הראשון בוקטור) ו-cend() (מצביע על האלמנט האחרון בווקטור) הן שתי הפונקציות שמסופקות על ידי כל מיכל המשמשות להחזרת האיטרטור הקבוע להתחלה ולסוף של המיכל. בזמן איטרציה של הווקטור, אנו יכולים להשתמש בשתי הפונקציות הללו.
- בואו ניצור וקטור בשם 'מחלקות' עם חמש מחרוזות.
- הכריז על const_iterator - ctr מסוג
. - חזור על המחלקות באמצעות האיטרטור הקודם באמצעות לולאת 'ל' והצג אותה.
#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - מחלקות
וֶקטוֹר < חוּט > מחלקות = { 'מכירות' , 'שֵׁרוּת' ,
'HR' , 'זה' , 'אחרים' } ;
וֶקטוֹר < חוּט > :: const_iterator ctr ;
// חזרו על המחלקות באמצעות const_iterator - ctr.
ל ( ctr = מחלקות. cbegin ( ) ; ctr ! = מחלקות. כמה ( ) ; ctr ++ ) {
cout << * ctr << endl ;
}
}
תְפוּקָה:
חצו וקטור באמצעות ה-Reverse_Iterator
ה reverse_iterator הוא גם איטרטור שדומה ל-const_iterator אבל הוא מחזיר את האלמנטים הפוך. ה-rbegin() (מצביע על האלמנט האחרון בווקטור) ו-rend() (מצביע על האלמנט הראשון בווקטור) הן שתי הפונקציות שמסופקות על ידי כל מיכל המשמשות להחזרת האיטרטור הקבוע לסוף ולהתחלה של המיכל.
- בואו ניצור וקטור בשם 'מחלקות' עם חמש מחרוזות.
- הכריז על reverse_iterator - rtr מסוג
. - חזור על המחלקות באמצעות האיטרטור הקודם באמצעות לולאת 'for' והצג אותה.
#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - מחלקות
וֶקטוֹר < חוּט > מחלקות = { 'מכירות' , 'שֵׁרוּת' ,
'HR' , 'זה' , 'אחרים' } ;
וֶקטוֹר < חוּט > :: reverse_iterator rtr ;
// איטרציה על המחלקות באמצעות reverse_iterator - rtr.
ל ( rtr = מחלקות. rbegin ( ) ; rtr ! = מחלקות. עושה ( ) ; rtr ++ ) {
cout << * rtr << endl ;
}
}
תְפוּקָה:
דחוף את האלמנטים לתוך הוקטור
דחיפה או הוספה של האלמנטים לוקטור היא הכנסה חד-כיוונית שניתן לבצע באמצעות vector::push_back() פוּנקצִיָה.
תחביר:
וֶקטוֹר. התנגדות ( אֵלֵמֶנט )נדרש אלמנט כדי להידחף לווקטור כפרמטר.
בואו ניצור וקטור ריק בשם 'מחלקות' עם חמש מחרוזות ונדחוף שתי מחרוזות אחת אחרי השנייה באמצעות הפונקציה push_back() .
#include#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// אתחול וקטור - מחלקות
וֶקטוֹר < חוּט > מחלקות ;
cout << 'מחלקות בפועל:' << endl ;
ל ( אוטומטי itr = מחלקות. התחל ( ) ; itr ! = מחלקות. סוֹף ( ) ; ++ itr )
cout << * itr << endl ;
// לחץ על 'מכירות'
מחלקות. התנגדות ( 'מכירות' ) ;
// לדחוף את זה'
מחלקות. התנגדות ( 'זה' ) ;
cout << ' \n מחלקות גמר:' << endl ;
ל ( אוטומטי itr = מחלקות. התחל ( ) ; itr ! = מחלקות. סוֹף ( ) ; ++ itr )
cout << * itr << endl ;
}
תְפוּקָה:
ראשית, אנו דוחפים את ה'מכירות'. לאחר מכן, 'IT' נדחף לווקטור. כעת, וקטור ה'מחלקות' מכיל שני אלמנטים.
פופ את האלמנטים מהווקטור
אם ברצונך למחוק את הפריט האחרון שקיים בווקטור, השתמש ב- vector::pop_back() פונקציה היא הגישה הטובה ביותר. הוא מוחק את האלמנט האחרון שקיים בווקטור.
תחביר:
וֶקטוֹר. pop_back ( )אין צורך בפרמטר עבור פונקציה זו. זה מראה את ההתנהגות הלא מוגדרת אם ננסה למחוק את האלמנט האחרון מוקטור ריק.
בואו ניצור וקטור ריק בשם 'מחלקות' עם חמש מחרוזות ונמחק את האלמנט האחרון באמצעות הפונקציה הקודמת. הצג את הווקטור בשני המקרים.
#include#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// אתחול וקטור - מחלקות
וֶקטוֹר < חוּט > מחלקות = { 'מכירות' , 'זה' , 'שֵׁרוּת' , 'שיווק' , 'HR' } ;
cout << 'מחלקות בפועל:' << endl ;
ל ( אוטומטי itr = מחלקות. התחל ( ) ; itr ! = מחלקות. סוֹף ( ) ; ++ itr )
cout << * itr << endl ;
// מחק את האלמנט האחרון
מחלקות. pop_back ( ) ;
cout << ' \n מחלקות גמר:' << endl ;
ל ( אוטומטי itr = מחלקות. התחל ( ) ; itr ! = מחלקות. סוֹף ( ) ; ++ itr )
cout << * itr << endl ;
}
תְפוּקָה:
'HR' הוא האלמנט האחרון שקיים בווקטור 'מחלקות'. אז, הוא מוסר מהווקטור והווקטור הסופי מכיל 'מכירות', 'IT', 'שירות' ו'שיווק'.
החלף את הוקטורים
ה vector::swap() הפונקציה ב-C++ STL משמשת להחלפת כל האלמנטים הקיימים בשני וקטורים.
תחביר:
first_vector. לְהַחלִיף ( וקטור שני )זה לא מתחשב בגודל של הוקטורים אבל הוקטורים צריכים להיות מאותו סוג (שגיאה נגרמת אם סוגי הוקטורים שונים).
בואו ניצור שני וקטורים - 'פירות' ו'ירקות' - מסוג מחרוזת בגדלים שונים. החלף כל אחד מהם והצג את הוקטורים בשני המקרים.
#include#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// אתחול וקטור - פירות
וֶקטוֹר < חוּט > פירות = { 'תפוח עץ' , 'מנגו' } ;
cout << 'פירות בפועל:' << endl ;
ל ( אוטומטי itr = פירות. התחל ( ) ; itr ! = פירות. סוֹף ( ) ; ++ itr )
cout << * itr << endl ;
// אתחול וקטור - ירקות
וֶקטוֹר < חוּט > ירקות = { 'תפוח אדמה' , 'עגבנייה' , 'ברינג'ל' } ;
cout << ' \n ירקות בפועל:' << endl ;
ל ( אוטומטי itr = ירקות. התחל ( ) ; itr ! = ירקות. סוֹף ( ) ; ++ itr )
cout << * itr << endl ;
// החליפו את האלמנטים בשני הוקטורים
פירות. לְהַחלִיף ( ירקות ) ;
cout << ' \n פירות לאחר החלפה:' << endl ;
ל ( אוטומטי itr = פירות. התחל ( ) ; itr ! = פירות. סוֹף ( ) ; ++ itr )
cout << * itr << endl ;
cout << ' \n ירקות לאחר החלפה:' << endl ;
ל ( אוטומטי itr = ירקות. התחל ( ) ; itr ! = ירקות. סוֹף ( ) ; ++ itr )
cout << * itr << endl ;
}
תְפוּקָה:
בעבר, וקטור 'פירות' מחזיק שני אלמנטים והוקטור 'ירקות' מחזיק שלושה אלמנטים. לאחר ההחלפה, וקטור ה'פירות' מכיל שלושה אלמנטים והוקטור 'הירקות' מחזיק שני אלמנטים.
קבל את האלמנט הראשון מהווקטור
במקרים מסוימים, הדרישה היא להחזיר רק את האלמנט הראשון מהווקטור. הפונקציה vector::front() ב-C++ STL שואבת רק את האלמנט הראשון מהווקטור.
תחביר:
וֶקטוֹר. חֲזִית ( )פונקציה זו לא תיקח שום פרמטר. אם הווקטור ריק, נזרקת שגיאה.
בואו ניצור שני וקטורים - 'פירות' ו'ירקות' - מסוג מחרוזת וננסה להביא את האלמנט הראשון בנפרד משני הוקטורים.
#include#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - פירות עם 2 אלמנטים
וֶקטוֹר < חוּט > פירות = { 'תפוח עץ' , 'מנגו' } ;
// החזר את האלמנט הראשון
cout << פירות. חֲזִית ( ) << endl ;
// אתחול וקטור - ירקות
וֶקטוֹר < חוּט > ירקות ;
// נסה להחזיר את האלמנט הראשון
cout << ירקות. חֲזִית ( ) ;
}
תְפוּקָה:
'תפוח' הוא האלמנט הראשון שקיים בווקטור 'פירות'. אז זה מוחזר. אבל נפלטת שגיאה כאשר אנו מנסים להביא את האלמנט הראשון מהוקטור 'הירקות' מכיוון שהוא ריק.
קבל את האלמנט האחרון מהווקטור
הפונקציה vector::end() ב-C++ STL שואבת רק את האלמנט האחרון מהווקטור.
תחביר:
וֶקטוֹר. חזור ( )פונקציה זו לא תיקח שום פרמטר. אם הווקטור ריק, נזרקת שגיאה.
בואו ניצור שני וקטורים - 'פירות' ו'ירקות' - מסוג מחרוזת וננסה להביא את האלמנט האחרון בנפרד משני הוקטורים.
#include#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - פירות עם 2 אלמנטים
וֶקטוֹר < חוּט > פירות = { 'תפוח עץ' , 'מנגו' } ;
// אחזר את האלמנט האחרון
cout << פירות. חזור ( ) << endl ;
// אתחול וקטור - ירקות
וֶקטוֹר < חוּט > ירקות ;
// נסה להביא את האלמנט האחרון
cout << ירקות. חזור ( ) ;
}
תְפוּקָה:
'מנגו' הוא האלמנט האחרון שקיים בוקטור ה'פירות'. אז זה מוחזר. אבל נגרמת שגיאה כאשר אנו מנסים להביא את האלמנט האחרון מהוקטור 'הירקות' מכיוון שהוא ריק.
הקצה ערכים חדשים לוקטור
בתרחישים מסוימים, אם ברצונך לעדכן את כל הערכים בערך החדש או ליצור וקטור עם אותם ערכים, השימוש בפונקציה vector::assign() היא הגישה הטובה ביותר. באמצעות פונקציה זו, אנו יכולים:
- צור את הווקטור עם כל האלמנטים הדומים
- שנה את הווקטור הקיים עם אותו אלמנט
תחביר:
וֶקטוֹר. לְהַקְצוֹת ( גודל, ערך )שני פרמטרים נדרשים לפונקציה זו.
כאן:
- הגודל מציין את מספר האלמנטים שיוקצו.
- הערך מציין את האלמנט שיש להקצות.
בואו ניצור וקטור בשם 'marks1' עם חמישה ערכים ונעדכן את הווקטור הזה בארבעה אלמנטים כך שכל האלמנטים בוקטור המעודכן יהיו שווים ל-20.
#include <אלגוריתם>#include
#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - סימנים1
וֶקטוֹר < int > סימנים 1 = { 100 , 90 , 80 , 70 , 60 } ;
cout << 'וקטור בפועל:' << endl ;
ל ( int אני = 0 ; אני < סימנים 1. גודל ( ) ; אני ++ )
cout << סימנים 1 [ אני ] << endl ;
סימנים 1. לְהַקְצוֹת ( 4 , עשרים ) ;
cout << ' \n וקטור מעודכן:' << endl ;
ל ( int אני = 0 ; אני < סימנים 1. גודל ( ) ; אני ++ )
cout << סימנים 1 [ אני ] << endl ;
}
תְפוּקָה:
בעבר, הווקטור מכיל חמישה אלמנטים שונים. כעת, הוא מכיל רק ארבעה אלמנטים וכולם שווים ל-20.
הרחב את הווקטור באמצעות Emplace()
אנחנו כבר יודעים שאלמנטים חדשים מוכנסים באופן דינמי בכל מיקום בווקטור. זה אפשרי באמצעות הפונקציה vector::emplace() . בואו נסתכל במהירות על התחביר והפרמטרים המקובלים על ידי פונקציה זו.
תחביר:
וֶקטוֹר. מקום ( const_iterator position, element )שני פרמטרים חובה מועברים לפונקציה זו.
כאן:
- הפרמטר הראשון לוקח את המיקום כך שנוכל להכניס את האלמנט בכל מיקום. אנו יכולים לקבל את המיקום באמצעות פונקציית האיטרטור begin() או end().
- הפרמטר השני הוא האלמנט שיש להכניס לווקטור.
שקול את וקטור 'כימיקלים' עם שני יסודות.
- הכנס 'מנגן' בעמדה הראשונה - התחל (כימיקלים)
- הכנס 'נחושת' במיקום האחרון - סוף (כימיקלים)
- הכנס 'גופרית' במיקום השלישי - התחל (כימיקלים)+2
#include
#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - כימיקלים
וֶקטוֹר < חוּט > כימיקלים = { 'חַמצָן' , 'שיתוף' } ;
cout << 'כימיקלים בפועל:' << endl ;
ל ( int אני = 0 ; אני < כימיקלים. גודל ( ) ; אני ++ )
cout << כימיקלים [ אני ] << endl ;
// הכנס אלמנט במיקום הראשון
כימיקלים. מקום ( התחל ( כימיקלים ) , 'מַנגָן' ) ;
// הכנס אלמנט במיקום האחרון
כימיקלים. מקום ( סוֹף ( כימיקלים ) , 'נְחוֹשֶׁת' ) ;
// הכנס אלמנט במיקום השלישי
כימיקלים. מקום ( התחל ( כימיקלים ) + 2 , 'גוֹפרִית' ) ;
cout << ' \n כימיקלים סופיים:' << endl ;
ל ( int אני = 0 ; אני < כימיקלים. גודל ( ) ; אני ++ )
cout << כימיקלים [ אני ] << endl ;
}
תְפוּקָה:
כעת, הווקטור הסופי מכיל חמישה אלמנטים (המסופקים בצילום המסך הבא).
הרחב את הווקטור באמצעות Emplace_Back()
ניתן להוסיף אלמנט (הוספת בסוף הווקטור) שניתן לעשות באמצעות ה- vector::emplace_back() פוּנקצִיָה.
תחביר:
וֶקטוֹר. emplace_back ( אֵלֵמֶנט )חובה להעביר את האלמנט שיש לצרף לווקטור כפרמטר.
בואו נוסיף שני אלמנטים בזה אחר זה באמצעות הפונקציה emplace_back() .
#include <אלגוריתם>#include
#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - כימיקלים
וֶקטוֹר < חוּט > כימיקלים = { 'חַמצָן' , 'שיתוף' } ;
cout << 'כימיקלים בפועל:' << endl ;
ל ( int אני = 0 ; אני < כימיקלים. גודל ( ) ; אני ++ )
cout << כימיקלים [ אני ] << endl ;
// הכנס מנגן בסוף הווקטור
כימיקלים. emplace_back ( 'מַנגָן' ) ;
// הכנס מנגן בסוף הווקטור
כימיקלים. emplace_back ( 'נְחוֹשֶׁת' ) ;
cout << ' \n כימיקלים סופיים:' << endl ;
ל ( int אני = 0 ; אני < כימיקלים. גודל ( ) ; אני ++ )
cout << כימיקלים [ אני ] << endl ;
}
תְפוּקָה:
כעת, הווקטור הסופי מכיל ארבעה אלמנטים לאחר הוספת 'מנגן' ו'נחושת'.
אלמנט מקסימלי של וקטור
- צור וקטור עם כמה אלמנטים.
- כדי למצוא את האלמנט המקסימלי שקיים בווקטור, השתמש בפונקציה *max_element() שמקבלת שני איטרטורים כארגומנטים. שני פרמטרים אלה פועלים כטווח והרכיב המקסימלי מוחזר בתוך הטווח המסופק. מיקום ההתחלה הוא begin() והמיקום האחרון הוא end().
בואו ניקח בחשבון וקטור בשם 'item_costs' שמכיל חמישה ערכי סוג מספר שלם ונחזיר את האלמנט המקסימלי.
#include#include
#include <אלגוריתם>
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - פריט_עלות
וֶקטוֹר < int > פריט_עלות = { 8900 , 5677 , 200 , 1000 , 2300 } ;
cout << 'עלות פריטים: \n ' ;
ל ( int אני = 0 ; אני < פריט_עלות. גודל ( ) ; אני ++ )
cout << פריט_עלות [ אני ] << endl ;
// החזר את האלמנט המקסימלי מהווקטור שלמעלה - item_costs
cout << ' \n עלות מקסימלית: ' << * max_element ( התחל ( פריט_עלות ) ,סוֹף ( פריט_עלות ) ) ;
}
תְפוּקָה:
כאן, 8900 הוא האלמנט המקסימלי מבין כל האלמנטים הקיימים בווקטור 'עלות_פריטים'.
מינימום אלמנט של וקטור
- צור וקטור עם כמה אלמנטים.
- כדי למצוא את האלמנט המינימלי שקיים בווקטור, השתמש בפונקציה *min_element() שמקבלת שני איטרטורים כארגומנטים. שני הפרמטרים הללו פועלים כטווח והאלמנט המינימלי (פחות מכל שאר האלמנטים) מוחזר בתוך הטווח המסופק. מיקום ההתחלה הוא begin() והמיקום האחרון הוא end().
השתמש באותו וקטור שנוצר כדי למצוא את האלמנט המקסימלי ולמצוא את האלמנט המינימלי באמצעות הפונקציה *min_element() .
#include#include
#include <אלגוריתם>
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - פריט_עלות
וֶקטוֹר < int > פריט_עלות = { 8900 , 5677 , 200 , 1000 , 2300 } ;
cout << 'עלות פריטים: \n ' ;
ל ( int אני = 0 ; אני < פריט_עלות. גודל ( ) ; אני ++ )
cout << פריט_עלות [ אני ] << endl ;
// החזר את האלמנט המינימלי מהווקטור לעיל - item_costs
cout << ' \n עלות מינימלית: ' << * min_element ( התחל ( פריט_עלות ) ,סוֹף ( פריט_עלות ) ) ;
}
תְפוּקָה:
כאן, 200 הוא האלמנט המינימלי מבין כל האלמנטים הקיימים בווקטור 'עלות_פריטים'.
סכום האלמנטים בוקטור
כדי להחזיר את הסכום של כל האלמנטים הקיימים בווקטור, ה- לִצְבּוֹר() נעשה שימוש בפונקציה ב-C++ STL. הוא מקבל שלושה פרמטרים. הפרמטר הראשון לוקח את האינדקס הראשון שמייצג את אלמנט ההתחלה בטווח (ציין את האיטרטור begin() והפרמטר השני לוקח את האינדקס האחרון שמייצג את אלמנט הסיום בטווח (ציין את האיטרטור end() . לבסוף, עלינו להעביר את הערך ההתחלתי של הסכום (במקרה שלנו, הוא 0).
לִצְבּוֹר ( first_index, last_index, initial_val ) ;צור וקטור בשם 'item_costs' עם חמישה אלמנטים מסוג מספר שלם וחשב את הסכום.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - פריט_עלות
וֶקטוֹר < int > פריט_עלות = { 8900 , 5677 , 200 , 1000 , 2300 } ;
cout << 'עלות פריטים: \n ' ;
ל ( int אני = 0 ; אני < פריט_עלות. גודל ( ) ; אני ++ )
cout << פריט_עלות [ אני ] << endl ;
// החזר את הסכום של כל האלמנטים בוקטור לעיל - פריט_עלות
cout << ' \n עלות כוללת: ' << לִצְבּוֹר ( התחל ( פריט_עלות ) ,סוֹף ( פריט_עלות ) , 0 ) ;
}
תְפוּקָה:
הסכום של 8900, 5677, 200, 1000, 2300 הוא 18077.
כפל אלמנט של שני וקטורים
- צור שני וקטורים עם סוג מספרי ושני וקטורים חייבים להיות באותו גודל (מספר האלמנטים הכולל הקיימים בווקטור הראשון = המספר הכולל של האלמנטים הקיימים בוקטור השני).
- הכריז על וקטור חדש והשתמש ב- עבור לולאה , בצע את פעולת הכפל בשני אלמנטים בכל איטרציה, ואחסן את הערך בווקטור שנוצר באמצעות הפונקציה push_back() . ל ( int itr = 0 ; אני < first_vec. גודל ( ) ; itr ++ )
- הצג את האלמנטים הקיימים בווקטור המתקבל על ידי איטרציה שלו.
{
תוצאה_וקטור. התנגדות ( first_vec [ itr ] * דבר שני [ itr ] ) ;
}
צור וקטור בשם 'item_costs' עם חמישה אלמנטים מסוג מספר שלם וחשב את הסכום.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור שני וקטורים - מוצרים1 ומוצר2 עם 5 אלמנטים כל אחד
וֶקטוֹר < int > מוצרים1 = { 10 , עשרים , 30 , 40 , חמישים } ;
וֶקטוֹר < int > מוצרים2 = { חמישים , 40 , 30 , 70 , 60 } ;
וֶקטוֹר < int > תוצאות_מוצרים ;
// בצע כפל חכם אלמנט
ל ( int אני = 0 ; אני < מוצרים1. גודל ( ) ; אני ++ ) {
תוצאות_מוצרים. התנגדות ( מוצרים1 [ אני ] * מוצרים2 [ אני ] ) ;
}
// הצג את הווקטור שנוצר
cout << 'כפל וקטור: \n ' ;
ל ( int מילואים : תוצאות_מוצרים )
cout << מילואים << endl ;
}
תְפוּקָה:
איטרציה - 1 : 10 * חמישים => 500איטרציה - 2 : עשרים * 40 => 800
איטרציה - 3 : 30 * 30 => 900
איטרציה - 4 : 40 * 70 => 2800
איטרציה - 5 : חמישים * 60 => 3000
תוצר נקודה של שני וקטורים
במקרה של וקטורים C++, מכפלת הנקודה מוגדרת כ'סכום התוצרים של הערכים התואמים של שני רצפי הוקטורים'.
תחביר:
מוצר פנימי ( וקטור1 ראשון, וקטור1 אחרון, וקטור2 ראשון, Initial_Val )השתמש בפונקציה inner_product() כדי להחזיר את מוצר הנקודה. פונקציה זו לוקחת ארבעה פרמטרים נדרשים.
כאן:
- הפרמטר הראשון מתייחס לאיטרטור שמצביע על תחילתו של הווקטור הראשון (ציין באמצעות הפונקציה begin()).
- הפרמטר השני מתייחס לאיטרטור שמצביע על הסוף של הווקטור הראשון (ציין באמצעות הפונקציה end()).
- הפרמטר השלישי מתייחס לאיטרטור המצביע על תחילתו של הווקטור השני (ציין באמצעות הפונקציה begin()).
- יש להעביר את הערך ההתחלתי כפרמטר האחרון שהוא מספר שלם לצבירה של תוצר הנקודה.
השתמש באותה תוכנית שנוצרה עבור הכפל של שני וקטורים והשתמש בפונקציה innsr_product() כדי למצוא את מכפלת הנקודה של שני הוקטורים.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור שני וקטורים - מוצרים1 ומוצר2 עם 5 אלמנטים כל אחד
וֶקטוֹר < int > מוצרים1 = { 10 , עשרים , 30 , 40 , חמישים } ;
וֶקטוֹר < int > מוצרים2 = { חמישים , 40 , 30 , 70 , 60 } ;
// הצג את הווקטור שנוצר
cout << 'מוצר נקודה של מוצרים1 ומוצרים2: ' ;
cout << מוצר פנימי ( התחל ( מוצרים1 ) ,סוֹף ( מוצרים1 ) ,התחל ( מוצרים2 ) , 0 ) ;
}
תְפוּקָה:
( 10 * חמישים ) + ( עשרים * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( חמישים * 60 )=> 500 + 800 + 900 + 2800 + 3000
=> 8000
המר סט לוקטור
ישנן דרכים רבות להמיר קבוצה לוקטור על ידי העברת כל האלמנטים המועלים בקבוצה לוקטור. הדרך הטובה והפשוטה ביותר היא שימוש בפונקציה std::copy() .
תחביר
סטד :: עותק ( sourceIterator ראשון, sourceIterator אחרון, destinationIterator ראשון )להשתמש ב std::copy() פונקציה שמכניסה את האלמנטים מקבוצה לוקטור. זה דורש שלושה פרמטרים.
כאן:
- הפרמטר הראשון מתייחס לאיטרטור המקור שמצביע על האלמנט הראשון באיטרטור. כאן, set הוא איטרטור המקור שצוין באמצעות הפונקציה begin() .
- באופן דומה, הפרמטר השני מצביע על האלמנט האחרון (פונקציית end()).
- הפרמטר השלישי מתייחס לאיטרטור היעד שמצביע על האלמנט הראשון (שצוין באמצעות הפונקציה begin()) באיטרטור.
בואו ניצור סט עם חמישה תלמידים ונעתיק את כל האלמנטים לווקטור באמצעות הפונקציה הקודמת.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור סט - תלמידים עם 5 אלמנטים
מַעֲרֶכֶת < חוּט > תלמידים = { 'סרבן' , 'בובי' , 'מדהו' , 'מגהנה' , 'לבניה' } ;
cout << 'מַעֲרֶכֶת: \n ' ;
ל ( מחרוזת i : תלמידים )
cout << אני << endl ;
// צור וקטור - גודל student_vcof שווה לגודל הסט
וֶקטוֹר < חוּט > student_vc ( תלמידים. גודל ( ) ) ;
// הכנס אלמנטים מתוך סט - תלמידים לתוך וקטור - student_vc.
עותק ( תלמידים. התחל ( ) , סטודנטים. סוֹף ( ) , student_vc. התחל ( ) ) ;
cout << ' \n וֶקטוֹר: \n ' ;
ל ( מחרוזת i : student_vc )
cout << אני << endl ;
}
תְפוּקָה:
כעת, כל האלמנטים הקיימים בערכת 'סטודנטים' מועתקים לוקטור 'students_vc'.
הסר את הרכיבים הכפולים
- ראשית, עלינו למיין את האלמנטים בווקטור כך שכל האלמנטים הכפולים יהיו צמודים זה לזה באמצעות ה- std::sort() פוּנקצִיָה. סטד :: סוג ( וקטור ראשון, וקטור אחרון ) ;
- השתמש בפונקציה std::unique() כדי שהרכיבים הכפולים ייבחרו. במקביל, השתמש בפונקציה erase() כדי להסיר את הכפילויות המוחזרות על ידי הפונקציה std::unique() . סדר האלמנטים עשוי להשתנות בוקטור הסופי. וֶקטוֹר. לִמְחוֹק ( סטד :: ייחודי ( וקטור ראשון, וקטור אחרון ) , וקטור אחרון ) )
צור את הווקטור 'תלמידים' עם 10 אלמנטים והחזר את הווקטור על ידי הסרת הכפילויות.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - תלמידים עם 10 אלמנטים
וֶקטוֹר < חוּט > תלמידים = { 'סרבן' , 'בובי' , 'מדהו' , 'מגהנה' , 'לבניה' ,
'סרבן' , 'בובי' , 'מדהו' , 'מגהנה' , 'לבניה' } ;
cout << 'סטודנטים: \n ' ;
ל ( מחרוזת i : תלמידים )
cout << אני << '' ;
// מיין את כל האלמנטים בוקטור התלמידים.
סוג ( התחל ( תלמידים ) , סוף ( תלמידים ) ) ;
// השתמש בפונקציה unique() כדי להסיר את הכפילויות עם הפונקציה erase().
תלמידים. לִמְחוֹק ( ייחודי ( התחל ( תלמידים ) , סוף ( תלמידים ) ) , סוף ( תלמידים ) ) ;
cout << ' \n \n סטודנטים ייחודיים: \n ' ;
ל ( אוטומטי itr = cbegin ( תלמידים ) ; itr ! = כמה ( תלמידים ) ; ++ itr ) {
cout << * itr << '' ;
}
}
תְפוּקָה:
כעת, כל האלמנטים ייחודיים בוקטור.
המר וקטור לסט
הסט אינו מאפשר את הרכיבים הכפולים. אם אתה מקליד כדי להוסיף וקטור לתוך קבוצה עם כפילויות, הם יתעלמו. אנו משתמשים באותה פונקציה std::copy() שהייתה בשימוש בתרחיש הקודם שהמירה את הסט לוקטור.
בתרחיש הזה:
- הפרמטר הראשון לוקח את הווקטור כאיטרטור המקור שצוין באמצעות הפונקציה begin() .
- הפרמטר השני לוקח את הווקטור כאיטרטור המקור שצוין באמצעות הפונקציה end() .
- העבר את הפונקציה std::inserter() המשמשת לדרוס/העתקה של האלמנטים באופן אוטומטי במיקום מסוים בסט על ידי מתן הסט והאיטרטור שמצביעים על סוף הסט כפרמטרים.
בואו ניצור וקטור עם 10 מספרים שלמים ונעתיק את האלמנטים לקבוצה.
#includeבאמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור קבוצה - סימנים עם 10 ערכים
וֶקטוֹר < int > סימנים = { 12 , 3. 4 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 3. 4 } ;
cout << 'וֶקטוֹר: \n ' ;
ל ( int אני : סימנים )
cout << אני << '' ;
// Create Set - marks_set של הגודל השווה לגודל הווקטור
מַעֲרֶכֶת < int > marks_set ;
// הכנס אלמנטים מתוך סט - תלמידים לתוך וקטור - student_vc.
עותק ( התחל ( סימנים ) ,סוֹף ( סימנים ) , מכניס ( marks_set, end ( marks_set ) ) ) ;
cout << ' \n \n מַעֲרֶכֶת: \n ' ;
ל ( int אני : marks_set )
cout << אני << '' ;
}
תְפוּקָה:
לוקטור הקיים בשם 'סימנים' יש 10 ערכים. לאחר העתקתו לסט 'marks_set', הוא מכיל רק שישה אלמנטים מכיוון שארבעת האלמנטים האחרים משוכפלים.
הסר את המחרוזות הריקות
אין שימוש במחרוזות ריקות הקיימות בווקטור. זה תרגול טוב להסיר את המחרוזות הריקות הקיימות בווקטור. בואו נראה כיצד להסיר את המחרוזות הריקות מהוקטור C++:
- חזרו על הווקטור באמצעות לולאת 'for'.
- בכל איטרציה, בדוק אם האלמנט ריק ('') או לא באמצעות האופרטור '==' עם הפונקציה איבר at().
- באמצעות הפונקציה std::erase(), הסר את המחרוזות הריקות לאחר בדיקת המצב הקודם.
- חזור על שלב 2 ושלב 3 עד לסוף הווקטור.
בואו ניצור את וקטור ה'חברות' עם 10 מחרוזות. ביניהם, חמישה ריקים ואנו מסירים אותם על ידי יישום הגישה הקודמת.
#include#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( ) {
וֶקטוֹר < חוּט > חברות { 'חברה-A' , '' , 'חברה ב'' ,
'' , 'חברה-C' , '' , 'חברה-D' , '' , '' , '' } ;
// חזרו על חברות
// והסר אלמנטים ריקים באמצעות erase()
ל ( int itr = 1 ; itr < חברות. גודל ( ) ; ++ itr ) {
אם ( חברות. בְּ- ( itr ) == '' ) {
חברות. לִמְחוֹק ( חברות. התחל ( ) + itr ) ;
-- itr ;
}
}
// הצג את הווקטור
ל ( אוטומטי & אני : חברות ) {
cout << אני << endl ;
}
}
תְפוּקָה:
כעת, וקטור ה'חברות' מחזיק את המחרוזות הלא ריקות.
כתוב וקטור לקובץ טקסט
בואו נדון כיצד לכתוב את כל האלמנטים הקיימים בוקטור לקובץ באמצעות מדדי הווקטור באמצעות fstream .
- דחף כמה אלמנטים לתוכו באמצעות הפונקציה push_back לאחר אתחול הווקטור.
- השתמש בפונקציה open() מספריית 'fstream' עם המצב כ-out.
- חצו כל אלמנט שקיים בוקטור באמצעות המדדים בלולאת 'for' וכתוב כל אלמנט לקובץ שסופק.
- לבסוף, סגור את הקובץ.
בואו ליישם את הגישה הקודמת על ידי הפעלת קוד C++.
#include#include
#include
#include
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// צור וקטור - v_data
// ודחוף שני אלמנטים לתוכו.
וֶקטוֹר < חוּט > v_data ;
v_data. התנגדות ( 'ברוך הבא' ) ;
v_data. התנגדות ( 'ל-LinuxHint' ) ;
זרם f ;
// פתח את הקובץ
ו. לִפְתוֹחַ ( 'written_file.txt' ,ios_base :: הַחוּצָה ) ;
// חזרו על כל אלמנט של הווקטור וכתבו לקובץ אחד אחד.
ל ( int אני = 0 ; אני < v_data. גודל ( ) ; אני ++ )
{
ו << v_data [ אני ] << endl ;
}
// סגור את הקובץ
ו. סגור ( ) ;
}
תְפוּקָה:
הווקטור 'v_data' מכיל שני אלמנטים ונוצר קובץ בנתיב שבו התוכנית מבוצעת עם האלמנטים הקיימים בווקטור.
צור וקטור מקובץ טקסט
למדנו איך לכתוב את האלמנטים הקיימים בווקטור לקובץ טקסט. כאן, בואו ניצור וקטור מהתוכן הקיים בקובץ הטקסט.
- ליצור ' ifstream' משתנה המשמש לקריאת המידע מקובץ הטקסט בו אנו יוצרים את הווקטור מהקובץ.
- צור וקטור ריק לאחסון תוכן הקובץ והשתמש במשתנה מחרוזת ריק כדגל כדי לבדוק את סוף הקובץ.
- קראו את השורה הבאה מהקובץ עד שהיא מגיעה לסוף (בעצם באמצעות לולאת 'בזמן'). השתמש בפונקציה push_back() כדי לקרוא את השורה הבאה ולדחוף אותה לוקטור.
- הצג את השורה הקיימת בשורה בנפרד כדי לראות את האלמנטים הקיימים בווקטור בקונסולה.
בואו ליישם את הגישה הקודמת על ידי הפעלת הקוד C++. הבה נשקול את הקובץ 'data.txt' עם התוכן הבא. כאן, שם הווקטור הוא 'v_data'.
באמצעות מרחב שמות סטד ;
רָאשִׁי ( )
{
// פתח את קובץ הטקסט - נתונים
קובץ ifstream ( 'data.txt' ) ;
// צור וקטור - v_data מסוג - מחרוזת
וֶקטוֹר < חוּט > v_data ;
חוטיני היה ;
// קרא את השורה הבאה מה-data.txt
// עד שהוא מגיע לסוף.
בזמן ( קוֹבֶץ >> היה ) {
// קרא את השורה הבאה ודחף לתוך v_data
v_data. התנגדות ( היה ) ;
}
// הצג את השורה הקיימת בשורה בנפרד.
עותק ( v_data. התחל ( ) , v_data. סוֹף ( ) , ostream_iterator < חוּט > ( cout , ' \n ' ) ) ;
}
תְפוּקָה:
אנו יכולים לראות ש-'v_data' מכיל חמישה אלמנטים שהגיעו מהקובץ.
סיכום
במאמר ארוך זה, בדקנו את כל הדוגמאות האפשריות המשמשות ביישומים בזמן אמת הקשורים לוקטורים בשפת התכנות C++. כל דוגמה מוסברת עם תחביר, פרמטרים ודוגמה עם פלט. הערות מתווספות בכל קוד כדי לקבל הבנה ברורה של הקוד.