Bij het overschrijven van functies herdefinieert de onderliggende klasse de functie die al is gedefinieerd in de bovenliggende klasse.
Het stelt de programmeur in staat om afgeleide klassespecifieke functionaliteit te bieden (ook al is dit gedefinieerd in de basisklasse).
Nu zullen we een paar voorbeelden zien en het functie-overschrijvende concept in C++ begrijpen.
Voorbeeld 1
Ik heb twee klassen gedefinieerd in de onderstaande voorbeeldcode: een basisklasse en een afgeleide klasse. De basisklasse heeft een lidfunctie, d.w.z. disp(). De Derived_Class is overgenomen van de Base_Class. De functie disp() is aanwezig in Base_Class en wordt vervolgens opnieuw gedefinieerd in de Derived_Class.
In de functie main() wordt een object van Derived_Class, d.w.z. d, gemaakt. Vervolgens roepen we de functie disp() aan op het afgeleide klasseobject, zodat de functie in de afgeleide klasse wordt aangeroepen. De basisklasseversie wordt hier genegeerd. Je kunt hieronder de uitvoer zien als - disp() functie in de afgeleide klasse.
#erbij betrekkennamespace std; gebruiken;
//basisklasse
klasse Basis_Klasse
{
openbaar:
leegtebaten()
{
kosten<< 'disp() functie in de basisklasse.' <<eindel;
}
};
// afgeleide klasse
klasse Afgeleide_Klasse:openbare Base_Class
{
openbaar:
leegtebaten()
{
kosten<< 'disp() functie in afgeleide klasse' <<eindel;
}
};
inthoofd()
{
Derived_Class d;
NS.baten(); //disp() functie op afgeleid klasseobject
opbrengst 0;
}
Voorbeeld-2
In dit voorbeeld zullen we zien hoe we opzettelijk de basisklasseversie van de functie kunnen aanroepen via het afgeleide klasseobject. In de afgeleide class-functiedefinitie gebruiken we de scope-resolutie-operator [::] om de basisklasseversie van de functie aan te roepen.
#erbij betrekkennamespace std; gebruiken;
klasse Basis_Klasse
{
openbaar:
leegtebaten()
{
kosten<< 'disp() functie in de basisklasse.' <<eindel;
}
};
klasse Afgeleide_Klasse:openbare Base_Class
{
openbaar:
leegtebaten()
{
Basis_Klasse::baten(); // Roep de basisklasse-versie van disp()
}
};
inthoofd()
{
Derived_Class d;
NS.baten();
opbrengst 0;
}
Voorbeeld-3
Dit is een ander voorbeeld van functieoverschrijving. In dit voorbeeld hebben we een bovenliggende klasse gemaakt - Dier en twee afgeleide klassen - Eend en Hond. De basisklasse, d.w.z. de klasse Animal, heeft een lidfunctie sound().
In de afgeleide klasse/kindklasse, d.w.z. Dog, hebben we dezelfde functie opnieuw gedefinieerd, d.w.z. sound(), om de definitie van de basisklasse te overschrijven. Evenzo hebben we in de andere afgeleide klasse, d.w.z. Duck, dezelfde functie opnieuw gedefinieerd, d.w.z. sound().
In de main()-functie hebben we het dog-object Dog en duck of Duck gemaakt. Dus als we nu de functie sound() voor hond en eend aanroepen, zal de afgeleide klasseversie van de functie sound() aanroepen. U kunt de uitvoer van het programma zien zoals hieronder weergegeven. Dus met behulp van de functie-overriding kunnen we de afgeleide klassespecifieke functie aanroepen.
#erbij betrekkennamespace std; gebruiken;
klasse dier
{
openbaar:
leegtegeluid()
{
kosten<< 'Dierengeluid!' <<eindel;
}
};
//Afgeleide klasse – Hondenklasse
klasse hond:openbaar dier
{
openbaar:
leegtegeluid()
{
kosten<< 'Hondengeluid - blaffen.' <<eindel;
}
};
//Afgeleide klasse - Eendklasse
klasse eend:openbaar dier
{
openbaar:
leegtegeluid()
{
kosten<< 'Eend geluid - kwak.' <<eindel;
}
};
inthoofd()
{
Hond hond;
Eend eend;
hond.geluid(); //geluid() van hond
eend.geluid(); //geluid() van eend
opbrengst 0;
}
Conclusie
In dit artikel heb ik het overschrijven van functies uitgelegd in C ++ . De C++-taal ondersteunt runtime-polymorfisme. Het overschrijven van functies helpt om het runtime-polymorfisme in C++ te bereiken. In dit artikel werd gekeken naar het concept van functieoverschrijving en hoe runtime-polymorfisme te bereiken met behulp van functieoverschrijving.