תוכן המאמר
- אזור הצהרה והיקף
- ראיה גלובלית
- חסום היקף
- היקף פונקציה
- היקף ספירה
- היקף הכיתה
- היקף פרמטר התבנית
- שם מסתתר
- אפשרות לחזור על הצהרה באותו היקף
- היקף מרחב שמות
- היקף בחלקים שונים
- סיכום
אזור הצהרה והיקף
אזור הצהרתי הוא החלק הגדול ביותר של טקסט תוכנית שבו שם הישות תקף. זהו האזור בו ניתן להשתמש (לראות) בשם הבלתי מוסמך כדי להתייחס לאותה ישות. שקול את התוכנית הקצרה הבאה:
#לִכלוֹל
באמצעות מרחב שמותשעה (ות;
בָּטֵלfn()
{
intאיפה= 3;
אם (1==1)
{
עֲלוּת<<איפה<<' n';
}
}
intרָאשִׁי()
{
fn();
לַחֲזוֹר 0;
}
הפונקציה fn () כוללת שני בלוקים: בלוק פנימי למצב ה- if ובלוק חיצוני לגוף הפונקציה. המזהה, var, מוצג ונראה בגוש החיצוני. הוא נראה גם בגוש הפנימי, עם הצהרת ההתייחסות. הבלוקים החיצוניים והפנימיים הם שניהם היקף השם, var.
עם זאת, עדיין ניתן להשתמש בשם var כדי להכריז על ישות אחרת כגון ציפה בבלוק הפנימי. הקוד הבא ממחיש זאת:
#לִכלוֹל
באמצעות מרחב שמותשעה (ות;
בָּטֵלfn()
{
intאיפה= 3;
אם (1==1)
{
לָצוּףאיפה= 7.5;
עֲלוּת<<איפה<<' n';
}
}
intרָאשִׁי()
{
fn();
לַחֲזוֹר 0;
}
התפוקה היא 7.5. במקרה זה, לא ניתן להשתמש עוד בשם var, בבלוק הפנימי כדי להתייחס למספר השלם של ערך 3, שהוצג (הוכרז) בבלוק החיצוני. בלוקים פנימיים כאלה מכונים היקף פוטנציאלי לגופים המוצהרים בבלוק החיצוני.
הערה: ישות מאותו סוג, כמו זה של הבלוק החיצוני, עדיין יכולה להיות מוכרזת בגוש הפנימי. עם זאת, במקרה זה, מה שתקף בבלוק הפנימי הוא ההכרזה החדשה ומשמעותה, בעוד שההצהרה הישנה ומשמעותה מחוץ לגוש הפנימי נשארות תקפות בגוש החיצוני.
הכרזה של אותו שם בבלוק פנימי בדרך כלל גוברת על ההכרזה על אותו שם מחוץ לגוש הפנימי הזה. בלוקים פנימיים יכולים לקנן בלוקים פנימיים אחרים.
ראיה גלובלית
כאשר מתכנת רק מתחיל להקליד קובץ, זהו ההיקף הגלובלי. התוכנית הקצרה הבאה ממחישה זאת:
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
לָצוּףאיפה= 9.4;
intרָאשִׁי()
{
עֲלוּת <<איפה<<' n';
עֲלוּת <<::איפה<<' n';
לַחֲזוֹר 0;
}
הפלט הוא:
9.4
9.4
במקרה זה, האזור ההצהרתי או ההיקף של var מתחיל מנקודת ההצהרה עבור var, ממשיך כלפי מטה עד סוף הקובץ (יחידת תרגום).
הבלוק של הפונקציה הראשית () הוא היקף אחר; זהו היקף מקונן להיקף הגלובלי. כדי לגשת לישות בהיקף הגלובלי, מהיקף אחר, המזהה משמש ישירות או לפניו של מפעיל פתרון ההיקפים, ::.
הערה: הישות, main (), מוצהרת גם בהיקף הגלובלי.
חסום היקף
הצהרת if, while, do, for או switch יכולה כל אחת להגדיר בלוק. אמירה כזו היא אמירה מורכבת. לשם המשתנה שהוכרז בבלוק יש היקף של בלוק. היקפו מתחיל בנקודת ההצהרה שלו ומסתיים בסוף החסימה שלו. התוכנית הקצרה הבאה ממחישה זאת עבור המשתנה, ident:
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
intרָאשִׁי()
{
אם (1==1)
{
/*כמה הצהרות*/
intזהות= 5;
עֲלוּת<<זהות<<' n';
/*כמה הצהרות*/
}
לַחֲזוֹר 0;
}
משתנה, כגון ident, המוצהר בהיקף הבלוק הוא משתנה מקומי.
משתנה המוצהר מחוץ להיקף הבלוק ומעליו ניתן לראות בכותרת הבלוק (למשל, תנאי עבור if-block) וגם בתוך הבלוק. התוכנית הקצרה הבאה ממחישה זאת עבור המשתנה, מזהה:
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
intרָאשִׁי()
{
intמזהה= 8;
אם (מזהה== 8)
{
עֲלוּת<<מזהה<<' n';
}
לַחֲזוֹר 0;
}
הפלט הוא 8. יש כאן שני היקפי בלוקים: הבלוק עבור הפונקציה הראשית () והצהרה המקוננת אם-מורכבת. הבלוק המקונן הוא ההיקף הפוטנציאלי של בלוק הפונקציות הראשי ().
לא ניתן לראות הכרזה שהוצגה בהיקף בלוק מחוץ לגוש. התוכנית הקצרה הבאה, שאינה מלמדת, ממחישה זאת עם המשתנה, variab:
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
intרָאשִׁי()
{
אם (1 == 1)
{
intvariab= חֲמֵשׁ עֶשׂרֵה;
}
עֲלוּת<<variab<<' n'; // שגיאה: גישה אליה מחוץ להיקפה.
לַחֲזוֹר 0;
}
המהדר יוצר הודעת שגיאה עבור variab.
ישות שהוצגה, המוצהרת בכותרת של פונקציה מורכבת, לא ניתן לראות מחוץ (מתחת) להצהרה המורכבת. הקוד של הלולאה הבא לא יקבץ, וכתוצאה מכך תופיע הודעת שגיאה:
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
intרָאשִׁי()
{
ל (intאני=0;אני<4; ++אני)
{
עֲלוּת<<אני<<'';
}
עֲלוּת<<אני<<'';
לַחֲזוֹר 0;
}
משתנה האיטרציה, i, נראה בתוך הבלוק של הלולאה אך לא מחוץ לגוש הלולאה.
היקף פונקציה
ניתן לראות פרמטר פונקציה בבלוק הפונקציות. ישות המוצהרת בבלוק פונקציות נראית מנקודת ההצהרה ועד סוף גוש הפונקציות. התוכנית הקצרה הבאה ממחישה זאת:
#לִכלוֹל#לִכלוֹל
באמצעות מרחב שמותשעה (ות;
מחרוזת fn(string str)
{
לְהַשְׁחִירstri[] = 'בננות';
/*הצהרות אחרות*/
string stringStr=עמ+stri;
לַחֲזוֹרtotalStr;
}
intרָאשִׁי()
{
string totStr=fn('אוכל');
עֲלוּת<<totStr<<' n';
לַחֲזוֹר 0;
}
הפלט הוא:
לאכול בננות
הערה: ישות המוצהרת מחוץ לפונקציה (מעליה) ניתן לראות ברשימת פרמטרי הפונקציות וגם בגוש הפונקציות.
תווית
היקף התווית הוא הפונקציה שבה היא מופיעה. הקוד הבא ממחיש זאת:
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
בָּטֵלfn()
{
לך לlabl;
/*הצהרות אחרות*/
labl: intלֹא= 2;
עֲלוּת<<לֹא<<' n';
}
intרָאשִׁי()
{
fn();
לַחֲזוֹר 0;
}
הפלט הוא 2.
היקף ספירה
ספירה ללא היקף
שקול את ה- if-block הבא:
{
enum {א ב ג=ב+2};
עֲלוּת<<ל<<''<<ב<<''<<ג<<' n';
}
הפלט הוא 0 1 3.
השורה הראשונה בבלוק היא ספירה, a, b ו- c הם מוניה. היקפו של מונה מתחיל מנקודת ההצהרה ועד לסוף הבלוק המקיף של הספירה.
ההצהרה הבאה לא תתקבץ מכיוון שנקודת ההצהרה של c היא אחריה של:
enum {ל=ג+2, ב, ג};קטע הקוד הבא לא יתאסף כיוון שנגישות הסופרים לאחר הבלוק המצורף של הספירה:
אם (1==1){
enum {א ב ג=ב+2};
}
עֲלוּת<<ל<<''<<ב<<''<<ג<<' n'; // שגיאה: מחוץ לתחום
הספירה לעיל מתוארת כמניין לא ממוקד, וסופריו מתוארים כמנינים בלתי ממוקדים. הסיבה לכך היא שהיא מתחילה רק במילה השמורה, enum. ספירות המתחילות בכיתה enum או במבנה enum מתוארות כמנין היקף. סופריהם מתוארים כמניני היקף.
ספירה נרחבת
המשפט הבא תקין:
זוהי דוגמה לספירה נרחבת. שם הכיתה הוא nam. כאן, היקף המונה מתחיל מנקודת ההצהרה ועד סוף הגדרת הספירה, ולא סופה של הבלוק המקיף לספירה. הקוד הבא לא יקבץ:
אם (1==1){
enum מעמדזָכָר{א ב ג=ב+2};
עֲלוּת<<ל<<''<<ב<<''<<ג<<' n'; // שגיאה: מחוץ להיקף עבור מחלקה enum או struct enum
}
היקף הכיתה
עם היקף רגיל, האזור הצהרתי מתחיל מנקודה, ואז ממשיך ועוצר בנקודה אחרת. ההיקף קיים באזור אחד רציף. עם המחלקה, היקפה של ישות יכול להיות באזורים שונים שאינם מחוברים זה לזה. הכללים עבור בלוקים מקוננים עדיין חלים. התוכנית הבאה ממחישה זאת:
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
// מחלקת בסיס
מעמדCla
{
פְּרָטִי:
intmemP= 5;
מוּגָן:
intmemPro= 9;
פּוּמְבֵּי:
בָּטֵלfn()
{
עֲלוּת<<memP<<' n';
}
};
// שיעור נגזר
מעמדDerCla: פּוּמְבֵּיCla
{
פּוּמְבֵּי:
intderMem=memPro;
};
intרָאשִׁי()
{
Cla obj;
obj.fn();
DerCla derObj;
עֲלוּת<<derObj.derMem<<' n';
לַחֲזוֹר 0;
}
הפלט הוא:
5
9
במחלקה Cla, המשתנה memP, נראה בנקודת ההצהרה. לאחר מכן, החלק הקצר של המוגן מדלג, ואז נראה שוב בבלוק הפונקציות של חברי הכיתה. מחלקים את המחלקה הנגזרת, ואז רואים אותה שוב בהיקף הפונקציות הראשי () (בלוק).
במחלקה Cla, המשתנה memPro, נראה בנקודת ההצהרה. את החלק מהפונקציה הציבורית fn () מדלגים, ואז רואים אותו בבלוק תיאור המחלקה הנגזר. הוא נראה שוב למטה בפונקציה הראשית ().
מפעיל פתרון טווח
אופרטור רזולוציית ההיקפים ב- C ++ הוא ::. הוא משמש לגישה לחבר סטטי בכיתה. התוכנית הבאה ממחישה זאת:
באמצעות מרחב שמותשעה (ות;
מעמדCla
{
פּוּמְבֵּי:
סטָטִי int קבועאני אני= 5;
פּוּמְבֵּי:
סטָטִי בָּטֵלfn()
{
עֲלוּת<<אני אני<<' n';
}
};
intרָאשִׁי()
{
עֲלוּת<<Cla::אני אני<<' n';
Cla::fn();
לַחֲזוֹר 0;
}
הפלט הוא:
5
5
החברים הסטטיים נראים בלוק הפונקציות הראשי (), אליו ניתן לגשת באמצעות אופרטור רזולוציית ההיקף.
היקף פרמטר התבנית
ההיקף הרגיל של שם פרמטר תבנית מתחיל מנקודת ההצהרה עד סוף הבלוק שלו, כמו בקוד הבא:
תבנית<סוג שםT,סוג שםU> מבנהגילאים{
טי ג'ון= אחת עשרה;
אתה פיטר= 12.3;
טי מרי= 13;
U Joy= 14.6;
};
U ו- T נראים בתוך הבלוק.
עבור אב טיפוס של פונקציית תבנית, ההיקף מתחיל מנקודת ההצהרה ועד סוף רשימת פרמטרי הפונקציה, כמו בהצהרה הבאה:
תבנית<סוג שםT,סוג שםU> בָּטֵלפוּנקצִיָה(אתה לא, אתה צ'ה,קבוע לְהַשְׁחִיר *עמ);עם זאת, בכל הנוגע לתיאור המחלקה (הגדרה), ההיקף יכול להיות גם בחלקים שונים כמו בקוד הבא:
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
תבנית<מעמדT,מעמדU> מעמדTheCla
{
פּוּמְבֵּי:
t num;
סטָטִיU ch;
בָּטֵלפוּנקצִיָה(אבא,קבוע לְהַשְׁחִיר *עמ)
{
עֲלוּת << 'יש ' <<על אחד<< 'ספרים שווים' <<לא<<עמ<< ' בחנות.' << ' n';
}
סטָטִי בָּטֵלכֵּיף(U ch)
{
אם (צ'== 'ל')
עֲלוּת << 'פונקציה רשמית של חבר סטטי' << ' n';
}
};
intרָאשִׁי()
{
TheCla<int,לְהַשְׁחִיר>obj;
obj.על אחד = 12;
obj.פוּנקצִיָה('$','500');
לַחֲזוֹר 0;
}
שם מסתתר
דוגמה להסתרת שמות מתרחשת כאשר השם של אותו סוג אובייקט מוכרז מחדש בגוש מקונן. התוכנית הבאה ממחישה זאת:
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
בָּטֵלfn()
{
intאיפה= 3;
אם (1==1)
{
intאיפה= 4;
עֲלוּת<<איפה<<' n';
}
עֲלוּת<<איפה<<' n';
}
intרָאשִׁי()
{
fn();
לַחֲזוֹר 0;
}
הפלט הוא:
4
3
זה בגלל var בבלוק המקונן הסתיר var בבלוק החיצוני.
אפשרות לחזור על הצהרה באותו היקף
נקודת ההצהרה היא המקום בו השם מוצג (לראשונה) בהיקפו.
אב טיפוס פונקציה
בדרך כלל אי אפשר להכריז על ישויות שונות, אפילו מסוגים שונים, באותו היקף. עם זאת, ניתן להכריז על אב טיפוס פונקציה יותר מפעם אחת באותו היקף. התוכנית הבאה עם שני אב טיפוס פונקציות והגדרת פונקציות מתאימה ממחישה זאת:
באמצעות מרחב שמותשעה (ות;
בָּטֵלfn(intעל אחד);
בָּטֵלfn(intעל אחד);
בָּטֵלfn(intעל אחד)
{
עֲלוּת<<על אחד<<' n';
}
intרָאשִׁי()
{
fn(5);
לַחֲזוֹר 0;
}
התוכנית עובדת.
פונקציות עמוסות
פונקציות עמוסות הן פונקציות בעלות אותו שם אך חתימות פונקציות שונות. כחריג נוסף, ניתן להגדיר פונקציות עמוסות עם אותו שם באותו היקף. התוכנית הבאה ממחישה זאת:
באמצעות מרחב שמותשעה (ות;
בָּטֵלfn(intעל אחד)
{
עֲלוּת<<על אחד<<' n';
}
בָּטֵלfn(לָצוּףלא)
{
עֲלוּת<<לא<<' n';
}
intרָאשִׁי()
{
fn(5);
לָצוּףflt= 8.7;
fn(flt);
לַחֲזוֹר 0;
}
הפלט הוא:
5
8.7
הפונקציות העומסות מדי הוגדרו בהיקף הגלובלי.
היקף מרחב שמות
ל- Namespace Scope מגיע מאמר משלו. המאמר האמור נכתב עבור אתר זה, linuxhint.com. פשוט הקלד את מילות החיפוש Namespace Scope בתיבת החיפוש של אתר זה (דף) ולחץ על OK, ותקבל את המאמר.
היקף בחלקים שונים
המעמד אינו התוכנית היחידה שבה ההיקף יכול להיות בחלקים שונים. מפרט חבר, שימושים מסוימים במפרט הסוג המשוכלל והוראות השימוש הן תוכניות אחרות בהן ההיקף נמצא במקומות שונים-לפרטים, ראה בהמשך.
סיכום
היקף הוא אזור הצהרתי. אזור הצהרתי הוא החלק הגדול ביותר של טקסט תוכנית שבו שם הישות תקף. ניתן לחלק אותו ליותר ממנה אחת בהתאם לתכניות תכנות מסוימות, כגון בלוקים מקוננים. החלקים שאין להם את נקודת ההצהרה מהווים את ההיקף הפוטנציאלי. ההיקף הפוטנציאלי עשוי להכיל את ההצהרה או לא.