Inleiding tot overbelasting en opheffen in C ++
Laten we beginnen met de basisdefinities voor overbelasting en overschrijven in C ++.
Overbelasting : de functienaam is hetzelfde, maar de parameters en het type retour veranderen. Omdat we het verschil tussen de overbelaste functies tijdens het compileren zullen leren kennen, wordt het ook Compile time polymorphism genoemd.
Overschrijven: dit is een functie van de objectgerichte programmeertaal waarbij de functie van de onderliggende klasse dezelfde naam heeft als de klassenfunctie van de bovenliggende klasse. Omdat de dwingende functionaliteit in beeld komt zodra het object is gedeclareerd en de functies toegankelijk zijn met behulp van de objecten; dat wil zeggen tijdens de uitvoering van code, wordt dit concept van opheffing ook wel run time polymorphism genoemd.
We hebben hun syntaxis en hun programmeerwijzen in de latere secties.
Syntaxis van overbelasting en opheffing
Hier is de syntaxis van de overbelasting en opheffing hieronder.
Syntaxis voor overbelasting:
return_type function_name ( int param_1, string param_2)
(
//function definition
)
return_type_2 function_name ( int param_1, string param_2)
(
//function definition
)
return_type function_name ( int param_1, int param_2)
(
//function definition
)
Ze kunnen alle drie samen een voorbeeld vormen van het concept van overbelasting.
Overheersende syntaxis:
Class A
(
Public:
void function_name ( int param_1, int param_2)
(
//function definition
)
);Class B : Class A
(
Public:
void function_name ( int param_1, int param_2)
(
//function definition
)
);
Het bovenstaande is de syntaxis voor de dwingende functionaliteit. De belangrijkste output kan worden afgeleid zodra we een object declareren en dezelfde methoden uit Klasse A en Klasse B aanroepen. In de functionaliteit van het opheffen van het "Object" speelt een belangrijke rol.
Laten we nu elk een voorbeeld bekijken om hun functionaliteit beter te leren kennen.
Voorbeelden van overbelasting en opheffing in C ++
Hier zijn de voorbeelden van overbelasting en overschrijven in C ++ met de onderstaande output:
Voorbeeld # 1 - Overbelasting
Laten we beginnen met een eenvoudig programma.
Code:
#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)
Output:
Wat nu als ik een verkeerd gegevenstypewaarde geef voor de variabelen a, b?
Code:
int main()
(
int a = 10.8;
float b = 12;
calc(a);
calc(b);
calc(a, b);
)
Ik heb alleen het hoofdgedeelte van het bovenstaande programma gewijzigd, dus hier komt de uitvoer.
output:
Het geeft ons de uitvoer aangezien het de floatwaarde naar het gegevenstype int zal omzetten en geeft ons de uitvoer.
Als oefening kunt u nu proberen het functie-retourtype en de parameters te wijzigen en ermee spelen.
Voorbeeld # 2 - Negeren
Hieronder kunnen we een voorbeeld geven voor een dwingende functionaliteit in C ++.
Code:
#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)
Output:
Via de bovenstaande code kunnen we vinden dat wanneer de referentie van het eersteklas object wordt toegewezen aan het object dat is gemaakt met betrekking tot onze tweede klasse. En toen we toegang kregen tot de overridemethode met behulp van het object van de basisklasse, kunnen we duidelijk zien dat de afgeleide klasse-uitvoer is weergegeven. Dit concept wordt dwingend genoemd. De eerste en tweede klasse zijn respectievelijk de basisklasse en de afgeleide klasse. De output van het bovenstaande is hieronder:
Als oefening kunt u proberen een functie samen te vervangen en te overbelasten en controleren of het mogelijk is of controleren hoe de uitvoer blijkt te zijn?
Hoe werkt het?
Overbelasting: hier is er geen speciaal punt dat we kunnen noteren. We moeten ervoor zorgen dat het retourtype of de parameters binnen de functie variëren. Als we hierboven naar de programmeerstructuur kijken, worden de functies eerst gedeclareerd en hun implementatie gegeven.
Doorslaggevend: de syntaxis van overerving en implementatie van functies zijn de belangrijkste punten die hier moeten worden opgemerkt. In het bovenstaande voorbeeld kunnen we opmerken dat de functieverklaring met publiek sleutelwoord heel anders is.
En in C ++ wordt de klassedefinitie beëindigd door een puntkomma (;) en als we de basisklasse moeten erven aan de onderliggende klasse, gebruiken we het dubbele punt (:) symbool. De belangrijkste functionaliteit van negeren wordt waargenomen wanneer objecten worden gedeclareerd en geïnitialiseerd voor de klasse. Na het aanroepen van functies met behulp van de objecten, kunnen we het begrip overschrijven duidelijk begrijpen.
voordelen
- Het enige grote voordeel van deze opheffing en overbelasting is tijdwinst.
- Bespaar geheugenruimte.
- De leesbaarheid van de code is verbeterd.
- Hier kunnen we voor het functie-overbelastingsconcept verschillende dezelfde functienamen gebruiken voor verschillende bewerkingen, waardoor het gebruik van verschillende functienamen wordt geëlimineerd.
- Flexibiliteit en onderhoudbaarheid van code worden eenvoudiger.
- In het geval van overschrijven kan de kindklasse functies van de ouderklasse hebben en zelfs een eigen implementatie van die functie hebben.
- Er kan naar de objecten worden verwezen en de functies van zowel de bovenliggende klasse als de onderliggende klasse kunnen worden geopend door de onderliggende klasse.
Conclusie
We hebben de concepten van zowel overbelasting als overbrugging nu duidelijk begrepen. Bij overbelasting moeten we ervoor zorgen dat het verschil in de overbelaste functies bestaat op basis van het retourtype of de parameters, hoewel de functiedefinitie daarin hetzelfde of anders is.
En in het geval van overschrijven, omdat het een objectgeoriënteerd programmeerconcept is, kunnen we alleen gebruiken in de vorm van klassen die de functionaliteit van overerving gebruiken.
Aanbevolen artikelen
Dit is een gids voor overbelasting en overschrijven in C ++. Hier bespreken we de introductie, hoe werkt het, syntaxis, voorbeelden en voordelen van overbelasting en overschrijven in C ++ met code-implementatie. U kunt ook de volgende artikelen bekijken voor meer informatie -
- Overbelasting in C ++
- Overbelasting versus opheffen
- Overschrijven in PHP
- Overschrijven in C ++
- Overschrijven in Java
- Polymorfisme op Java
- Top 11 kenmerken en voordelen van C ++
- Overschrijven in Python | Functie en regels