ממשקים ב-C++ מיושמים באמצעות מחלקות מופשטות. מצד שני, מחלקה נקראת מחלקה מופשטת אם לפחות פונקציה אחת בתוך מחלקה מוכרזת כפונקציה וירטואלית טהורה.
מהי הפונקציה הווירטואלית הטהורה
ה פונקציה וירטואלית טהורה זה אומר שמשתמשים רק מצהירים על הפונקציה ולא על ההגדרה שלה. עקיפת שיטה/פונקציה משמשת ליישום שיטות וירטואליות טהורות במחלקה הנגזרת. פונקציה נחשבת וירטואלית טהורה אם היא מתוארת בתוך המחלקה כמפורט להלן:
הנה התחביר של א פונקציה וירטואלית טהורה של חדר הכיתה.
מעמד חֶדֶר {
פּוּמְבֵּי :
// פונקציה וירטואלית טהורה
וירטואלי לְהַכפִּיל גטריה ( ) = 0 ;
פְּרָטִי :
לְהַכפִּיל אורך ; // אורך חדר
לְהַכפִּיל רוֹחַב ; // רוחב חדר
} ;
מהו שיעור מופשט
מחלקה שנוצרה במיוחד במטרה לשמש כמחלקה בסיס נקראת an שיעור מופשט . לפחות פונקציה וירטואלית אחת טהורה חייבת להיות נוכחת במחלקה המופשטת. זה עשוי לכלול משתנים ופונקציות סטנדרטיות. המחלקות הנגזרות שיש למחלקה המופשטת, צריכות ליישם פונקציה וירטואלית טהורה של מחלקת הבסיס, אחרת הן יהפכו למופשטות.
שקול את הדוגמה הבאה, שבה מחלקת האב נותנת ממשק למחלקת בסיס על מנת שהמחלקה הבסיסית תפעיל פונקציה וירטואלית טהורה הנקראת getArea() . שתי כיתות שונות משתמשות באותו אופן getArea() פונקציה, אבל הפלט עבור שני המקרים יהיה שונה.
#include
באמצעות מרחב שמות סטד ;
מעמד צוּרָה
{
פּוּמְבֵּי :
וירטואלי int גטריה ( ) = 0 ;
בָּטֵל setWidth ( int wth )
{
רוֹחַב = wth ;
}
בָּטֵל setLength ( int הראשון )
{
אורך = הראשון ;
}
מוּגָן :
int רוֹחַב ;
int אורך ;
} ;
מעמד מַלבֵּן : פּוּמְבֵּי צוּרָה
{
פּוּמְבֵּי : int גטריה ( )
{
לַחֲזוֹר ( רוֹחַב * אורך ) ;
}
} ;
מעמד משולש : פּוּמְבֵּי צוּרָה
{
פּוּמְבֵּי : int גטריה ( )
{
לַחֲזוֹר ( רוֹחַב * אורך ) / 2 ;
}
} ;
int רָאשִׁי ( בָּטֵל )
{
מלבן R ;
משולש T ;
ר. setWidth ( 9 ) ;
ר. setLength ( 5 ) ;
cout << 'אזור מלבן:' << ר. גטריה ( ) << endl ;
ט. setWidth ( 9 ) ;
ט. setLength ( 5 ) ;
cout << 'אזור משולש:' << ט. גטריה ( ) << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה
חשיבות הממשקים
כל מחלקה הנגזרת ממחלקה אבסטרקטית טהורה (Interface) צריכה תמיד ליישם כל אחת מהשיטות של מחלקת הבסיס, כלומר ממשק. ניתן להעביר מצביעי ממשק לפונקציות כמו גם למחלקות, מה שמאפשר לנו לקרוא לפונקציות של המחלקה הנגזרת משם בעצמה.
מהם הכללים לשימוש בממשקים
ישנם כללים הבאים שמשתמשים צריכים לעקוב אחר שימוש בממשקים ב-C++:
- הכריז רק על פונקציות וירטואליות טהורות.
- הוקצה רק 0 לפונקציות וירטואליות טהורות.
- אל תיצור את הממשק של שיעורים.
- באמצעות הפניה למחלקה אבסטרקטית בסיסית, נוכל ליצור מצביע למופע של המחלקה הנגזרת.
בקוד הבא, ממשק לינוקס , כמו מחלקה מופשטת נוצרה על ידי שימוש בשיטה וירטואלית טהורה, כמו גם הפונקציה שלה מיושמת בכיתת הילד, וקראנו את returnString() שיטה בפונקציה הראשית על ידי ביצוע כללי הממשק.
#include#include
#include
באמצעות מרחב שמות סטד ;
מעמד לינוקס
{
פּוּמְבֵּי :
וירטואלי string returnString ( ) = 0 ;
} ;
מעמד יֶלֶד : פּוּמְבֵּי לינוקס
{
פּוּמְבֵּי :
string returnString ( )
{
לַחֲזוֹר 'שלום Linuxhint' ;
}
} ;
int רָאשִׁי ( )
{
ילד ילד_אובייקט ;
לינוקס * pntr ;
pntr = & חפץ_ילד ;
cout < returnString ( ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה
סיכום
ממשקים הם מחלקות מופשטות המתארות את התנהגות המחלקה שצריכה ליישם את המחלקה הנדרשת ב-C++. ההנחיות המוזכרות לעיל חיוניות למתחילים לשפר את כישורי התכנות שלו ב-C++ על ידי עבודה עם הממשקים. תמצא גם כמה דוגמאות שיעזרו לך ללמוד את הטמעת ממשקים ב-C++.