In dit artikel gaan we het overervingsconcept in C++-programmering bespreken. We zullen het concept van de vriendfunctie in C++ uitleggen met werkende voorbeelden.
Waarom erfenis?
Overerving maakt het mogelijk om een nieuwe klasse of afgeleide klasse van een andere klasse of basisklasse te maken. De afgeleide klasse of de onderliggende klasse heeft alle kenmerken van de bovenliggende klasse of basisklasse. Met behulp van overerving kunnen we de code hergebruiken.
Soort erfenis
Er zijn verschillende soorten overerving:
- Eenvoudige/enkele overerving
- Hiërarchische erfenis
- Overerving op meerdere niveaus
- Meerdere overerving
In dit artikel gaan we alleen eenvoudige/enkele overerving beschouwen.
Voorbeeld 1:
Laten we nu een voorbeeldprogramma bekijken om het concept van overerving in C++ te begrijpen. We hebben een basisklasse gedefinieerd en er vervolgens een andere klasse van afgeleid. Daarom heeft de afgeleide klasse de kenmerken (leden en functies) van de basisklasse.
#erbij betrekkennamespace std; gebruiken;
klasse Basis_Klasse
{
openbaar:
intl;
leegteScherm()
{
kosten<< 'Weergave van basisklasse' <<l<<eindel;
}
};
klasse Afgeleide_Klasse:openbare Base_Class
{
openbaar:
leegtelaten zien()
{
kosten<< 'Toon van afgeleide klasse' <<eindel;
}
};
inthoofd()
{
Derived_Class dc;
gelijkstrooml = 100;
gelijkstroomScherm();
gelijkstroomlaten zien();
opbrengst 0;
}
Voorbeeld 2:
Dit is een ander voorbeeld van overerving in C++. In dit voorbeeld gaan we zien hoe de constructors worden aangeroepen wanneer een afgeleid klasseobject wordt gemaakt.
Zoals je hieronder kunt zien, hebben we twee constructors van basisklassen en drie afgeleide constructors van klassen gedefinieerd. U kunt aan de onderstaande uitvoer duidelijk zien dat de constructor van de basisklasse eerst wordt aangeroepen voordat de afgeleide klassenconstructor wordt aangeroepen.
#erbij betrekkennamespace std; gebruiken;
klasse Basis_Klasse
{
openbaar:
Basis_Klasse()
{
kosten<< 'Base_Class - Geen parameters' <<eindel;
}
Basis_Klasse(intx)
{
kosten<< 'Base_Class - Parameters : ' <<x<<eindel;
}
};
klasse Afgeleide_Klasse:openbare Base_Class
{
openbaar:
Afgeleide_Klasse()
{
kosten<< 'Derived_Class - Geen parameters' <<eindel;
}
Afgeleide_Klasse(inten)
{
kosten<< 'Derived_Class - Parameters : ' <<en<<eindel;
}
Afgeleide_Klasse(intx,inten):Basis_Klasse(x)
{
kosten<< 'Param van Derived_Class : ' <<en<<eindel;
}
};
inthoofd()
{
Derived_Class d(7,19);
}
Voorbeeld 3:
In dit voorbeeld gaan we zien hoe afgeleide klasseobjecten kunnen worden gebruikt.
Zoals u kunt zien, zijn er twee klassen gedefinieerd: Rectangle_Class en Cube_Class. De Rectangle_Class is de basisklasse waarvan de afgeleide klasse, d.w.z. Cube_Class, is afgeleid. Daarom erven we de functies van de Rectangle_Class naar Cube_Class.
U kunt ook opmerken dat we de Cube_Class erven met de openbare toegangscontrole. Dit betekent dat de afgeleide klasse toegang heeft tot alle niet-private leden van de basisklasse.
We hebben een object van de afgeleide klasse gedeclareerd en vervolgens de methoden van de basisklasse aangeroepen, d.w.z. setLength() en setBreadth().
#erbij betrekkennamespace std; gebruiken;
class Rectangle_Class
{
privaat:
intlengte;
intbreedte;
openbaar:
Rectangle_Class();
Rectangle_Class(intde,intB);
Rectangle_Class(Rectangle_Class&R);
intgetLength()
{
opbrengstlengte;
}
inthaalBreedte()
{
opbrengstbreedte;
}
leegtesetLengte(intde);
leegtesetBreedte(intB);
intOppervlakte();
};
klasse Kubus_Klasse:openbare Rectangle_Class
{
privaat:
inthoogte;
openbaar:
Cube_Class(intH)
{
hoogte=H;
}
intgetHeight()
{
opbrengsthoogte;
}
leegtesetHoogte(intH)
{
hoogte=H;
}
intvolume()
{
opbrengstgetLength()*haalBreedte()*hoogte;
}
};
Rectangle_Class::Rectangle_Class()
{
lengte=1;
breedte=1;
}
Rectangle_Class::Rectangle_Class(intde,intB)
{
lengte=de;
breedte=B;
}
Rectangle_Class::Rectangle_Class(Rectangle_Class&R)
{
lengte=R.lengte;
breedte=R.breedte;
}
leegteRectangle_Class::setLengte(intde)
{
lengte=de;
}
leegteRectangle_Class::setBreedte(intB)
{
breedte=B;
}
intRectangle_Class::Oppervlakte()
{
opbrengstlengte*breedte;
}
inthoofd()
{
Cube_Class c(8);
C.setLengte(12);
C.setBreedte(9);
kosten<<'Volume is'<<C.volume()<<eindel;
}
Conclusie:
In dit artikel heb ik het concept van overerving uitgelegd in C ++ . De C++ ondersteunt verschillende soorten overerving, waaronder meervoudige overerving (d.w.z. het erven van functies van meerdere basisklassen of bovenliggende klassen). Om het echter eenvoudiger te maken, heb ik hier alleen een enkele overerving overwogen. Ik heb drie werkvoorbeelden laten zien om uit te leggen hoe we overerving in C++-programmering kunnen gebruiken en de code opnieuw kunnen gebruiken. Bovendien is dit een zeer handige functie van C++.