ב-C++, וקטור הוא מיכל רב-תכליתי שיכול לשנות את גודלו באופן דינמי, מה שמאפשר מניפולציה יעילה של אלמנטים. בעוד שזוג הוא מיכל פשוט שיכול להכיל שני אובייקטים הטרוגניים המספקים אמצעי נוח לשייך ולנהל את הנתונים הקשורים. כאשר הזוגות הללו מאורגנים בתוך וקטור, המפתחים מקבלים את היכולת ליצור אוספים דינמיים של צמדי מפתח-ערך או כל שילוב אחר של שני אלמנטים נפרדים.
מבנה נתונים זה שימושי במיוחד בתרחישים שבהם יש לאחסן את האלמנטים כזוגות, כגון כאשר עוסקים בצמדי מפתח-ערך או מייצגים את הקשרים בין ישויות. במאמר זה, נחקור את הרעיון של וקטור C++ של זוגות ונחקור את הדוגמאות השונות כדי להמחיש את היישומים המעשיים שלו.
דוגמה 1: שימוש בסיסי: איטרציה על וקטור של זוגות
הבה נבחן דוגמה בסיסית שבה אנו יוצרים וקטור של זוגות המייצגים את שמות התלמידים והגילאים התואמים שלהם. איטרציה על וקטור של זוגות דומה לחזרה על וקטור רגיל. אפשר להשתמש באיטרטורים או לולאות 'for' מבוססות טווח כדי לאחזר כל זוג בתוך הווקטור.
דוגמה זו מציגה את התחביר עבור 'וקטור של זוגות' בהקשר משמעותי.
#include
#include
#include <תועלת>
int main ( ) {
std::vector < std::pair < std::string, int >> studentData;
studentData.push_back ( std::make_pair ( 'אדם' , עשרים ) ) ;
studentData.push_back ( std::make_pair ( 'שטר כסף' , 22 ) ) ;
studentData.push_back ( std::make_pair ( 'צ'רלי' , עשרים ואחת ) ) ;
std::cout << 'נתוני סטודנטים: \n ' ;
ל ( const auto & תלמיד: studentData ) {
std::cout << 'שם:' << תלמיד.ראשון << ', גיל: ' << תלמיד.שני << std::endl;
}
לַחֲזוֹר 0 ;
}
בקטע קוד C++ זה, אנו מתחילים על ידי הכללת שלושה קובצי כותרת חיוניים: '
קדימה, בתוך הפונקציה main() אנו מכריזים על וקטור בשם 'studentData' באמצעות מיכל 'std::vector'. וקטור זה נועד לאחסן את הזוגות שבהם כל זוג מקפל את שם התלמיד (המיוצג כ-'std::string') ואת גילם (מספר שלם 'int'). לאחר מכן, אנו מאכלסים את וקטור ה-'studentData' בשלושה זוגות. באמצעות הפונקציה 'push_back', זוגות מתווספים לקצה הווקטור, תוך התאמה דינמית של גודלו. לאחר מכן עוברת לולאה דרך 'נתוני סטודנטים', מחלצת ומדפיסה את שמו וגילו של כל תלמיד. הפלט מציג 'נתוני תלמיד:' המדגיש את הייצוג המובנה. שמות התלמידים והגילאים מודפסים בנפרד, ומציגים בבירור את הנתונים המאוחסנים.
דוגמה 2: מיון וקטור של זוגות
מיון וקטור של זוגות הוא פעולה נפוצה, במיוחד כאשר עוסקים בשיוך מפתח-ערך. ניתן להשתמש בפונקציה 'std::sort' מהכותרת '
#include
#include <אלגוריתם>
int main ( ) {
std::vector < std::pair < std::string, int >> מידע;
info.push_back ( std::make_pair ( 'פיטר' , חֲמֵשׁ עֶשׂרֵה ) ) ;
info.push_back ( std::make_pair ( 'דורה' , 29 ) ) ;
info.push_back ( std::make_pair ( 'חנה' , עשרים ) ) ;
std::cout << 'מידע מקורי: \n ' ;
ל ( const auto & ערך: מידע ) {
std::cout << 'שם:' << כניסה.תחילה << ', גיל: ' << entry.second << std::endl;
}
std::sort ( info.begin ( ) , info.end ( ) ) ;
std::cout << ' \n מידע ממוין: \n ' ;
ל ( const auto & ערך: מידע ) {
std::cout << 'גיל: ' << entry.second << ', שם: ' << כניסה.תחילה << std::endl;
}
לַחֲזוֹר 0 ;
}
בדוגמה זו של קוד C++, אנו עובדים עם וקטור של זוגות כדי לאחסן ולתפעל את הנתונים הקשורים ליחידים, במיוחד את שמם וגילם. אנו מאתחלים וקטור בשם 'מידע של זוגות' בתוך הפונקציה main() . לאחר מכן, אנו מאכלסים את הווקטור הזה בשלושה זוגות, שכל אחד מכיל את השם והגיל של אדם נפרד, תוך שימוש בפונקציית 'push_back' ו-'std::make_pair' ליצירת זוג יעיל.
אנו מוציאים את 'המידע המקורי' לקונסולה. זה כולל איטרציה דרך וקטור ה'מידע' והדפסת רכיבי כל זוג. לאחר מכן, אנו משתמשים באלגוריתם 'std::sort' כדי לארגן מחדש את וקטור ה'מידע' בהתבסס על אופרטור ההשוואה המוגדר כברירת מחדל עבור זוגות אשר משווה את האלמנט הראשון של כל זוג (במקרה זה, השמות). לאחר פעולת המיון, אנו חוזרים שוב על וקטור ה'מידע' שהשתנה על ידי הדפסת המידע הממוין. הפעם, הפלט מדגיש את סדר הגיל הראשון, הממחיש את תוצאת תהליך המיון.
דוגמה 3: שילוב הוקטורים מסוגים שונים
אתה עלול להיתקל במצבים מסוימים שבהם עליך לשלב מידע משני וקטורים. וקטור של זוגות יכול לעזור לשמור על הקשר בין אלמנטים משני הוקטורים.
#include#include
int main ( ) {
std::vector < std::string > ערים = { 'ניו יורק' , 'פריז' , 'טוקיו' } ;
std::vector < int > אוכלוסיות = { 8175133 , 2140526 , 37435191 } ;
std::vector < std::pair < std::string, int >> עירPopulationPairs;
ל ( size_t i = 0 ; אני < std::min ( ערים.גודל ( ) , אוכלוסיות.גודל ( ) ) ; ++i ) {
cityPopulationPairs.push_back ( { ערים [ אני ] , אוכלוסיות [ אני ] } ) ;
}
std::cout << 'זוגות עיר-אוכלוסיה:' << std::endl;
ל ( const auto & זוג: עירPopulationPairs ) {
std::cout << 'עיר:' << זוג.ראשון << ', אוכלוסיה: ' << pair.second << std::endl;
}
לַחֲזוֹר 0 ;
}
בפונקציה ה'ראשית' של הקוד, מוכרזים שני וקטורים: 'ערים' לאחסון שמות הערים ו'אוכלוסיות' לאחסון ערכי האוכלוסייה המתאימים.
וקטור שלישי, 'עירPopulationPairs', מוגדר לאחסון זוגות הערים והאוכלוסיות שלהן. כל זוג הוא 'std::pair
לאחר שילוב המידע, נעשה שימוש בלולאת 'for' נוספת כדי לעבור בין הזוגות המאוחסנים ב-'cityPopulationPairs'. לאחר מכן, הנתונים המשולבים מוצגים בפלט הסטנדרטי באמצעות 'std::cout', המייצג בבירור כל עיר והאוכלוסייה המתאימה לה.
דוגמה 4: מציאת ערכי המקסימום והמינימום
זיהוי ערכי המינימום והמקסימום בתוך מערך נתונים הוא דרישה נפוצה בפעולות אלגוריתמיות וסטטיסטיות. אנו יכולים להשתמש בוקטור של זוגות כדי לעקוב אחר הערכים המקסימליים והמינימליים ברצף:
#include#include
#include <אלגוריתם>
int main ( ) {
std::vector < int > מספרים = { 5 , 12 , 18 , 3 , 7 , 4 , 33 } ;
std::vector < std::pair < אתה, אתה >> minMaxPairs;
std::sort ( מספרים.התחל ( ) , numbers.end ( ) ) ;
minMaxPairs.push_back ( { מספרים.חזית ( ) , מספרים.חזרה ( ) } ) ;
std::cout << 'מינימום-מקס זוגות:' << std::endl;
ל ( const auto & זוג: minMaxPairs ) {
std::cout << 'דקה:' << זוג.ראשון << ', מקסימום: ' << pair.second << std::endl;
}
לַחֲזוֹר 0 ;
}
קוד C++ שסופק מדגים את התהליך של מציאת ערכי המינימום והמקסימום בווקטור של מספרים שלמים ולאחר מכן אחסון ערכים אלה בווקטור של זוגות. וקטור בשם 'מספרים' מוכרז בתחילה ומאותחל עם קבוצה של מספרים שלמים. כדי לזהות ביעילות את ערכי המינימום והמקסימום במערך הנתונים, התוכנית משתמשת בפונקציית 'std::sort' מספריית האלגוריתמים.
פונקציה זו שואפת לסדר את האלמנטים בסדר עולה, ולפשט את תהליך זיהוי הערכים המינימליים והמקסימליים במערך הנתונים. פעולת המיון מיושמת על וקטור ה'מספרים' באמצעות numbers.begin() ו- numbers.end() כפרמטרי הטווח. לאחר שלב המיון, התוכנית יוצרת וקטור של זוגות, 'minMaxPairs', כדי לאחסן את ערכי המינימום והמקסימום המחושבים. לאחר מכן, הפונקציה 'push_back' משמשת להוספת זוג בודד המכיל את האלמנטים הראשונים (המינימום) והאחרונים (המקסימליים) של וקטור המספרים הממוינים. לבסוף, התוכנית מוציאה את התוצאה על ידי איטרציה דרך הווקטור 'minMaxPairs' והצגת ערכי המינימום והמקסימום.
סיכום
לסיכום, וקטור הזוגות C++ מופיע כמבנה נתונים רב עוצמה וגמיש, המוסיף שכבה של צדדיות למשימות תכנות. באמצעות חקירה מפורטת של התחביר והיישומים המעשיים שלו, ראינו כיצד מיכל זה עוזר לארגן את אסוציאציות המפתח-ערך, לשלב את המידע מוקטורים שונים ולעקוב אחר ערכי המינימום והמקסימום.