במדריך זה, נסתכל על אופרטור נקודתיים כפול (::). ב-C++ וכיצד זה עובד בתרחישים שונים.
מה עושה :: ב-C++?
ב-C++, ה רזולוציית היקף מפעיל (::) משמש לאחזור שמות המשתנה הקיימים ברמות היקף שונות. ההיקף בתכנות מתייחס להקשר שבו ניתן לגשת למשתנים ולפונקציות.
שימושים של :: במקרים שונים ב-C++
ב-C++, ה מפעיל רזולוציית היקף (::) יש שימושים שונים בהתאם להקשר שבו הוא משמש. להלן כמה שימושים בולטים של מפעיל זה:
1: גישה למשתנה או פונקציה במרחב שמות אחר
א מרחב שמות משמש ב-C++ כדי לקבץ פונקציות, מחלקות ומשתנים קשורים כדי למנוע התנגשויות בשמות. כאשר אתה מגדיר משתנה או פונקציה בתוך a מרחב שמות , שם המשתנה או הפונקציה גלוי רק בתוך זה מרחב שמות .
ב-C++, אתה יכול להשתמש ב- מפעיל רזולוציית היקף (::) ביחד איתי מרחב שמות name ואת שם המשתנה או הפונקציה כדי לגשת למשתנה או פונקציה שהוגדרו במרחב שמות אחר. זה מאפשר לך לגשת למשתנה או לפונקציה מ-a מרחב שמות מלבד זה שבו הוא נוצר.
כדי להבין את המקרה לעיל, שקול את הקוד הבא כדוגמה:
#includeבאמצעות מרחב שמות std ;
מתמטיקה של מרחב שמות {
const לְהַכפִּיל פאי = 3.14159 ;
לְהַכפִּיל כיכר ( לְהַכפִּיל איקס ) {
לַחֲזוֹר איקס * איקס ;
}
}
int רָאשִׁי ( ) {
cout << 'הערך של PI הוא:' << מתמטיקה :: פאי << endl ;
cout << 'הריבוע של 5 הוא:' << מתמטיקה :: כיכר ( 5 ) << endl ;
לַחֲזוֹר 0 ;
}
הקוד לעיל משתמש ב- מרחב שמות מתמטי כדי לגשת ל 'פאי' קבוע ו 'כיכר' פונקציה באמצעות מפעיל רזולוציית היקף '::' . לאחר מכן הוא מדפיס את הערכים למסוף.
תְפוּקָה
2: גישה למשתנה גלובלי בתוכנית
כאשר אותו שם של משתנים מקומיים וגלובליים קיים בתוכנית, המשתנה המקומי עשוי להסתיר את הגלובלי. במצבים כאלה, אתה יכול להשתמש ב- מפעיל רזולוציית היקף (::) לגישה למשתנה הגלובלי. אופרטור זה מאפשר לנו להתייחס במפורש למשתנה הגלובלי בהתבסס על היקפו.
לדוגמה, בקוד שניתן להלן, התייחסנו למשתנה הגלובלי 'א ' דרך ה מפעיל רזולוציית היקף (::) , מתוך פונקציה שבה הוגדר משתנה מקומי באותו שם:
#includeבאמצעות מרחב שמות std ;
int א = חֲמֵשׁ עֶשׂרֵה ;
int רָאשִׁי ( )
{
int א = 35 ;
cout << 'הערך של משתנה גלובלי a הוא' << :: א << endl ;
cout << 'הערך של משתנה מקומי a הוא' << א << endl ;
לַחֲזוֹר 0 ;
}
בקוד לעיל, המשתנה a present מחוץ לפונקציה הראשית הוא ה משתנה גלובלי והמשתנה a בתוך הפונקציה הראשית הוא ה משתנה מקומי עם אותו שם כמו המשתנה הגלובלי. בהצהרת cout, השתמשנו באופרטור רזולוציית ההיקף כדי להדפיס את המשתנה הגלובלי א .
תְפוּקָה
3: הגדר פונקציה מחוץ לכיתה
ב-C++, אתה יכול להגדיר פונקציית מחלקה מחוץ להגדרת המחלקה וניתן לעשות זאת באמצעות ה מפעיל רזולוציית היקף (::) כדי לציין לאיזו מחלקה שייכת הפונקציה. זה הכרחי מכיוון שהפונקציה מוגדרת מחוץ להיקף המחלקה.
הנה קוד לדוגמה שמדגים את השימוש הזה ב- מפעיל רזולוציית היקף :
#includeבאמצעות מרחב שמות std ;
class myClass {
פּוּמְבֵּי :
בָּטֵל התפקוד שלי ( ) ;
} ;
בָּטֵל הכיתה שלי :: התפקוד שלי ( ) {
cout << 'myfunction() נקרא !' ;
}
int רָאשִׁי ( )
{
myClass classObj ;
classObj. התפקוד שלי ( ) ;
לַחֲזוֹר 0 ;
}
בקוד לעיל, הפונקציה חבר myfunction() מוגדר מחוץ למחלקה באמצעות ה- מפעיל רזולוציית היקף :: כדי לציין זאת myfunction() שייך לכיתה myClass.
תְפוּקָה
4: גישה לחברים סטטיים של הכיתה
ב-C++, כאשר יש איבר סטטי ומשתנה מקומי בעל אותו שם קיים בתוך המחלקה, ה- מפעיל רזולוציית היקף (::) ניתן להשתמש כדי לגשת לחברים סטטיים של מחלקה. זה מאפשר לתוכנית להבחין בין המשתנה המקומי לאיבר הסטטי.
להלן קוד לדוגמה המתייחס לשימוש ב מפעיל רזולוציית היקף למקרה כזה:
#includeבאמצעות מרחב שמות std ;
class myClass {
פּוּמְבֵּי :
סטָטִי int myStatVar ;
} ;
int הכיתה שלי :: myStatVar = 5 ;
int רָאשִׁי ( ) {
int myStatVar = 10 ;
cout << 'משתנה מקומי myStatVar: ' << myStatVar << endl ;
cout << 'משתנה מחלקה myStatVar: ' << הכיתה שלי :: myStatVar << endl ;
לַחֲזוֹר 0 ;
}
התוכנית לעיל מגדירה תחילה מחלקה הכיתה שלי עם משתנה איבר סטטי myStatVar . לאחר מכן הוא מגדיר משתנה מקומי עם אותו שם בתוך הפונקציה הראשית של התוכנית. כדי לגשת למשתנה המחלקה, ה- מפעיל רזולוציית היקף (::) משמש עם שם המחלקה הכיתה שלי . התוכנית מוציאה את הערך של שני המשתנים למסוף.
תְפוּקָה
5: השתמש עם ירושות מרובות
ה מפעיל רזולוציית היקף (::) משמש גם כדי לציין באיזו גרסה של חבר להשתמש כאשר מחלקה C++ נגזרת ממספר מחלקות אב שיש להן משתני איבר או פונקציות עם אותו שם. אנו יכולים להבחין בין גרסאות שונות של אותו חבר על ידי שימוש ב- מפעיל רזולוציית היקף ואחריו שם כיתה האב ושם החבר.
#includeבאמצעות מרחב שמות std ;
כיתה הורה 1 {
פּוּמְבֵּי :
בָּטֵל הדפס ( ) {
cout << 'זוהי פונקציית ההדפסה של Class Parent1.' << endl ;
}
} ;
כיתה הורה 2 {
פּוּמְבֵּי :
בָּטֵל הדפס ( ) {
cout << 'זוהי פונקציית הדפסה מסוג Parent2.' << endl ;
}
} ;
class myClass : הורה ציבורי 1 , הורה ציבורי 2 {
פְּרָטִי :
int על אחד ;
פּוּמְבֵּי :
הכיתה שלי ( int נ ) {
על אחד = נ ;
}
בָּטֵל הדפס ( ) {
הורה 1 :: הדפס ( ) ; // קרא לפונקציית ההדפסה של Parent1
הורה 2 :: הדפס ( ) ; // קרא לפונקציית ההדפסה של Parent2
cout << 'הערך של num הוא:' << על אחד << endl ; // הדפס את הערך של num
}
} ;
int רָאשִׁי ( ) {
myClass obj ( 42 ) ; // צור אובייקט של MyClass עם num מאותחל ל-42
obj. הדפס ( ) ; // קרא לפונקציה print() של האובייקט
לַחֲזוֹר 0 ;
}
התוכנית לעיל מדגימה את השימוש ב- מפעיל רזולוציית היקף (::) להבחין בין פונקציות ההדפסה של הורה 1 ו הורה 2 כאשר שתי המחלקות עוברות בירושה על ידי הכיתה שלי. על ידי קריאה לפונקציות עם ה כיתת הורים שם לפני שם הפונקציה, נוכל לציין באיזו גרסה של הפונקציה להשתמש.
תְפוּקָה
שורה תחתונה
ה מפעיל רזולוציית היקף (::) הוא רכיב חיוני ב-C++ המשמש לגישה לשמות משתנים ברמות היקף שונות. לאופרטור שימושים שונים, כולל גישה למשתנה או פונקציה במרחב שמות אחר, גישה למשתנה גלובלי, הגדרת פונקציה מחוץ למחלקה, גישה לאיברים סטטיים של מחלקה ושימוש במספר ירושות. למרות שזה יכול להיות מבלבל עבור מפתחים חדשים, להבין את מפעיל רזולוציית היקף (::) חיוני לתרגול תכנות טוב.