ספריית C++ STL מספקת לנו מחלקת מפות. מפות נחשבות למכולות אסוציאטיביות השומרות אובייקטים בזוג ערכי מפתח מסודרים וערכים ממופים. לעולם לא יכולים להיות שני ערכים ממופים עם אותו ערך מפתח. מחלקה מפה מספקת פונקציות רבות אך כאן נדון ב map.at() פוּנקצִיָה. האלמנט הממופה לערך המפתח מועבר כפרמטר של הפונקציה שאליו מתייחסים באמצעות ה- map.at() פוּנקצִיָה. כאשר אנו מנסים להגיע לאלמנט שאינו בטווח של המיכל, ה- map.at() הפונקציה מעריכה את הטווח של המכולה וזורקת חריג.
תחביר של פונקציה map.at().
עלינו לעקוב אחר התחביר למטה כדי ליישם את הפונקציה map.at() ב-C++.
Map_variable.at ( מַפְתֵחַ / זוג ערכים )
השתמשנו באובייקט המפה ששמו 'Map_variable' עם ה- בְּ() פוּנקצִיָה. הוא מחזיר את האלמנט שאליו מפנה ישירות ומצביע על ערך המפתח שצוין. מפת מפתח הנתונים תלויה בעיקר בטווח המפה. אם לא, קיימת אפשרות שבזמן הביצוע יוחזר חריג או שגיאה שמסמלת שהערך הוא מעבר לטווח המוגדר. כעת, נשתמש בתחביר הזה בקודי C++ כדי להראות שהוא עובד.
דוגמה 1: שימוש בפונקציה map.at()
התוכנית מיושמת כדי להדגים את הפונקציה map.at. קישרנו את בְּ() לתפקד עם ה מַפָּה() פונקציה שלוקחת כמה ערכי קלט ומראה את הפונקציונליות שלה. לשם כך, מילאנו את קטע הכותרת של התוכנית על ידי ייבוא מודול המפה עם מודול נדרש נוסף עבור c++. לאחר מכן, התקשרנו ל- רָאשִׁי() פונקציה להצהרת המפה ממחלקת המפה. האובייקט של המפה מסומן בתור 'המפה שלי'. אנו יוצרים את רשימת המפות על ידי מתן מפתח וערך המפה.
לאחר מכן, הזמנו את map.at() פונקציה שממפה את המחרוזת שצוינה למספר שלם. לאחר מכן, הדפסנו את התוצאות מה- map.at() פונקציה מלולאת for. לולאת for משתמשת בהפניה למילת מפתח 'אוטומטית'. מילת המפתח האוטומטית מציינת שהמאתחל יסיר אוטומטית את סוג המשתנה מהסוג המוצהר. הצהרת ה-cout תדפיס את הזוגות לפי הסדר שיוחזר מה- map.at() פוּנקצִיָה.
#include#include
#include <מפה>
int main ( )
std: :map < std::string,int > MyMap = {
{ 'תפוח עץ', 0 } ,
{ 'ענבים' , 0 } ,
{ 'מנגואים' , 0 } }
MyMap.at ( 'תפוח עץ' ) = 5 ;
MyMap.at ( 'ענבים' ) = 10 ;
MyMap.at ( 'מנגואים' ) = 6 ;
ל ( אוטומטי & מ: MyMap ) {
std::cout << מ.ראשון << ': ' << מ.שניה << '\n' ; }
< חָזָק > לַחֲזוֹר 0 ;
}
כעת, יש לנו את התוצאות מהתוכנית לעיל המיישמת את map.at() פוּנקצִיָה. כל המספרים השלמים שצוינו שנמצאים בטווח מוצגים מול כל מחרוזת.
דוגמה 2: שימוש בפונקציה map.at() עבור חריגה מחוץ לטווח
דנו באמצעות תוכנית לדוגמה בשימוש ב- map.at פונקציה ב-C++. כעת, יישמנו עוד אחד map.at בתוכנית. אבל הפעם זה יחזיר את הערך שמוצג בתוך המפה וגם את החריגה מחוץ לטווח כאשר המפתח לא מצוין. כפי שאנו צריכים לנצל את map.at פונקציה, אז הוספנו את מודול המפה בכותרת. לאחר מכן, הגדרנו את הפונקציה הראשית שבה ה'ריק' מועבר כפרמטר.
בתוך הפונקציה הראשית, אתחלנו את בנאי הרשימה על ידי יצירת אובייקט המפה בתור 'm1'. ברשימת המפות יש מחרוזות שונות של מפתחות וערכי המספרים השלמים מולן. לאחר מכן, הדפסנו את המפתח 'i' על ידי העברתו דרך map.at פוּנקצִיָה. השתמשנו בגוש הנסיון. בבלוק try, הצגנו את מפתח אי-קיום ב- map.at פוּנקצִיָה. מכיוון שהמפתח נמצא מחוץ לטווח, אז בלוק הנסיון יזרוק את השגיאה.
#include#include <מפה>
שימוש במרחב שמות std;
int main ( בָּטֵל ) {
מַפָּה < char, int > m1 = {
{ 'אני' , 1 } ,
{ 'אני' , שתיים } ,
{ 'נ' , 3 } ,
{ 'ב' , 4 } ,
{ 'איקס' , 5 } ,
} ;
cout << 'ערך מפתח מפה m1['i'] = ' << m1.at ( 'אני' ) << endl;
לְנַסוֹת {
m1.at ( 'Y' ) ;
} לתפוס ( const מחוץ לטווח & ו ) {
cerr << 'שגיאה ב' << ה.מה ( ) << endl;
}
לַחֲזוֹר 0 ;
}
אנו יכולים לדמיין מצילום מסך הפלט כי map.at() הפונקציה מחזירה רק את המפתחות הקיימים במפה. המקשים מחוץ לטווח זורקים את השגיאה כאשר השגיאה מוצגת כאשר העברנו את המקש 'y' ב- map.at פוּנקצִיָה.
דוגמה 3: שימוש בפונקציה map.at() לגישה לאלמנטים
ניתן לגשת לאלמנט באמצעות רכיב הספרות שצוין מהפונקציה map.at. בואו ליישם תוכנית זו כדי להשיג את ההצהרה לעיל. הגדרנו את מודול המפה תחילה בקטע הכותרת כפי שהוא נדרש כדי לגשת ל map.at פוּנקצִיָה. לאחר מכן, יש לנו את הפונקציה הראשית שבה מחלקת המפה אתחלה את אובייקט המפה כ'מפה'. עם אובייקט 'מפה' זה, יצרנו את מפתחות המחרוזות והקצינו להם את ערך הספרה. לאחר מכן, התקשרנו ל- map.at פונקציה עם הצהרת cout והעבירה את מקש 'דוגמה' כקלט.
#include#include <מפה>
#include
שימוש במרחב שמות std;
int main ( )
{
מַפָּה < מחרוזת, int > מַפָּה;
מַפָּה [ 'שֶׁלִי' ] = 1 ;
מַפָּה [ 'c++' ] = שתיים ;
מַפָּה [ 'מַפָּה' ] = 3 ;
מַפָּה [ 'דוגמא' ] = 4 ;
cout << Map.at ( 'דוגמא' ) ;
לַחֲזוֹר 0 ;
}
רכיב הספרה מוחזר כנגד המפתח שצוין ב- map.at פוּנקצִיָה. התוצאה נותנת את הערך '4' שכן ספרה זו מוקצית לאלמנט המפתח 'דוגמה' של מפה.
דוגמה 4: שימוש בפונקציה map.at() לשינוי אלמנטים
הבה נשקול דוגמה פשוטה של שינוי הערך המשויך לערך המפתח. יצרנו את רשימת המפה על ידי קריאה למחלקת המפה ויצירת האובייקט 'M1'. הקצינו את ערך המחרוזת כנגד כל מפתח במפה. לאחר מכן, עלינו לנצל את map.at פוּנקצִיָה. בתוך ה map.at פונקציה, השתמשנו במפתחות שצוינו והקצנו את ערכי המחרוזת החדשים מול המפתחות הללו. כעת, ערכים אלה ישתנו עם הערכים הקודמים. בעזרת for loop, איטרנו כל אלמנט מהמפה והצגנו אותו כפלט.
#include#include
#include <מפה>
שימוש במרחב שמות std;
int main ( )
{
מַפָּה < int, מחרוזת > M1 = {
{ 10 , 'c++' } ,
{ עשרים , 'ג'אווה' } ,
{ 30 , 'פִּיתוֹן' } ,
{ 40 , 'קשארפ' } ,
{ חמישים , 'לִפְתוֹחַ' } } ;
M1.at ( עשרים ) = 'זרימת טנסור' ;
M1.at ( 30 ) = 'לינוקס' ;
M1.at ( חמישים ) = 'סקאלה' ;
cout << ' \n אלמנטים:' << endl;
ל ( אוטומטי & x: M1 ) {
cout << x.first << ': ' << x.שניה << '\n' ;
}
לַחֲזוֹר 0 ;
}
שימו לב שערכים שהתקבלו כפלט שינו את ערכי המחרוזת החדשים שהוקצו ב- map.at פוּנקצִיָה. הערכים המעודכנים מוצגים בתמונת המצב שלהלן.
סיכום
המאמר עוסק בפונקציית map.at. סיפקנו את הפונקציונליות של הפונקציה map.at() דרך התחביר שלה והדוגמה מיושמת עם מהדר C++. הפונקציה map.at() שימושית ביותר מכיוון שהיא מאפשרת נגישות לרכיבים ומחזירה חריגה ברורה או שגיאה המתארת את המצב שנוצר כאשר השיטה נקראת. יתר על כן, אנו יכולים להקצות ערכים חדשים כנגד מפתח הקיום באמצעות הפונקציה map.at.