כיתה וחפצים
מחלקה היא קבוצת משתנים ופונקציות שעובדים יחד, כאשר למשתנים אין ערכים שהוקצו להם. כאשר מוקצים ערכים למשתנים, המחלקה הופכת לאובייקט. ערכים שונים הניתנים לאותה המעמד גורמים לאובייקטים שונים; כלומר, אובייקטים שונים הם אותו מעמד עם ערכים שונים. אומרים שיצירת אובייקט ממעמד מייצגת את האובייקט.
השם, מפה לא מסודרת, היא מחלקה. לאובייקט שנוצר מהמחלקה unordered_map יש שם מתכנת שנבחר.
יש צורך בפונקציה השייכת למחלקה כדי לייצר אובייקט מהמעמד. ב- C ++, לפונקציה הזו יש אותו שם כמו שם המחלקה. לאובייקטים שנוצרו (מיוצרים) מהכיתה יש שמות שונים שניתן להם על ידי המתכנת.
יצירת אובייקט מהמעמד פירושה בניית האובייקט; זה אומר גם להזדהות.
תוכנית C ++ המשתמשת במחלקה unordered_map, מתחילה בשורות הבאות בראש הקובץ:
#לִכלוֹל#לִכלוֹל
באמצעות מרחב שמות std;
השורה הראשונה מיועדת לקלט/פלט. השורה השנייה היא לאפשר לתוכנית להשתמש בכל התכונות של המחלקה unordered_map. השורה השלישית מאפשרת לתוכנית להשתמש בשמות במרחב השמות הסטנדרטי.
עומס יתר של פונקציה
כאשר לשתי חתימות פונקציות שונות או יותר יש את אותו שם, נאמר כי שם זה טעון יתר. כאשר נקראת פונקציה אחת, מספר וסוג הארגומנטים קובעים איזו פונקציה מבוצעת בפועל.
בנייה/העתקת בנייה
בנייה פשוטה
ניתן לבנות מפה בלתי מסודרת ולהקצות ערכים כדלקמן:
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>אמפ;אמפ['בננה'] = 'צהוב';
אמפ['עַנָב'] = 'ירוק';
אמפ['תאנה'] = 'סָגוֹל';
ההצהרה מתחילה בהתמחות התבנית עם הסוגים של צמדי המפתח והערך. אחריו מופיע שם המתכנת שנבחר למפה; ואז נקודה -פסיק. קטע הקוד השני מראה כיצד להקצות ערכים למפתחות שלהם.
בנייה לפי Initializer_list
ניתן לעשות זאת כדלקמן:
{'עַנָב', 'ירוק'}, {'תאנה', 'סָגוֹל'}});
בנייה על ידי הקצאת Initializer_list
דוגמא:
{'עַנָב', 'ירוק'}, {'תאנה', 'סָגוֹל'}};
בנייה על ידי העתקת מפה נוספת ללא סדר
דוגמא:
{'עַנָב', 'ירוק'}, {'תאנה', 'סָגוֹל'}});
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>umap2(umap1);
אלמנט הזוג
הקוד הבא מראה כיצד ליצור ולגשת לרכיב הזוג:
זוג<לְהַשְׁחִיר, קבוע לְהַשְׁחִיר*>יחסי ציבור= {'d', 'לִהיוֹת'};עֲלוּת<<יחסי ציבור.ראשון << ' n';
עֲלוּת<<יחסי ציבור.שְׁנִיָה << ' n';
הפלט הוא:
דלִהיוֹת
הראשון והשני הם מילים שמורות לשני הפריטים בזוג. עדיין ניתן לשנות את הערכים בזוג באמצעות הראשון והשני.
זוג נקרא, value_type בנושא המפה הלא מסודרת.
גישת אלמנט unordered_map
סוג מיפוי ואופרטור [] (סוג מפתח && k)
מחזירה את הערך עבור המפתח המתאים. דוגמא:
אמפ['בננה'] = 'צהוב';
אמפ['עַנָב'] = 'ירוק';
אמפ['תאנה'] = 'סָגוֹל';
קבוע לְהַשְׁחִיר *ימין=אמפ['עַנָב'];
עֲלוּת<<ימין<<' n';
הפלט הוא: ירוק. ניתן להקצות ערכים באותו אופן - ראה לעיל.
קיבולת מפה לא מסודרת
size_type size () const noexcept
מחזירה את מספר הזוגות במפה.
אמפ['בננה'] = 'צהוב';
אמפ['עַנָב'] = 'ירוק';
אמפ['תאנה'] = 'סָגוֹל';
עֲלוּת<<אמפ.גודל() <<' n';
התפוקה היא 3.
bool ריק () const noexcept
מחזירה 1 עבור true אם למפה אין זוג, ו- 0 עבור false אם יש לה זוגות. דוגמא:
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>אמפ;עֲלוּת<<אמפ.ריק() <<' n';
התפוקה היא 1.
איטרטורים חוזרים ומחלקת המפות הלא מסודרות
איטרטור הוא כמו מצביע אך יש לו פונקציונליות רבה יותר מהמצביע.
begin () noexcept
מחזירה איטרציה המצביעה על הצמד הראשון של אובייקט המפה, כמו בקטע הקוד הבא:
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>אמפ;אמפ['בננה'] = 'צהוב';אמפ['עַנָב'] = 'ירוק';אמפ['תאנה'] = 'סָגוֹל';
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*> ::איטרציהאיטר=אמפ.התחל();
זוג<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>יחסי ציבור= *איטר;
עֲלוּת<<יחסי ציבור.ראשון << ',' <<יחסי ציבור.שְׁנִיָה << ' n';
הפלט הוא: תאנה, סגולה. המפה אינה מסודרת.
begin () const noexcept;
מחזירה איטרציה המצביעה על האלמנט הראשון של אוסף אובייקטים המפה. כאשר לפני בניית האובייקט const, הביטוי begin () const מבוצע במקום התחל (). בתנאי זה, לא ניתן לשנות את האלמנטים באובייקט. הוא משמש בקוד הבא, למשל.
קבועמפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>אמפ({{'בננה', 'צהוב'},{'עַנָב', 'ירוק'}, {'תאנה', 'סָגוֹל'}});
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*> ::const_iteratorאיטר=אמפ.התחל();
זוג<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>יחסי ציבור= *איטר;
עֲלוּת<<יחסי ציבור.ראשון << ',' <<יחסי ציבור.שְׁנִיָה << ' n';
הפלט הוא: תאנה, סגולה. המפה אינה מסודרת. שים לב כי const_iterator שימש הפעם, במקום רק איטרציה, לקבלת האיטרור המוחזר.
סוף () noexcept
מחזירה איטרציה המצביעה מיד מעבר לרכיב האחרון של אובייקט המפה.
סוף () const noexcept
מחזירה איטרציה המצביעה מיד מעבר לרכיב האחרון של אובייקט המפה. כאשר לבנייה של אובייקט המפה קבוע const, הביטוי end () const מבוצע במקום end ().
פעולות unorded_map
iterator find (const key_type & k)
מחפש זוג המפתח הנתון במפה. אם הוא נמצא, הוא מחזיר את האיטרציה. אם לא נמצא, הוא מחזיר איטרור המצביע על קצה המפה, שאינו זוג. הקוד הבא מראה כיצד להשתמש בפונקציית החברים הזו:
מפה_לא מסודרת<לְהַשְׁחִיר,לְהַשְׁחִיר>אמפ;אמפ['ל'] = 'ב';אמפ['ג'] = 'd';אמפ['וגם'] = 'f';
מפה_לא מסודרת<לְהַשְׁחִיר,לְהַשְׁחִיר> ::איטרציהאיטר=אמפ.למצוא('ג');
אם (אמפ.למצוא('ג') ! =אמפ.סוֹף())
{
זוג<לְהַשְׁחִיר,לְהַשְׁחִיר>יחסי ציבור= *איטר;
עֲלוּת<<יחסי ציבור.ראשון << ',' <<יחסי ציבור.שְׁנִיָה << ' n';
}
הפלט הוא: c, d
const_iterator למצוא (const key_type & k) const;
גרסה זו של הפונקציה נקראת אם יצירת המפה הלא מסודרת מתחילה ב- const, מה שהופך את כל מרכיבי המפה לקריאה בלבד.
משתנים unordered_map
צירוף זוג (value_type && obj)
מפה לא מסודרת פירושה שהזוגות אינם בסדר כלשהו. לכן, התוכנית מכניסה את הזוג בכל מקום שנוח לה. הפונקציה חוזרת, זוג. אם ההכנסה הצליחה, bool יהיה 1 עבור true, אחרת הוא יהיה 0 עבור false. אם ההכנסה מוצלחת, האיטרציה תצביע על האלמנט שהוכנס לאחרונה. הקוד הבא ממחיש את השימוש:
אמפ['בננה'] = 'צהוב';
אמפ['עַנָב'] = 'ירוק';
אמפ['תאנה'] = 'סָגוֹל';
אמפ.לְהַכנִיס({{'דובדבן', 'נֶטוֹ'}, {'תּוּת', 'נֶטוֹ'}});
עֲלוּת<<אמפ.גודל() << ' n';
הפלט הוא: 5. ניתן להכניס יותר מזוג אחד.
מחק סוג_סוג (const key_type & k)
פונקציה זו מוחקת זוג מהמפה הלא מסודרת. קטע הקוד הבא ממחיש:
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>אמפ;אמפ['בננה'] = 'צהוב';
אמפ['עַנָב'] = 'ירוק';
אמפ['תאנה'] = 'סָגוֹל';
intעל אחד=אמפ.לִמְחוֹק('עַנָב');
עֲלוּת<<אמפ.גודל() << ' n';
הפלט הוא 2.
החלפת חללים (מפה לא מסודרת &)
ניתן להחליף שתי מפות לא מסודרות, כפי שמודגם בקטע קוד זה:
{'עַנָב', 'ירוק'}, {'תאנה', 'סָגוֹל'}, {'תּוּת', 'נֶטוֹ'}};
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>umap2= {{'דובדבן', 'נֶטוֹ'}, {'ליים', 'ירוק'}};
umap1.לְהַחלִיף(umap2);
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*> ::איטרציהiter1=umap1.התחל();
זוג<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>pr1= *iter1;
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*> ::איטרציהiter2=umap2.התחל();
זוג<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>pr2= *iter2;
עֲלוּת<< 'המפתח והגודל הראשון של umap1:'<<pr1.ראשון <<','<<umap1.גודל() << ' n';
עֲלוּת<< 'המפתח והגודל הראשון של umap2'<<pr2.ראשון <<','<<umap2.גודל() << ' n';
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>umap1= {{'בננה', 'צהוב'},
{'עַנָב', 'ירוק'}, {'תאנה', 'סָגוֹל'}, {'תּוּת', 'נֶטוֹ'}};
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>umap2= {{'דובדבן', 'נֶטוֹ'}, {'ליים', 'ירוק'}};
umap1.לְהַחלִיף(umap2);
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*> ::איטרציהiter1=umap1.התחל();
זוג<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>pr1= *iter1;
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*> ::איטרציהiter2=umap2.התחל();
זוג<קבוע לְהַשְׁחִיר*, קבוע לְהַשְׁחִיר*>pr2= *iter2;
עֲלוּת<< 'המפתח והגודל הראשון של umap1:'<<pr1.ראשון <<','<<umap1.גודל() << ' n';
עֲלוּת<< 'המפתח והגודל הראשון של umap2'<<pr2.ראשון <<','<<umap2.גודל() << ' n';
הפלט הוא:
מפתח וגודל ראשון של umap1: סיד, 2
מפתח וגודל ראשון של תות שדה umap2, 4
המפה אינה מסודרת. שים לב שאורך המפה גדל במידת הצורך. סוגי הנתונים חייבים להיות זהים.
קלאס וחפציו הממוסדים
ערך הוא לסוג נתונים, כמו שאובייקט מיידי הוא למחלקה. בניית המפה הלא מסודרת יכולה לקבל גם מחלקה כסוג נתונים. התוכנית הבאה ממחישה זאת:
#לִכלוֹל#לִכלוֹל
באמצעות מרחב שמות std;
כיתה TheCla
{
פּוּמְבֵּי:
intעל אחד;
סטָטִי לְהַשְׁחִירצ';
בָּטֵלפוּנקצִיָה(לְהַשְׁחִירלא, קבוע לְהַשְׁחִיר *עמ)
{
עֲלוּת<< 'יש ' <<על אחד<< 'ספרים שווים' <<לא<<עמ<< ' בחנות.' << ' n';
}
סטָטִי בָּטֵלכֵּיף(לְהַשְׁחִירצ')
{
אם (צ'== 'ל')
עֲלוּת<< 'פונקציה רשמית של חבר סטטי' << ' n';
}
};
intרָאשִׁי()
{
TheCla obj1;TheCla obj2;TheCla obj3;TheCla obj4;TheCla obj5;
מפה_לא מסודרת<קבוע לְהַשְׁחִיר*,TheCla>אמפ;
אמפ= {{'בננה',obj1}, {'עַנָב',obj2}, {'תאנה',obj3}, {'תּוּת',obj4}, {'ליים',obj5}};
עֲלוּת<<אמפ.גודל() << ' n';
לַחֲזוֹר 0;
}
הפלט הוא: 5.
ההגדרה המעמדית כוללת שני חברים בציבור נתונים ושתי פונקציות של ציבור ציבור. בפונקציה הראשית () מייצרים עצמים שונים למחלקה. לאחר מכן מיידית מפה לא מסודרת, כאשר כל זוג מורכב משמו של פרי וחפץ מהכיתה. גודל המפה מוצג. התוכנית מתאספת ללא אזהרה או הודעת שגיאה.
יישום המפה
המערך מקשר אינדקס לערך. זוגות מפתח/ערך קיימים במצבים רבים בחיים, אותם ניתן לתכנת. צמד המפתח/ערך של פרי/צבע הוא רק דוגמה אחת. דוגמה נוספת היא שם האנשים וגילם. במקרה זה, הצמד יהיה מסוג, זוג. זה יכול להיות גם זוג. במקרה האחרון, ההוראה לעיבוד מוקדם תופעל. זוג מפתח/ערך עדיין יכול להיות שמות של זוגות נשואים. במדינות בהן יש פוליגמיה, יהיו נשים שונות לגבר אחד.
גיבוש מפה
מפה אינה מערך דו-ממדי, בעל שני עמודים. מפה עובדת עם פונקציית hash. המפתח מקודד על ידי פונקציית ה- hash, למספר שלם של מערך. המערך הזה הוא זה שמחזיק את הערכים. אז, למעשה יש מערך אחד עם הערכים, והמפתחות ממופים למדדי המערך, ולכן ההתאמות בין מפתחות לערכים נעשות. האשינג הוא נושא נרחב ואינו מכוסה במאמר זה.
סיכום
מפה, המכונה גם מערך אסוציאטיבי היא רשימה של אלמנטים, כאשר כל אלמנט הוא זוג מפתח/ערך. אז, כל מפתח מתאים לערך. ב- C ++ המפה מיושמת כמבנה נתונים עם פונקציות וחברים אופרטורים. מפה מסודרת היא מפה שבה זוגות האלמנטים הוזמנו באמצעות מפתחות. מפה לא מסודרת היא מפה שבה אין הזמנה.
מבחינה טכנית, חשיש מורכב מאלמנטים זוגיים. למעשה, הצמד הוא מבנה נתונים שלם עם פונקציות החברים והמפעילים שלו. שני הפרמטרים של התבנית עבור הצמד הם אותם שני פרמטרי תבנית עבור המפה הלא מסודרת.
רשימת האתחול של המפה היא מערך מילולי של מילולי. כל מילולית פנימית מורכבת משני אובייקטים, צמד המפתחות/ערך.
ניתן לסווג את פונקציות החברים והמפעילים של מפה לא מסודרת בכותרות הבאות: בניית מפה לא מסודרת/בניית עותקים, קיבולת לא מסודרת, מפה לא מסודרת, מפעולות לא מסודרות ומפות.
מפה לא מסודרת משמשת כאשר יש למפות מפתח לערך.
כריס