C++ מספק לנו את המאפשר ליצור את אובייקט המחלקה. אנו יוצרים את האובייקט רק לאחר שהכרזנו על מחלקה בקוד שלנו. במחלקה C++, שיטות מניפולציית הנתונים והנתונים משולבות לישות אחת. הכיתה היא אוסף של פריטים קשורים. יתר על כן, מחלקות מגדירות צורת אובייקט. אובייקט הוא יצירה המתרחשת בזמן ריצה. זה מופע בכיתה. בעזרת האובייקט, כל חברי הכיתה נגישים. כאן, ניצור את האובייקט של המחלקה ולאחר מכן ניגש לחברים שלה דרך האובייקט שלה במדריך זה.
דוגמה 1:
אנו כוללים את הפונקציות של קובץ הכותרת 'iostream' בקוד שלנו כדי להשתמש בהן. לאחר מכן, אנו מוסיפים את קובץ הכותרת 'מחרוזת' מכיוון שעלינו לעבוד עם ה'מחרוזת' בקוד זה. לאחר מכן אנו משתמשים במרחב השמות 'std' כדי לגשת לשיעורים שלו מבלי לקרוא לו. לאחר מכן, אנו יוצרים את המחלקה 'MyFirstClass' וממקמים איתה את מילת המפתח 'class'.
מתחת לזה, אנו ממקמים את ה-'public' שהוא מפרט הגישה כאן ומצהירים על התכונות של מחלקה זו שהן 'a' ו-'str_a'. סוג הנתונים של 'a' הוא 'int' וסוג הנתונים של 'str_a' הוא 'מחרוזת'. לאחר מכן אנו קוראים ל-'main()'. מתחת ל-'main()' הזה, אנו יוצרים את האובייקט של 'MyFirstClass' עם השם, 'myFirstObj'.
לאחר מכן, בשורה הבאה, אנו ניגשים לתכונות המחלקה בעזרת אובייקט המחלקה ומקצים להם ערכים. אנו מניחים את שם האובייקט, שמים נקודה ולאחר מכן מקלידים את שם התכונה כדי להקצות את הערך. אנו מקלידים 'myFirstObj.a' ומקצים '40' לתכונת 'a' זו. באותו אופן, אנו מקצים את נתוני המחרוזת לתכונה 'str_a'. המחרוזת שאנו מקצים למשתנה זה היא 'המחרוזת נמצאת כאן'.
לאחר מכן, אנו משתמשים ב-'cout' ומוסיפים את התכונות הללו יחד עם אובייקט הכיתה על ידי הצבת נקודה ביניהן. כעת, שתי התכונות, יחד עם הערכים שלהן, יוצגו.
קוד 1:
#include
#include
שימוש במרחב שמות std;
class MyFirstClass {
פּוּמְבֵּי:
int a;
מחרוזת str_a;
} ;
int main ( ) {
MyFirstClass myFirstObj;
myFirstObj.a = 40 ;
myFirstObj.str_a = 'המחרוזת כאן' ;
cout << 'המספר השלם הוא' << myFirstObj.a << endl;
cout << myFirstObj.str_a;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
אנו ניגשים לשתי תכונות המחלקה בעזרת מחלקת האובייקט. התכונות, יחד עם הערכים שלהן, מוצגות בקטע הבא:
דוגמה 2:
הכיתה שאנו יוצרים כאן היא כיתת 'דוקטור'. לאחר מכן, אנו מצהירים על כמה משתנים ציבוריים על ידי הצבת מילת המפתח 'ציבורי'. התכונות של מחלקה 'דוקטור' זו הן 'dr_id' ו-'dr_name' של סוגי הנתונים 'int' ו-'string', בהתאמה.
כעת, אנו מפעילים את הפונקציה 'main()'. לאחר מכן, אנו יוצרים את האובייקט של כיתת 'דוקטור'. השם של אובייקט המחלקה הוא 'd1'. לאחר מכן, אנו מקצים את הערכים לתכונות אלו בעזרת האובייקט 'd1'. אנו מקצים '123' ל-'dr_id' על ידי הצבת האובייקט 'd1' עם שם התכונה הזו. לאחר מכן, אנו מקצים את 'פיטר סמואל' לתכונה 'dr_name' על ידי הצבת האובייקט 'd1' עם זה.
כעת, אנו פשוט מציגים את שתי התכונות יחד עם הערכים שהקצנו בעבר באמצעות 'cout' והכנסת 'd1.dr_id' ו-'d1.dr_name' בו.
קוד 2:
#includeשימוש במרחב שמות std;
רופא בכיתה {
פּוּמְבֵּי:
int dr_id;
מחרוזת dr_name;
} ;
int main ( ) {
דוקטור ד1;
d1.dr_id = 123 ;
d1.dr_name = 'פיטר סמואל' ;
cout << 'זיהוי הרופא הוא' << d1.dr_id << endl;
cout << 'שם הרופא הוא' << d1.dr_name << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
ה'שם' וה'מזהה' של הרופא מוצגים כעת כאן. אנו גם מקצים את ה'שם' וה-'id' הללו לאחר יצירת האובייקט והקצאת הערך בעזרת האובייקט של המחלקה.
דוגמה 3:
מחלקת 'לקוח' היא זו שבנינו כאן. הכרזנו על כמה משתנים ציבוריים באמצעות מילת המפתח 'ציבורי'. ה-'clientId' ו-'clientName' של סוגי הנתונים 'int' ו-'string', בהתאמה, מוכרזים כאן כמאפיינים של המחלקה 'Client'.
לאחר מכן, אנו ממקמים את הפונקציה 'insert()' ומעבירים לתוכה שני פרמטרים, 'c_id' ו-'c_name', עם סוגי הנתונים שלהם שהם 'int' ו-'string', בהתאמה. לאחר מכן, אנו מקצים 'c_id' ל-'clientId' ו-'c_name' לתכונה 'clientName'. מתחת לזה, אנו משתמשים בפונקציה נוספת בשם 'display()' ומשתמשים ב-'cout' המסייע בהצגת ה-'clientId' ו-'clientName'. כאן, אנו קוראים לפונקציה 'main()' ומייצרים אובייקט מחלקה 'Client'. אובייקטי המחלקה נקראים 'c1', 'c2' ו-'c3'. אובייקטי המחלקה נוצרים על ידי הצבת שם המחלקה עם שם האובייקט שאנו רוצים ליצור כאן.
כעת, אנו מכניסים את הערכים בתכונות אלו על ידי שימוש בפונקציה 'insert()' עם שמות האובייקט 'c1', 'c2' ו-'c3'. אנו רוצים להציג את כל שלושת ערכי האובייקט, אז אנו שמים את הפונקציה 'display()' עם כל אובייקטי המחלקה הללו.
קוד 3:
#includeשימוש במרחב שמות std;
לקוח בכיתה {
פּוּמְבֵּי:
int clientId;
string clientName;
הוספה בטל ( int c_id, מחרוזת c_name )
{
clientId = c_id;
שם לקוח = c_name;
}
תצוגה ריקה ( )
{
cout << זיהוי לקוח << '' << שם הלקוח << endl;
}
} ;
int main ( בָּטֵל ) {
לקוח c1;
לקוח c2;
לקוח c3;
c1.insert ( 111 , 'ג'יימס' ) ;
c2.insert ( 112 , 'מרי' ) ;
c3.insert ( 113 , 'ג'ורג'' ) ;
c1.display ( ) ;
c2.display ( ) ;
c3.display ( ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
יצרנו שלושה אובייקטים בקוד הקודם והוספנו את הערכים על ידי שימוש באובייקטים אלו. גם רינדרנו את כל הערכים.
דוגמה 4:
אנו יוצרים את ה-'studentClass' ולאחר מכן מצהירים על המאפיינים 'ציבורי'. אנו מצהירים על ארבע תכונות של 'תלמיד כיתת' זה, שהן 'שם_שם', 'מחלקה_ש', 'שמגילה לא' ו'נושא_ש'. סוגי הנתונים של התכונות הללו שהם 'מחרוזת' עבור ה-'s_name', 'int' עבור 's_class', 'int' עבור 's_rollNo', ו-'string' עבור 's_subject' ממוקמים כאן. כעת, אנו מפעילים את 'main()' והאובייקט של 'studentClass' נוצר. האובייקט של 'studentClass' הוא 'stdObj1'. זה נוצר על ידי הצבת שם המחלקה ולאחר מכן את שם האובייקט אחרי ה-'main()'.
לאחר מכן, אנו מקצים את הערכים לכל התכונות הללו על ידי הצבת שם האובייקט ושם התכונה כאן. ראשית, אנו מניחים את ה-'stdObj1.s_name' ומקצים 'John'. לאחר מכן, אנו ממקמים את 'stdObj1.s_s_class' ומקצים '9' לתכונה זו. מתחת לזה, אנו מקצים '143' לתכונה 's_rollNo' לאחר הצבת שם האובייקט עם הנקודה. לאחר מכן, אנו שמים את שם האובייקט שוב עם הנקודה ומקצים 'מחשב' לתכונה 's_subject'.
באותו אופן, אנו מקצים 'וויליאם', '8', '211' ו'כימיה' לכל ארבע התכונות על ידי הצבת שם האובייקט עם שמות התכונות. לאחר מכן, אנו מציגים את כל הערכים הללו של התכונות על ידי הצבתם ב-'cout'. לצורך עיבוד, אנו מציבים גם את שמות התכונה והאובייקטים עם כל התכונות הללו.
קוד 4:
#include#include
שימוש במרחב שמות std;
תלמיד כיתה {
פּוּמְבֵּי:
מחרוזת s_name;
int s_class;
int s_rollNo;
מחרוזת s_subject;
} ;
int main ( ) {
studentClass stdObj1;
stdObj1.s_name = 'ג'ון' ;
stdObj1.s_class = 9 ;
stdObj1.s_rollNo = 143 ;
stdObj1.s_subject = 'מַחשֵׁב' ;
studentClass stdObj2;
stdObj2.s_name = 'וויליאם' ;
stdObj2.s_class = 8 ;
stdObj2.s_rollNo = 211 ;
stdObj2.s_subject = 'כִּימִיָה' ;
cout << stdObj1.s_name << '' << stdObj1.s_class << '' << stdObj1.s_rollNo << '' << stdObj1.s_subject << endl ;
cout << stdObj2.s_name << '' << stdObj2.s_class << '' << stdObj2.s_rollNo << '' << stdObj2.s_subject << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כל הערכים שאנו מקצים לתכונות המחלקה לאחר יצירת אובייקט המחלקה מוצגים בפלט זה.
סיכום
למדנו כיצד ליצור אובייקט ב-C++ במדריך זה בפירוט. יצרנו אובייקט אחד ואובייקטים מרובים של המחלקה בקוד שלנו. הקצינו את הערכים גם לתכונות המחלקה עם אובייקטי המחלקה. כל הדוגמאות מוסברות כאן והפלטים מוצגים גם במדריך זה.