במאמר זה, אנו הולכים לדון בתפיסת הירושה בתכנות C ++. נסביר את הרעיון של פונקציית החברים ב- C ++ בעזרת דוגמאות עבודה.
למה ירושה?
ירושה מאפשרת ליצור מחלקה חדשה או מחלקה נגזרת ממעמד אחר או מחלקה בסיסית. למחלקה הנגזרת או למעמד הילד יהיו כל התכונות של מחלקת ההורים או כיתת הבסיס. אנו יכולים להשתמש בקוד מחדש בעזרת ירושה.
סוג הירושה
ישנם סוגים שונים של ירושה:
- ירושה פשוטה/יחידה
- ירושה היררכית
- ירושה מרובת רמות
- ירושה מרובה
במאמר זה אנו הולכים לשקול רק ירושה פשוטה/יחידה.
דוגמה 1:
כעת, הבה נבחן תוכנית לדוגמא להבנת מושג הירושה ב- C ++. הגדרנו מחלקה בסיסית ולאחר מכן נגזר ממנה מחלקה נוספת. לכן, למחלקה הנגזרת יהיו התכונות (חברים ופונקציות) ממעמד הבסיס.
#לִכלוֹלבאמצעות מרחב שמות std;
class Base_Class
{
פּוּמְבֵּי:
intאני;
בָּטֵללְהַצִיג()
{
עֲלוּת<< 'תצוגת מחלקה בסיסית' <<אני<<endl;
}
};
class Derived_Class:public_Class ציבורי
{
פּוּמְבֵּי:
בָּטֵלהופעה()
{
עֲלוּת<< 'מופע בכיתה נגזרת' <<endl;
}
};
intרָאשִׁי()
{
Derived_Class dc;
זֶרֶם יָשָׁר.אני = 100;
זֶרֶם יָשָׁר.לְהַצִיג();
זֶרֶם יָשָׁר.הופעה();
לַחֲזוֹר 0;
}
דוגמה 2:
זוהי דוגמה נוספת לתורשה ב- C ++. בדוגמה זו, אנו הולכים לראות כיצד קוראים לבנאים כאשר נוצר אובייקט מחלקה נגזר.
כפי שניתן לראות להלן, הגדרנו שני בוני מחלקות בסיס ושלושה בוני מחלקות נגזרות. אתה יכול להבחין בבירור מהפלט שלהלן כי בונה מחלקת הבסיס נקרא תחילה לפני שנקרא בונה המחלקה הנגזר.
#לִכלוֹלבאמצעות מרחב שמות std;
class Base_Class
{
פּוּמְבֵּי:
Base_Class()
{
עֲלוּת<< 'Base_Class - ללא פרמטרים' <<endl;
}
Base_Class(intאיקס)
{
עֲלוּת<< 'Base_Class - פרמטרים:' <<איקס<<endl;
}
};
class Derived_Class:public_Class ציבורי
{
פּוּמְבֵּי:
Derived_Class()
{
עֲלוּת<< 'Derived_Class - ללא פרמטרים' <<endl;
}
Derived_Class(intו)
{
עֲלוּת<< 'Derived_Class - פרמטרים:' <<ו<<endl;
}
Derived_Class(intאיקס,intו):Base_Class(איקס)
{
עֲלוּת<< 'Param של Derived_Class:' <<ו<<endl;
}
};
intרָאשִׁי()
{
Derived_Class d(7,19);
}
דוגמה 3:
בדוגמה זו, אנו הולכים לראות כיצד ניתן להשתמש באובייקטים ממעמד נגזר.
כפי שאתה יכול לראות, ישנן שתי מחלקות המוגדרות: Rectangle_Class ו- Cube_Class. המחלקה Rectangle_Class היא מחלקת הבסיס שממנה נגזרת המחלקה הנגזרת, כלומר Cube_Class. לכן, אנו יורשים את התכונות מה- Rectangle_Class ל- Cube_Class.
כמו כן, תוכל להבחין כי אנו יורשים את Cube_Class עם בקרת הגישה הציבורית. המשמעות היא שהמחלקה הנגזרת יכולה לגשת לכל החברים הלא-פרטיים של מחלקת הבסיס.
הכרזנו אובייקט מהמחלקה הנגזרת, ולאחר מכן התקשר לשיטות ממחלקת הבסיס, כלומר setLength () ו- setBreadth ().
#לִכלוֹלבאמצעות מרחב שמות std;
class Rectangle_Class
{
פְּרָטִי:
intאורך;
intרוֹחַב;
פּוּמְבֵּי:
Rectangle_Class();
Rectangle_Class(intה,intב);
Rectangle_Class(Rectangle_Class&r);
intgetLength()
{
לַחֲזוֹראורך;
}
intgetBreadth()
{
לַחֲזוֹררוֹחַב;
}
בָּטֵלsetLength(intה);
בָּטֵלsetBreadth(intב);
intאֵזוֹר();
};
class Cube_Class:Rectangle_Class הציבורי
{
פְּרָטִי:
intגוֹבַה;
פּוּמְבֵּי:
Cube_Class(intח)
{
גוֹבַה=ח;
}
intgetHeight()
{
לַחֲזוֹרגוֹבַה;
}
בָּטֵלsetHeight(intח)
{
גוֹבַה=ח;
}
intכרך()
{
לַחֲזוֹרgetLength()*getBreadth()*גוֹבַה;
}
};
Rectangle_Class::Rectangle_Class()
{
אורך=1;
רוֹחַב=1;
}
Rectangle_Class::Rectangle_Class(intה,intב)
{
אורך=ה;
רוֹחַב=ב;
}
Rectangle_Class::Rectangle_Class(Rectangle_Class&r)
{
אורך=r.אורך;
רוֹחַב=r.רוֹחַב;
}
בָּטֵלRectangle_Class::setLength(intה)
{
אורך=ה;
}
בָּטֵלRectangle_Class::setBreadth(intב)
{
רוֹחַב=ב;
}
intRectangle_Class::אֵזוֹר()
{
לַחֲזוֹראורך*רוֹחַב;
}
intרָאשִׁי()
{
Cube_Class c(8);
ג.setLength(12);
ג.setBreadth(9);
עֲלוּת<<'עוצמת הקול היא'<<ג.כרך()<<endl;
}
סיכום:
במאמר זה הסברתי את המושג ירושה ב C ++ . ה- C ++ תומך בסוגים שונים של ירושה כולל ירושה מרובה (כלומר תכונות יורשות ממחלקות בסיסיות או מחלקת הורים). עם זאת, כדי להפוך את זה לפשוט יותר, שקלתי כאן רק ירושה אחת. הראיתי שלוש דוגמאות עבודה להסבר כיצד אנו יכולים להשתמש בתורשה בתכנות C ++ ולהשתמש מחדש בקוד. יתר על כן, זוהי תכונה שימושית מאוד של C ++.