Inhoud

• 
  Vergelijkingstabel:
• Definitie van overbelasting
• Implementatie van overbelasting in C ++
• Definitie van opheffen
• Implementatie van opheffen in C ++
• overeenkomsten
• Gevolgtrekking

In ‘overbelasting‘We definiëren de overbelaste functies met dezelfde functienaam maar met een ander aantal en type parameters. In ‘dwingende‘Prototype van de onderdrukte functie is overal in het programma hetzelfde, maar de te overschrijven functie wordt voorafgegaan door het trefwoord‘ virtueel ’in de basisklasse en wordt opnieuw gedefinieerd door de afgeleide klasse zonder enig trefwoord.

Polymorfisme is een van de cruciale kenmerken van OOP. Het betekent gewoon 'één naam gebruiken voor meerdere formulieren'. Polymorfisme kan worden geïmplementeerd met behulp van ‘functie-overbelasting’, ‘operator-overbelasting’ en ‘virtuele functie’. Zowel 'overbelasting' als 'overheersend' impliceert het concept van polymorfisme. Hier is ‘overbelasting’ compileer tijd polymorfisme en ‘override’ is runtime polymorfisme. Verder studeren, als we het hebben over het grote verschil in ‘overbelasting’ en ‘overriding’.

Verder bestuderen we het verschil tussen overbelasting en opheffen met behulp van een vergelijkingstabel.

1. Vergelijkingstabel
2. Definitie
3. Belangrijkste verschillen
4. overeenkomsten
5. Gevolgtrekking

Vergelijkingstabel:

Basis voor vergelijking	overbelasting	overschrijven
Prototype	Prototype verschilt omdat aantal of type parameter kan verschillen.	Alle aspecten van het prototype moeten hetzelfde zijn.
keyword	Geen trefwoord toegepast tijdens overbelasting.	De functie die moet worden genegeerd, wordt voorafgegaan door virtueel trefwoord, in de basisklasse.
Onderscheidende factor	Aantal of type parameter verschilt wat bepaalt welke versie van de functie wordt aangeroepen.	Welke klassenfunctie door de aanwijzer wordt genoemd, wordt bepaald door het adres van welk klasseobject aan die aanwijzer wordt toegewezen.
Patroon definiëren	Functie wordt opnieuw gedefinieerd met dezelfde naam, maar een ander nummer en type parameter.	Functie wordt gedefinieerd, voorafgegaan door een virtueel trefwoord in hoofdklasse en opnieuw gedefinieerd door afgeleide klasse zonder trefwoord.
Tijd van voltooiing	Compileer tijd.	Run time.
Constructor / virtuele functie	Constructeurs kunnen overbelast raken.	Virtuele functie kan worden opgeheven.
destructor	Destructor kan niet worden overbelast.	Destructor kan worden opgeheven.
Verbindend	Overbelasting zorgt voor vroege binding.	Overschrijven verwijst naar late binding.

Definitie van overbelasting

Compile-time polymorfisme wordt ‘overbelasting’ genoemd. Omdat overbelasting wordt gegenereerd vanuit een concept van polymorfisme, biedt het "een gemeenschappelijke interface voor meerdere methoden". Dat betekent dat als een functie overbelast is, deze dezelfde functienaam bevat terwijl deze opnieuw wordt gedefinieerd.

Overbelaste functies verschillen met betrekking tot, ‘aantal of type parameter (s)’, het maakt de ene overbelaste functie onderscheidend van de andere. Op deze manier herkent de compiler welke overbelaste functie wordt aangeroepen. De meest overbelaste functies zijn ‘constructors’. ‘Copy constructor’ is een soort van "constructor overbelasting".

Implementatie van overbelasting in C ++

klasse overbelasting {int a, b; public: int load (int x) {// first load () functie a = x; retourneer een; } int load (int x, int y) {// second load () functie a = x; b = y; retourneer a * b; }}; int main () {overload O1; O1.load (20); // first load () functieaanroep O1.load (20,40); // tweede load () functie-oproep}

Hier is functie load () van klasse-overbelasting overbelast. De twee overbelaste functies van de klasse kunnen worden onderscheiden op een manier dat de eerste load () -functie alleen een enkele geheel-getal parameter accepteert, terwijl de tweede load () -functie twee geheel-getal parameter accepteert. Wanneer het object van de klasse-overbelasting de functie load () met een enkele parameter aanroept, wordt de functie first load () aangeroepen. Wanneer object de functie load () aanroept die twee parameters doorgeeft, wordt de tweede load () -functie aangeroepen.

Definitie van opheffen

Polymorfisme bereikt tijdens runtime wordt ‘overriding’ genoemd. Het wordt bereikt met behulp van ‘overerving’ en ‘virtuele functies’. De te overschrijven functie wordt voorafgegaan door het trefwoord ‘virtueel’ in een basisklasse en opnieuw gedefinieerd in een afgeleide klasse zonder enig trefwoord.

Een van de belangrijkste dingen om te onthouden in het geval van overschrijven is dat het prototype van de opgeheven functie niet mag veranderen, terwijl de afgeleide klasse het opnieuw definieert. Wanneer een onderdrukte functie een aanroep krijgt, bepaalt C ++ welke versie van de functie wordt aangeroepen op basis van het ‘type object aangeduid door een pointer’ waarmee de functie wordt opgeroepen.

Implementatie van opheffen in C ++

class base {public: virtual void funct () {// virtuele functie van base class cout << "Dit is een base classs funct ()"; }}; class afgeleid1: public base {public: void funct () {// virtuele functie van basisklasse opnieuw gedefinieerd in deriv1 class cout << "Dit is een deriv1 classs funct ()"; }}; class afgeleid2: public base {public: void funct () {// virtuele functie van basisklasse opnieuw gedefinieerd in deriv2 class cout << "Dit is een deriv2 classs funct ()"; }}; int main () {base * p, b; afgeleid1 d1; afgeleid2 d2; * P = & b; p> funct (); // aanroep naar base class funct (). * P = & d1; p> funct (); // aanroep van afgeleid1 klasse funct (). * P = & d2; p> funct (); // aanroep van afgeleid2 klasse funct (). terugkeer 0; }

Hier is er een enkele basisklasse die publiekelijk wordt geërfd door twee afgeleide klassen. Een virtuele functie wordt gedefinieerd in een basisklasse met een trefwoord 'virtueel' en wordt opnieuw gedefinieerd door beide afgeleide klassen zonder trefwoord. In main () maakt base class een pointer variabele ‘p’ en een object ‘b’; De klasse 'afgeleid1' ​​maakt een object d1 en de klasse afgeleid2 maakt een object d2 '.

Nu wordt het adres van het object ‘b’ van de basisklasse toegewezen aan de aanwijzer van de basisklasse ‘p’. ‘P’ roept de functie funct () aan, dus een functie van de basisklasse wordt aangeroepen.Vervolgens wordt het adres van afgeleid1 klasseobject ‘d1’ toegewezen aan pointer ‘p’, opnieuw roept het funct () op; hier wordt de functie funct () van de afgeleide klasse uitgevoerd. Tenslotte wordt aanwijzer ‘p’ toegewezen aan het object van afgeleide klasse. Vervolgens roept ‘p’ functie funct () aan die de functie funct () van de afgeleide klasse uitvoert.

Als afgeleide1 / afgeleide klasse funct () niet opnieuw had gedefinieerd, zou de funct () van base class zijn aangeroepen, omdat de virtuele functie ‘hiërarchisch’ is.

1. Het prototype van een functie die wordt overbelast verschilt vanwege het type en aantal parameters dat wordt doorgegeven aan de overbelaste functie. Aan de andere kant verandert het prototype van de onderdrukte functie niet omdat een onderdrukte functie een andere actie uitvoert voor een andere klasse waartoe het behoort, maar met hetzelfde type en aantal parameters.
2. De overbelaste functienaam gaat niet vooraf aan een sleutelwoord, terwijl de naam van een onderdrukte functie alleen voorafgaat aan de toets "Virtual" in de basisklasse.
3. Welke overbelaste functie wordt aangeroepen, is afhankelijk van het type of aantal parameters dat aan de functie wordt doorgegeven. De onderdrukte functie van welke klasse wordt aangeroepen, hangt af van, welk objectadres van de klasse is toegewezen aan de aanwijzer, die de functie heeft opgeroepen.
4. Welke overbelaste functie moet worden opgeroepen, wordt tijdens het compileren opgelost. Welke overschreven functie die moet worden opgeroepen, wordt tijdens runtime opgelost.
5. Constructeurs kunnen overbelast zijn, maar kunnen niet worden opgeheven.
6. Destructors kunnen niet worden overbelast, maar ze kunnen worden opgeheven.
7. Overbelasting bereikt vroege binding, waardoor de overbelaste functie wordt opgeroepen tijdens het compileren. Overschrijven bereikt late binding omdat de overschreven functie wordt opgeroepen tijdens runtime.

overeenkomsten

1. Beide worden toegepast op lidfuncties van een klasse.
2. Polymorfisme is het basisconcept achter beide.
3. Functienaam blijft hetzelfde terwijl we overbelasting en opheffing op de functies toepassen.

Gevolgtrekking

Overbelasting en opheffing lijken op elkaar, maar dit is niet het geval. Functies kunnen worden overbelast, maar elke klasse kan de overbelaste functie in de toekomst niet verder definiëren. Een virtuele functie kan niet worden overbelast; ze kunnen alleen worden opgeheven.