În acest articol, vom discuta conceptul de moștenire în programarea C ++. Vom explica conceptul funcției prieten în C ++ cu exemple de lucru.
De ce Moștenire?
Moștenirea permite crearea unei clase noi sau a unei clase derivate dintr-o altă clasă sau clasă de bază. Clasa derivată sau clasa copil va avea toate caracteristicile clasei părinte sau a clasei de bază. Putem reutiliza codul cu ajutorul moștenirii.
Tipul moștenirii
Există diferite tipuri de moștenire:
- Moștenire simplă / simplă
- Moștenirea ierarhică
- Moștenirea pe mai multe niveluri
- Moștenirea multiplă
În acest articol, vom lua în considerare doar moștenirea simplă / simplă.
Exemplul 1:
Acum, să analizăm un exemplu de program pentru a înțelege conceptul de moștenire în C ++. Am definit o clasă de bază și apoi am derivat o altă clasă din aceasta. Prin urmare, clasa derivată va avea caracteristicile (membrii și funcțiile) din clasa de bază.
#includefolosind spațiul de nume std;
clasa Base_Class
{
public:
inteu;
nulafişa()
{
cost<< „Afișarea clasei de bază” <<eu<<endl;
}
};
clasa Derived_Class:public_Base_Class
{
public:
nulspectacol()
{
cost<< „Spectacolul clasei derivate” <<endl;
}
};
intprincipal()
{
Derived_Class dc;
DC.eu = 100;
DC.afişa();
DC.spectacol();
întoarcere 0;
}
Exemplul 2:
Acesta este un alt exemplu de moștenire în C ++. În acest exemplu, vom vedea cum sunt numiți constructorii atunci când este creat un obiect de clasă derivat.
După cum puteți vedea mai jos, am definit doi constructori de clase de bază și trei constructori de clase derivate. Puteți observa clar din rezultatul de mai jos că constructorul clasei de bază este apelat mai întâi înainte de a fi chemat constructorul clasei derivate.
#includefolosind spațiul de nume std;
clasa Base_Class
{
public:
Clasa_bază()
{
cost<< „Base_Class - Fără parametri” <<endl;
}
Clasa_bază(intX)
{
cost<< 'Base_Class - Parametri:' <<X<<endl;
}
};
clasa Derived_Class:public_Base_Class
{
public:
Derivat_Clasă()
{
cost<< „Derived_Class - Fără parametri” <<endl;
}
Derivat_Clasă(intși)
{
cost<< 'Derived_Class - Parametri:' <<și<<endl;
}
Derivat_Clasă(intX,intși):Clasa_bază(X)
{
cost<< 'Param of Derived_Class:' <<și<<endl;
}
};
intprincipal()
{
Derivat_Clasă d(7,19);
}
Exemplul 3:
În acest exemplu, vom vedea cum pot fi utilizate obiecte de clasă derivate.
După cum puteți vedea, există două clase definite: Rectangle_Class și Cube_Class. Rectangle_Class este clasa de bază din care derivă clasa derivată, adică Cube_Class. Prin urmare, moștenim caracteristicile de la Rectangle_Class la Cube_Class.
De asemenea, puteți observa că moștenim Cube_Class cu controlul accesului public. Aceasta înseamnă că clasa derivată poate accesa toți membrii non-privați ai clasei de bază.
Am declarat un obiect al clasei derivate și apoi apelăm metodele din clasa de bază, adică setLength () și setBreadth ().
#includefolosind spațiul de nume std;
clasa Rectangle_Class
{
privat:
intlungime;
intlăţime;
public:
Rectangle_Class();
Rectangle_Class(intthe,intb);
Rectangle_Class(Rectangle_Class&r);
intgetLength()
{
întoarcerelungime;
}
intgetBreadth()
{
întoarcerelăţime;
}
nulsetLength(intthe);
nulsetBreadth(intb);
intzonă();
};
clasa Cube_Class:public Rectangle_Class
{
privat:
intînălţime;
public:
Cube_Class(inth)
{
înălţime=h;
}
intgetHeight()
{
întoarcereînălţime;
}
nulsetHeight(inth)
{
înălţime=h;
}
intvolum()
{
întoarceregetLength()*getBreadth()*înălţime;
}
};
Rectangle_Class::Rectangle_Class()
{
lungime=1;
lăţime=1;
}
Rectangle_Class::Rectangle_Class(intthe,intb)
{
lungime=the;
lăţime=b;
}
Rectangle_Class::Rectangle_Class(Rectangle_Class&r)
{
lungime=r.lungime;
lăţime=r.lăţime;
}
nulRectangle_Class::setLength(intthe)
{
lungime=the;
}
nulRectangle_Class::setBreadth(intb)
{
lăţime=b;
}
intRectangle_Class::zonă()
{
întoarcerelungime*lăţime;
}
intprincipal()
{
Cube_Class c(8);
c.setLength(12);
c.setBreadth(9);
cost<<„Volumul este”<<c.volum()<<endl;
}
Concluzie:
În acest articol, am explicat conceptul de moștenire în C ++ . C ++ acceptă diferite tipuri de moștenire, inclusiv moștenirea multiplă (adică moștenirea caracteristicilor din mai multe clase de bază sau clase părinte). Cu toate acestea, pentru ao simplifica, am luat în considerare aici doar o moștenire. Am arătat trei exemple de lucru pentru a explica cum putem folosi moștenirea în programarea C ++ și să reutilizăm codul. Mai mult, aceasta este o caracteristică foarte utilă a C ++.