דף הבית >>הורשה>> גישה למחלקת בסיס>>הורשה וחברים מוגנים>> הורשת מחלקת בסיס מוגנת>>פונקציות בונות הורסות והורשה>>העברת נתונים למחלקת בסיס

 

העברת נתונים לבנאי של מחלקת בסיס

 

הנוסחה המורחבת של של הצהרת הבנאים במחלקות הנגזרות אשר מעבירות איתם ארגומנטים לאחד או יותר מבסיסי המחלקות תוצג כאן : 

derived-constructor(arg-list) : base1 (arg- list),
                                           
                                                                        base2 (arg- list), 
                                                                         //…    
                                                                        baseN(arg-list)
{
// body of derived constructor
}

כאן המחלקה base1 עד baseN הם השמות של מחלקות הבסיס שעוברות בירושה .

שים לב! שנקודותים מפרידות בין הצהרת הבנאי של המחלקה הנגזרת לבין מחלקות הבסיס המפורטות,וכל מחלקת בסיס שמפורטת מופרדת ע"י פסיק.

דוגמה להעברת נתונים לבנאי של מחלקת הבסיס : 

#include <iostream.h>

class base  {
protected :         
       int i ;
public:
       base (int x ) {i = x ; cout << "constructing  base  \n";  }
       ~base ( ) { cout << "destructing base \n " ; }
};

class derived : public base  {
       int  j ;
       public:
//derived uses x ; y is passed along to base.
       derived (int x , int y ) :base ( y )         
         { j=x ; cout <, "constructing derived  \n " ; }
       ~derived ( ) { cout << "destructing derived \n " ; }
       void show ( ) { cout << i <<  " " << j <<  " \n ";  }
};

int  main ( ) 
 {
       derived ob ( 3 , 4 ) ;
       ob.show ( ) ;//displays 4 3
        return 0 ;
}

כאן הבנאי של המחלקה הנגזרת הצהירה על לקיחת שני פרמטרים ,x ו y ,בכל מקרה הנגזרת משתמשת רק בx ; y מועבר למחלקת הבסיס .באופן כללי הבנאי של הנגזרת חייב להצהיר על שני הפרמטרים הנדרשים גם במחלקת הבסיס .דוגמה אשר תמחיש איזה פרמטרים נדרשים ע"י מחלקת הבסיס אשר מועברים לרשימה הספציפית לארגומנט של מחלקת הבסיס לאחר הנקודתיים , לדוגמה: 


#include <iostream.h>
class base1  {
protected :        
       int i ;
public:
       base1 (int x ) {i = x ; cout << "constructing  base1  \n";  }
       ~base1 ( ) { cout << "destructing base1 \n " ; }
};

class base2  {
protected :      
       int k;
public:
       base2 (int x ) {k = x ; cout << "constructing  base2  \n";  }
       ~base2 ( ) { cout << "destructing base2 \n " ; }
};

class derived : public base1, public base2  {
       int  j ;
       public:
       derived (int x , int y , int z ) :base1 ( y ) , base2 ( z )       
         { j=x ; cout <, "constructing derived  \n " ; }
       ~derived ( ) { cout << "destructing derived \n " ; }
       void show ( ) { cout << i <<  "  " << j <<  "  " << k <<  " \n ";  }
};

int  main ( ) 
 {
       derived ob ( 3 , 4  , 5) ;
       ob.show ( ) ; //displays  3 4 5
        return 0 ;
}

חשוב להבין כי הארגומנטים לבנאי של מחלקת הבסיס מועברים דרך ארגומנטים לבנאי של המחלקה הנגזרת.למרות שהבנאי של המחלקה הנגזרת לא ישתמש באף אחד מהארגומנטים ,הוא עדין יהיה חייב להצהיר על אחד אם מחלקת הבסיס תצטרך.

במקרה הבא ,הארגומנטים שיעברו למחלקה הנגזרת יעברו יחד לחלקת בסיס.בדוגמה הבאה הבנאי של המחלקה הנגזרת לא תיקח ארגומנטים ,אבל( )base1 ו ( )base2 כן יקחו . 

  
                  
#include <iostream.h>
#include 

class base1  {
protected :          
       int i ;
public:
       base1 (int x ) {i = x ; cout << "constructing  base1  \n";  }
       ~base1 ( ) { cout << "destructing base1 \n " ; }
};

class base2  {
protected :         
       int k;
public:
       base2 (int x ) {k = x ; cout << "constructing  base2  \n";  }
       ~base2 ( ) { cout << "destructing base 2 \n " ; }
};

class derived : public base1, public base2  { 
       public:
//derived constructor uses no parameter ,but still must be  declared
//as taking them to pass them along to base classes.
       derived (int x , int y  ) :base1 ( x ) , base2 ( y )
         {  cout << "constructing derived  \n " ; }
       ~derived ( ) { cout << "destructing derived \n " ; }
       void show ( ) { cout << i <<   "  " << k <<  " \n ";  }
};

int  main ( ) 
 {
       derived ob ( 3 , 4 ) ;
       ob.show ( ) ; //displays  3 4 
        return 0 ;
}

הבנאי של המחלקה הנגזרת חופשי לעשות שימוש בכל הפרמטרים אשר מוצהרים כלקוחים ,אפילו אם אחד או יותר מועברים למחלקת בסיס. להעביר ארגומנט למחלקת בסיס לא להוציא מהכלל את השימוש של המחלקה הנגזרת . לדוגמה הקטע הבא תקף: 

class derived : public base  {
       int j ;
public:
//derived uses both x and y and them to base .
       derived (int x , int y ) : base ( x , y )  
           { j = x * y ;  cout  <<  " constructing derived  \n " ; }

נקודה אחרונה שצריך להשאיר במחשבה ,מתי שמעבירים ארגומנטים לבנאי של מחלקת בסיס:הארגומנט יכול להיות מורכב מאיזה שהוא ביטוי תקף באותו זמן.זה כולל קריאה לפונקציות ומשתנים.זה נשמר אם העובדה ש++c מאפשרת אתחול דינמי.

הקודם
הבא