Innehåll

• 
  Jämförelsediagram:
• Definition av överbelastning
• Implementering av överbelastning i C ++
• Definition av överskridande
• Implementering av överskridande i C ++
• Likheter
• Slutsats

I 'överbelastning‘Vi omdefinierar de överbelastade funktionerna med samma funktionsnamn men, olika antal och parametertyp. I 'tvingande"Prototyp för åsidosatt funktion är densamma i hela programmet, men funktionen som ska åsidosättas föregås av nyckelordet" virtuell "i basklassen och omdefinieras av den härledda klassen utan något nyckelord.

Polymorfism är en av de avgörande funktionerna i OOP. Det betyder helt enkelt "att använda ett namn för flera former". Polymorfism kan implementeras med 'funktionsöverbelastning', 'operatörens överbelastning' och 'virtuell funktion'. Både "överbelastning" och "överskridande" innebär begreppet polymorfism. Här är "överbelastning" kompilering av tidspolymorfism och "överskridande" är körtidspolymorfism. Studera vidare om vi pratar om den stora skillnaden i "överbelastning" och "åsidosättande".

Vidare studerar vi skillnaden mellan överbelastning och överskridande med hjälp av ett jämförelsediagram.

1. Jämförelsediagram
2. Definition
3. Viktiga skillnader
4. Likheter
5. Slutsats

Jämförelsediagram:

Grund för jämförelse	överbelastning	tvingande
Prototyp	Prototypen skiljer sig eftersom antalet eller typen av parametrar kan skilja sig åt.	Alla aspekter av prototypen måste vara samma.
Nyckelord	Inget sökord användes under överbelastning.	Funktion som ska åsidosättas föregås av virtuella nyckelord i basklassen.
Utmärkande faktor	Antalet eller typen av parametrar skiljer sig som bestämmer vilken version av funktionen som kallas.	Vilken klassfunktion som kallas av pekaren, bestäms av, adress för vilken klassobjekt tilldelas den pekaren.
Definiera mönster	Funktionen omdefinieras med samma namn, men olika antal och parametertyp.	Funktion definieras, föregås av ett virtuellt nyckelord i huvudklassen och omdefinieras av härledd klass utan sökord.
Tid för genomförande	Samla tid.	Körtid.
Konstruktör / virtuell funktion	Konstruktörer kan överbelastas.	Virtuell funktion kan åsidosättas.
destructor	Destruktorn kan inte överbelastas.	Destruktorn kan åsidosättas.
Bindning	Överbelastning uppnår tidig bindning.	Överskridande avser sen bindning.

Definition av överbelastning

Polymorfism för kompileringstid kallas 'överbelastning.' Eftersom överbelastning genereras från ett begrepp polymorfism, ger det "ett gemensamt gränssnitt för flera metoder". Det betyder att om en funktion är överbelastad innehåller den samma funktionsnamn medan den omdefinieras.

Överbelastade funktioner skiljer sig åt, olika 'antal eller typ av parametrar', det gör att en överbelastad funktion skiljer sig från en annan. På detta sätt känner kompilatorn igen vilken överbelastad funktion som kallas. De vanligaste överbelastade funktionerna är 'konstruktörer'. "Copy constructor" är en typ av "konstruktör överbelastning".

Implementering av överbelastning i C ++

klassöverbelastning {int a, b; public: int load (int x) {// first load () -funktion a = x; return a; } int last (int x, int y) {// second load () funktion a = x; b = y; returnera a * b; }}; int main () {överbelastning O1; O1.load (20); // första belastning () -funktionssamtal O1.load (20,40); // second load () -funktionssamtal}

Här har funktionsbelastning () för klassöverbelastning överbelastats. Klassens två överbelastade funktioner kan skiljas på ett sätt som funktionen för första belastning () endast accepterar en enda heltalsparameter, medan den andra belastningsfunktionen () accepterar två heltalsparameter. När objektet för klassöverbelastningen kallar lasten () -funktionen med en enda parameter, kommer den första belastningsfunktionen () att ringa. När objektet anropar funktionen last () som passerar två parametrar, kommer den andra lasten () -funktionen att anropas.

Definition av överskridande

Polymorfism uppnådd under körning kallas "övervägande." Det åstadkoms genom att använda "arv" och "virtuella funktioner". Funktionen som ska åsidosättas föregås av nyckelordet "virtuell" i en basklass och omdefinieras i en härledd klass utan något nyckelord.

En av de viktigaste sakerna att komma ihåg i fall av åsidosättande är att prototypen för den åsidosatta funktionen inte får ändras medan härledd klass omdefinierar den. När den åsidosatta funktionen ges ett samtal bestämmer C ++ vilken version av funktionen som kallas baserat på den typen av objekt som är pekad av en pekare med vilken funktionssamtalet utförs.

Implementering av överskridande i C ++

klassbasen {public: virtual void funct () {// virtual reality of bas class cout << "Detta är en basklasserfunktion ()"; }}; klass härledd1: offentlig bas {public: void funct () {// virtuell funktion av basklassen omdefinierad i härledd1 klasscout << "Detta är en deriverad1 klasser funktion ()"; }}; klass härledd2: public base {public: void funct () {// virtuell funktion av basklassen omdefinierad i deriv2 class cout << "Detta är en deriv2 classs funktion ()"; }}; int main () {base * p, b; härledd1 d1; härledd2 d2; * P = & b; p-> funkt (); // samtal till basklassfunktion (). * P = & d1; p-> funkt (); // samtal till deriv1 klassfunktion (). * P = & d2; p-> funkt (); // samtal till deriv2 klassfunktion (). retur 0; }

Här finns en enda basklass som ärvs offentligt av två härledda klasser. En virtuell funktion definieras i en basklass med ett nyckelord "virtuell", och den definieras om av båda de härledda klasserna utan sökord. I huvudsak () skapar basklassen en pekvariabel "p" och ett objekt "b"; "Härledd1 ′ klass skapar ett objekt d1 och derivat2 klass skapar ett objekt d2".

Nu tilldelas initialt adressen till basklassens objekt "b" till pekaren för basklassen "p". ‘P’ ringer till funktionsfunktionen (), så en funktion av basklassen kallas.Sedan tilldelas adress för härledd klassobjekt "d1" till pekaren "p", återigen ger den uppmaning till funktion (); här exekveras funktionsfunktionen () för deriv1-klassen. Slutligen tilldelas pekaren 'p' till deriv2-klassens objekt. Sedan kallar ‘p’ funktionsfunktion () som exekverar funktionsfunktionen () för deriv2-klassen.

Om klassen härledd1 / härledd2 inte definierade funktionen (), skulle basklassens funktioner () ha kallats, eftersom virtuell funktion är "hierarkisk."

1. Prototypen för en funktion som överbelastas skiljer sig på grund av typen och antalet parametrar som överförs till den överbelastade funktionen. Å andra sidan förändras inte prototypen för den åsidosatta funktionen eftersom en åsidosatt funktion utför olika åtgärder för olika klasser den tillhör men med samma typ och antal parametrar.
2. Det överbelastade funktionsnamnet föregås inte med något nyckelord, medan namnet på en åsidosatt funktion föregås av nyckelordet "Virtuell" endast i basklassen.
3. Vilken överbelastad funktion som anropas beror på typen eller antalet parametrar som skickas till funktionen. Den åsidosatta funktionen för vilken klass som åberopas beror på vilken klassens objektadress tilldelas pekaren, som åberopade funktionen.
4. Vilken överbelastad funktion som ska påkallas löses under kompileringstiden. Vilken åsidosatt funktion som ska åberopas löses under körning.
5. Konstruktörer kan överbelastas men kan inte åsidosättas.
6. Destruktorer kan inte överbelastas, men de kan åsidosättas.
7. Överbelastning uppnår tidig bindning eftersom vilken överbelastad funktion kommer att påkallas löses under kompileringstiden. Överskridande uppnår sen bindning eftersom den som åsidosätts funktionen kommer att löses under körning.

Likheter

1. Båda tillämpas på medlemsfunktioner i en klass.
2. Polymorfism är det grundläggande konceptet bakom båda.
3. Funktionsnamnet förblir detsamma medan vi tillämpar överbelastning och åsidosätter funktionerna.

Slutsats

Överbelastning och åsidosättning verkar liknande, men detta är inte fallet. Funktioner kan överbelastas, men vilken klass som helst kan inte omdefiniera den överbelastade funktionen i framtiden. En virtuell funktion kan inte överbelastas; de kan bara åsidosättas.