דוגמה 1: תוכנית של פונקציית Const Member ב-C++
כאן, יש לנו תוכנית פשוטה של הפונקציה const member:
#includeבאמצעות מרחב שמות סטד ;
מעמד הכיתה שלי {
int על אחד ;
פּוּמְבֵּי :
הכיתה שלי ( int נ = 0 ) {
על אחד = נ ;
}
int getValue ( ) const {
לַחֲזוֹר על אחד ;
}
} ;
int רָאשִׁי ( ) {
const MyClass ג ( 30 ) ;
MyClass c1 ( 5 ) ;
cout << 'מספר באמצעות אובייקט c :' << ג. getValue ( ) ;
cout << ' \n מספר באמצעות אובייקט c1: ' << ג1. getValue ( ) ;
לַחֲזוֹר 0 ;
}
בתחילה, אנו מגדירים את קובץ הכותרת המאפשר את זרמי הקלט/פלט של התוכנית. לאחר מכן, אנו מגדירים את המחלקה 'MyClass' שבה אנו מכריזים על משתנה 'num' ואת פונקציות האיבר של הפונקציה MyClass() והפונקציה getVal(). בתוך הפונקציה MyClass() אנו מגדירים את הפרמטר 'n' עם הערך '0'. לאחר מכן, הארגומנט 'n' מוקצה למשתנה 'num'. לאחר מכן, אנו קוראים לפונקציה getVal() עם מילת המפתח 'const', מה שמציין שלא ניתן לשנות את המצב הנוכחי של האובייקט בקריאה לפונקציה. הפונקציה getVal() מחזירה את משתנה האיבר 'num'.
לבסוף, אנו מגיעים לפונקציה main() . כאן, אנו מגדירים את האובייקטים 'c' ו- 'c1' של הפונקציה MyClass() וגם מעבירים את הערכים לאובייקטים אלה. האובייקט 'c' מוגדר עם מילת המפתח 'const', מה שמציין שלא ניתן לשנות את הערך המוקצה לאובייקט זה.
הפלט של פונקציית האיבר const שנקראת על ידי האובייקט מוצג בהמשך. בדרך זו, נוכל להשתמש במילת המפתח 'const' עם פונקציית האיבר והאובייקט:
דוגמה 2: תוכנית של פונקציית חבר Const מחוץ למחלקה ב-C++
כעת, יש לנו יישום נוסף שבו הפונקציה const איבר מוגדרת מחוץ להגדרת מחלקה ומגדירה ומחזירה ערך משתנה איבר פרטי באמצעות פונקציית איבר const.
#includeבאמצעות מרחב שמות סטד ;
מעמד NewClass {
int אני ;
פּוּמְבֵּי :
בָּטֵל set_record ( int ) ;
int get_record ( ) const ;
} ;
בָּטֵל NewClass :: set_record ( int איקס ) { אני = איקס ; }
int NewClass :: get_record ( ) const { לַחֲזוֹר אני ; }
int רָאשִׁי ( )
{
NewClass ג ;
ג. set_record ( 10 ) ;
cout << ג. get_record ( ) ;
לַחֲזוֹר 0 ;
}
כאן, אנו מקימים תחילה מחלקה, 'NewClass', שבה אנו מאתחלים את המשתנה 'i' שנשמר פרטי. לאחר מכן, יש לנו מילת מפתח ציבורית שבה מוגדרות פונקציות החברים set_record() ו-get_record(). הפונקציה איבר set_record() משמשת להגדרת הערך של המשתנה 'i' והפונקציה get_record() משמשת כאן להחזרת הערך של המשתנה 'i'. שימו לב שאנו משתמשים במילת המפתח 'const' עם פונקציית האיבר get_record() המייצגת אותה כפונקציית איבר const, ולא ניתן לשנות את מצב האובייקט. לאחר מכן, יש לנו הגדרת פונקציה set_record() כדי להגדיר את ערך המשתנה 'i'.
באופן דומה, יש לנו את הגדרת הפונקציה get_record() כדי לאחזר את ערך המשתנה 'i'. לאחר מכן, אנו מגדירים את הפונקציה main() שבה יש לנו הצהרה של האובייקט 'c' של המחלקה 'NewClass'. לאחר מכן, ה-'set_record', פונקציה שאינה קשורה ל-const, נקראת כדי להקצות ערך למשתנה 'z'. ממשיכים הלאה, אנו קוראים לפונקציה get_record() const member כדי להדפיס את הערך של 'i'.
הערך של משתנה האיבר הפרטי נקרא על ידי הפונקציה const איבר והוא מוצג בהנחיה הבאה:
דוגמה 3: תוכנית של פונקציית חבר Const המוגדרת מחוץ לכיתה כפונקציה עצמאית
עם זאת, אנו מיישמים מקרה נוסף של פונקציית האיבר const שבו פונקציית האיבר עם מילת המפתח 'const' נקראת מחוץ למחלקה כפונקציה עצמאית.
#includeבאמצעות מרחב שמות סטד ;
מעמד משוואה {
int n1,n2 ;
פּוּמְבֵּי :
בָּטֵל set_equation ( int איקס, int ו )
{
n1 = איקס ;
n2 = ו ;
}
בָּטֵל show_equation ( )
{
cout << 'המשוואה היא:' << n1 << '+' << n2 << 'ב' << endl ;
}
חבר בָּטֵל זה כיף ( const משוואה ) ;
} ;
בָּטֵל זה כיף ( const משוואה obj )
{
cout << 'הפונקציה באמצעות המשוואה היא:' << obj. n1 << '+' << obj. n2 << 'ב' << endl ;
}
int רָאשִׁי ( )
{
משוואה obj ;
obj. set_equation ( 5 , 8 ) ;
obj. show_equation ( ) ;
זה כיף ( obj ) ;
}
כאן, אנו יוצרים את המחלקה 'Equation()' ואז מכריזים על המשתנים 'n1' ו- 'n2'. כאן, אנו גם מוסיפים את הפונקציה איבר set_Equation() כדי להגדיר את הערכים של המשתנים 'n1' ו-'n2'. הפונקציה show_Equation() מציגה את המשוואה שנוצרת באמצעות משתנים אלה.
לאחר מכן, יש לנו הצהרת פונקציה של funIs() המוגדרת באמצעות מילת המפתח 'חבר'. מילת המפתח 'חבר' זו מאפשרת לנו לגשת לחבר הפרטי בכיתה 'משוואה'. לאחר מכן, אנו קוראים לפונקציית החברים 'funIs()' מחוץ למחלקה ומזין את הפרמטר 'obj' של המחלקה 'משוואה' בתור const. בסופו של דבר, יש לנו פונקציה main() שבה אנו מכריזים על האובייקט של המחלקה 'משוואה'. לאחר מכן, אנו מגדירים את הערכים של המשתנים 'n1' ו-'n2 באמצעות הפונקציה set_Equation() . המשתנים 'n1' ו- 'n2' משמשים להצגת הערכים שלהם באמצעות הפונקציה show_Equation() . לבסוף, אנו קוראים לפונקציית החברים 'funIs' של המחלקה 'משוואה' כדי להציג את המשוואה.
המשוואה והמשוואה באמצעות הפונקציה const friend מוצגות בהנחיה:
דוגמה 4: תוכנית של פונקציית חבר Const לעדכון הערך ב-C++ (המקרה הגרוע ביותר)
התוכנית מדגימה את התרחיש הגרוע ביותר של פונקציית האיבר const שבו אנו מנסים לשנות את הערך של המשתנה שנקרא 'בתוך פונקציית האיבר const'.
#includeבאמצעות מרחב שמות סטד ;
מעמד נתונים {
int ב ;
פּוּמְבֵּי :
בָּטֵל הגדר ערך ( int אני ) { ב = אני ; }
int getValue ( ) const
{
++ ב ;
לַחֲזוֹר ב ;
}
} ;
int רָאשִׁי ( )
{
נתונים ד ;
ד. הגדר ערך ( עשרים ) ;
cout << endl << ד. getValue ( ) ;
לַחֲזוֹר 0 ;
}
כאן, אנו בונים תחילה את המחלקה 'Data' ומכריזים על המשתנה 'v' בתוך המחלקה. לאחר מכן, אנו מגדירים את מילת המפתח 'public' ולאחר מכן מכריזים על פונקציות חבר המחלקה של 'setValue()' המייצג את הבנאי של המחלקה וה-getValue() המציין את פונקציית החברים של המחלקה. הפונקציה setValue() לוקחת את המשתנה 'i' כפרמטר. משתנה 'i' זה מוקצה למשתנה האיבר 'v'.
לאחר מכן, יש לנו את הגדרת הפונקציה getValue() שבה אנו מאחזרים את הערך של המשתנה 'v'. מכיוון שהפונקציה getValue() מוצהרת עם מילת המפתח 'const', המייצגת שבכל מקרה לא ניתן לעדכן את הערך של המשתנה 'v'. עם זאת, אנו מנסים בכוונה להגדיל את המשתנה 'v' כדי לשנות את הערך שלו. כאשר התוכנית מגיעה לשלב זה, נזרקת שגיאה. לבסוף, יש לנו את קריאת הפונקציה main() שבה אנו מגדירים את האובייקט 'd' של המחלקה 'Data' וקובעים את הערך של '20' עבור אובייקט 'd' זה. לאחר מכן, אנו קוראים לפונקציה getValue() כדי לקבל את הערך 'd' של האובייקט.
ההנחיה מייצרת את התוצאות של היישום הקודם שבו היא נותנת שגיאה ב-'++v' מכיוון שאיננו רשאים לשנות את הערך של אובייקטי הפונקציה איבר const:
סיכום
לסיכום, אנו צוללים לתוך הפונקציה const של C++ המשמשת כדי למנוע שינויים מקריים בערך התוכנית. פונקציות האיבר const ב-C++ הן פונקציות לקריאה בלבד שאסור לשנות את האובייקטים שעליהם היא נקראת. הטמענו גם תרחישים שונים של הפונקציה const כדי להדגים את הפונקציונליות שלה ב-C++.