אחת השפות הנפוצות ביותר ברמה גבוהה היא C++ שעוזרת לנו בפעולות ופונקציות שונות. בנוסף, הוא מציע מספר קובצי כותרות המכילים הצהרות פונקציות, ואנחנו עשויים ליצור מחלקות בקודי C++. תכונות אלו הופכות את העבודה שלנו לנוחה יותר. הליבה של עיקרון האנקפסולציה היא גטרים ומקבעים. Getters הופכים את הנתונים הפרטיים לנגישים לציבור. הם עשויים גם לשנות במידת מה את התוצאה שתוחזר. מגדירים מאפשרים לשנות משתנה פרטי. הם חיוניים מכיוון שהם עשויים להציע אישור לפני קביעת ערך. בואו ליישם את ה-Gutters and Setters אלה בקודי C++ שלנו כאן.
דוגמה 1:
אנו משתמשים בקבצי הכותרות כאן כדי להתחיל את הקוד שלנו מכיוון שהם זמינים לפיתוח C++. אנו טוענים את קבצי הכותרות הדרושים כדי להפעיל את הקוד הזה כדי להתחיל. קובצי הכותרות 'מחרוזת' ו-'iostream' כלולים בקוד זה. לאחר מכן אנו כוללים את 'מרחב השמות std' לאחר מכן.
לאחר מכן, אנו יוצרים כאן מחלקה 'טבלה' ומאתחלים משתנה פרטי בשם 'count' עם סוג הנתונים 'int' ומאחסנים בו '15' כערך שלו. לאחר מכן, אנו מכניסים את מילת המפתח 'ציבורי'. לאחר מכן, אנו יוצרים פונקציה בשם 'getCount()'. סוג הנתונים שלו הוא 'int'. זוהי פונקציית המשבר כאן. אנו מחזירים את ה'ספירה' הזו בפונקציה זו על ידי שימוש במילת המפתח 'החזרה'. לאחר מכן, אנו מפעילים את הפונקציה 'main()' הבאה שבה אנו יוצרים את האובייקט של המחלקה הקודמת עם השם 'T_obj'. לאחר מכן, אנו קוראים לפונקציה 'getCount()' עם אובייקט המחלקה הזה במשפט 'cout' כדי לקבל את הערך של count ולהדפיס את התוצאה כאן.
קוד 1:
#include#include
באמצעות מרחב שמות סטד ;
מעמד שולחן
{
פְּרָטִי :
int לספור = חֲמֵשׁ עֶשׂרֵה ;
פּוּמְבֵּי :
int getCount ( )
{
לַחֲזוֹר לספור ;
}
} ;
int רָאשִׁי ( )
{
טבלה T_obj ;
cout << 'אנחנו מקבלים את המספרים של הטבלה כאן שהם:' << T_obj. getCount ( ) ;
}
תְפוּקָה:
לאחר הקומפילציה מלאה ומוצלחת של קוד זה, אנו מקבלים את הפלט הרצוי הזה בו נוכל לראות שהוא מקבל את ערך הספירה ולהציג אותו כאן שהוא '15'. הוא מאותחל בתוך הכיתה 'פרטית'.
דוגמה 2:
קבצי הכותרות 'מחרוזת' ו-'iostream' הדרושים לקוד זה כלולים כאן. לאחר מכן נכלל 'מרחב השמות std'. לאחר מכן, אנו יוצרים מופע חדש של המחלקה 'MySquareClass', מאתחלים משתנה פרטי בשם 'squareSide' עם סוג הנתונים 'int', ומגדירים את הערך שלו ל- '5'. לאחר מכן מתווספת מילת המפתח 'ציבורי', ומפתחת פונקציה בשם 'getSquareSide()' עם סוג הנתונים 'int'.
כאן, היא מכונה פונקציית ה'משבר'. בתוך זה, אנו 'מחזירים' את ה-'SquareSide'. לכן, כאשר אנו קוראים לפונקציה הזו, היא נותנת את הערך 'squareSide'. לאחר מכן, אנו מניחים פונקציה נוספת בשם 'getSquarePerimeter()'. כאן, אנו מניחים את הנוסחה כדי למצוא את ההיקף כך שהיא תחזיר את היקף הריבוע לאחר קבלת הערך של הצלע של הריבוע והכפלתו ב-'4'. אנחנו צריכים גם למצוא את שטח הכיכר. לצורך כך, אנו מפתחים עוד פונקציה אחת בשם 'getSquareArea()' ומחשבים את שטח הריבוע בעזרת נוסחה המכפילה את צלעות הריבוע. הוא מחזיר את שטח הריבוע בכל פעם שאנו קוראים לו ומקבל את הערך של הצלע הריבועית מהמשתנה הקודם 'squareSide'.
כעת, עלינו לקרוא לפונקציות הללו. אנו מפעילים את ה-'main()' ואז יוצרים אובייקט של 'MySquareClass' עם השם 'sq_obj1'. לאחר מכן, אנו קוראים ומדפיסים את כל שלוש הפונקציות עם אובייקט המחלקה הזה בנפרד.
קוד 2:
#include#include
באמצעות מרחב שמות סטד ;
מעמד MySquareClass
{
פְּרָטִי :
int squareSide = 5 ;
פּוּמְבֵּי :
int getSquareSide ( )
{
לַחֲזוֹר squareSide ;
}
int getSquarePerimeter ( )
{
לַחֲזוֹר squareSide * 4 ;
}
int getSquareArea ( )
{
לַחֲזוֹר squareSide * squareSide ;
}
} ;
int רָאשִׁי ( )
{
MySquareClass sq_obj1 ;
cout << 'הצד של הריבוע =' <<
sq_obj1. getSquareSide ( ) << endl ;
cout << 'ההיקף של הריבוע = ' <<
sq_obj1. getSquarePerimeter ( ) << endl ;
cout << 'השטח של הריבוע = ' <<
sq_obj1. getSquareArea ( ) << endl ;
}
תְפוּקָה:
ראשית, הוא מציג את הצד של הריבוע, שהוא '5', בעזרת הפונקציה 'getSquareSide()'. לאחר מכן, הוא מדפיס את היקף הריבוע על ידי שימוש בפונקציה 'getSquarePerimeter()' ושטח הריבוע באמצעות הפונקציה 'getSquareArea()'.
דוגמה 3:
כאן, יש לנו את המחלקה 'Driver' שבה אנו שמים את מילת המפתח 'private' ומצהירים על 'driverSalary' כחבר הפרטי עם סוג הנתונים 'int'. לאחר מכן, יש לנו 'public' שבו אנו יוצרים פונקציה 'setDriverSalary' ומעבירים 'int d_s' כפרמטר של פונקציה זו. זוהי פונקציית הקובע כאן בקוד זה. כעת, אנו מקצים 'd_s' למשתנה 'driverSalary' בתוך פונקציה זו.
לאחר מכן, אנו יוצרים את פונקציית ה-getter הנקראת 'getDriverSalary' ומחזירים את השכר של הנהג. כעת, לאחר הפעלת ה-'main()', אנו יוצרים אובייקט של המחלקה שהוא 'driverObj_1' וקובעים את הערך של משכורת הנהג על ידי קריאה לפונקציה 'setDriverSalary()' והעברת '30000' כפרמטר שלה שהוא משכורת הנהג. לאחר מכן, אנו מדפיסים משכורת זו על ידי קריאה לפונקציה 'getDriverSalary()'.
קוד 3:
#includeבאמצעות מרחב שמות סטד ;
מעמד נהג {
פְּרָטִי :
int שכר נהג ;
פּוּמְבֵּי :
בָּטֵל setDriverSalary ( int d_s ) {
שכר נהג = d_s ;
}
int getDriverSalary ( ) {
לַחֲזוֹר שכר נהג ;
}
} ;
int רָאשִׁי ( ) {
Driver driverObj_1 ;
driverObj_1. setDriverSalary ( 30000 ) ;
cout << 'שכר הנהג הוא:' << driverObj_1. getDriverSalary ( ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, אנו קובעים את השכר של הנהג ומקבלים את שכרו לאחר קביעתו והצגתו במסך הפלט.
דוגמה 4:
המחלקה 'אדם' נוצרת בקוד זה שבו אנו מכריזים על שלושה משתנים 'פרטיים' בשם 'P_name', 'P_city' ו-'P_language' עם סוג הנתונים 'מחרוזת'. לאחר מכן, אנו יוצרים קונסטרוקטור 'ציבורי'. כאן, אנו מניחים את הפונקציה 'setPersonName()' ונשים את 'string newName' כפרמטר של הפונקציה. לאחר מכן, אנו מקצים את ה-'newName' הזה למשתנה 'P_name'. לאחר מכן, אנו יוצרים את הפונקציה 'getPersonCity()' ומחזירים את 'P_city'. באותו אופן, אנו יוצרים פונקציה נוספת עם השם 'setPersonCity()'. לאחר מכן, אנו מעבירים את 'עיר מחרוזת' כפרמטר.
המשתנה 'עיר' מוקצה כעת למשתנה 'P_city'. ה-'getPersonLanguage()' היא הפונקציה הבאה כאן שגם מחזירה את ה-'P_language'. יתרה מכך, אנו גם מגדירים את הפונקציה 'setPersonLanguage()' ומעבירים לה את המחרוזת 'lang' כפרמטר שלה. לאחר מכן, ה-'lang' מוקצה למשתנה 'P_language'. לאחר מכן, יש לנו עוד שתי פונקציות, 'חי()' ו-'דבר()', בהן אנו משתמשים במשפט 'cout()'.
לאחר ביצוע שיטת 'main()', אנו יוצרים כעת אובייקט מהמחלקה בשם 'p_obj1'. כאן, אנו מגדירים את שם האדם על ידי הפעלת הפונקציה 'setPersonName()' ומספקת את שמו של האדם שהוא 'Samuel' כפרמטר שלה. לאחר מכן, אנו מגדירים את העיר של האדם על ידי קריאה לפונקציה 'setPersonCity()' והעברת 'לונדון' כפרמטר. לאחר מכן, אנו גם מגדירים את השפה של האדם באמצעות הפונקציה 'setPersonLanguage()' ומעבירים את 'אנגלית' כפרמטר שלה. כעת, אנו קוראים לפונקציות 'lives()' ו-'speak()' בנפרד עם האובייקט של המחלקה 'p_obj1'.
קוד 4:
#includeבאמצעות מרחב שמות סטד ;
מעמד אדם
{
פְּרָטִי :
מחרוזת P_name ;
מחרוזת P_city ;
מחרוזת P_language ;
פּוּמְבֵּי :
בָּטֵל setPersonName ( מחרוזת newName ) {
P_name = שם חדש ;
}
מחרוזת getPersonCity ( ) {
לַחֲזוֹר P_city ;
}
בָּטֵל setPersonCity ( עיר מחרוזת ) {
P_city = עִיר ;
}
מחרוזת getPersonLanguage ( ) {
לַחֲזוֹר P_language ;
}
בָּטֵל setPersonLanguage ( string lang ) {
P_language = רַק ;
}
בָּטֵל חיים ( )
{
cout << P_name << ' גר ב ' << P_city << endl ;
}
בָּטֵל לְדַבֵּר ( )
{
cout << P_name << 'מדבר' << P_language << endl ;
}
} ;
int רָאשִׁי ( ) {
אדם p_obj1 ;
p_obj1. setPersonName ( 'סמואל' ) ;
p_obj1. setPersonCity ( 'לונדון' ) ;
p_obj1. setPersonLanguage ( 'אנגלית' ) ;
p_obj1. חיים ( ) ;
p_obj1. לְדַבֵּר ( ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, הוא מציג את כל הערכים שהגדרנו בקוד שלנו כתוצאה מכך. אנו מקבלים תוצאה זו על ידי קריאה לפונקציה שיצרנו.
סיכום
במדריך זה חקרנו את הגורמים והמגדירים בתכנות C++. הסברנו ששיטות ה'מג'טר' וה'מגדיר' מציעות הפשטה והפקה טובה יותר של הפעולות הפנימיות של הכיתה. בנוסף, בדקנו שפונקציונליות תקפות הנתונים כדי להגן על חבר הנתונים נשמרת, מה שמאפשר לכיתה לשנות את הקוד שלה מבלי להשפיע על הקוד החיצוני. עשינו זאת עם קודי C++ על ידי שימוש ב-Gutters ו-seters אלה.