Vidare studerar vi skillnaden mellan överbelastning och tvingande med hjälp av ett jämförelseskart.
Jämförelsediagram:
| Grunder för jämförelse | överbelastning | tvingande |
|---|---|---|
| Prototyp | Prototypen skiljer sig åt eftersom antalet eller typen av parameter kan skilja sig åt. | Alla aspekter av prototypen måste vara samma. |
| Nyckelord | Inget sökord tillämpat under överbelastning. | Funktion som ska överskridas föregås av nyckelordet "virtuellt", i basklassen. |
| Skillnadsfaktor | Nummer eller typ av parameter skiljer sig åt vilket bestämmer vilken funktionsversion som kallas. | Vilken klassens funktion som kallas av pekaren bestäms av vilken adress som klassens objekt är tilldelat pekaren. |
| Definiera mönster | Funktionen omdefinieras med samma namn men olika antal och typ av parameter. | Funktionen definieras, föregås av ett nyckelord "virtuellt" i huvudklassen och omdefinieras av härledd klass med ut nyckelord. |
| Tiden för prestation | Kompilera tid. | Körtid. |
| Konstruktör / Virtuell funktion | Konstruktörer kan vara överbelastade. | Virtuell funktion kan överskridas. |
| destructor | Destructor kan inte överbelastas. | Destructor kan överskridas. |
| Bindning | Överbelastning uppnår tidig bindning. | Övergripande hänvisar till sen bindning. |
Definition av överbelastning
Kompileringstidspolymorfismen kallas överbelastning. Eftersom överbelastning genereras från ett begrepp polymorfism, tillhandahåller det "ett gemensamt gränssnitt för flera metoder". Det innebär att om en funktion är överbelastad innehåller den samma funktionsnamn medan det omdefinieras.
Överbelastade funktioner skiljer sig från olika "antal eller typ av parameter (er)", det gör en överbelastad funktion som skiljer sig från en annan. På så sätt känner kompilatorn igen vilken överbelastad funktion som kallas. De flesta överbelastade funktionerna är "konstruktörer". "Copy constructor" är en slags "konstruktör överbelastning".
Implementering av överbelastning i C ++
klassöverbelastning {int a, b; allmän: int belastning (int x) {// första belastning () funktion a = x; returnera a; } int belastning (int x, int y) {// andra belastning () funktion a = x; b = y; returnera a * b; }}; int main () {överbelastning O1; O1.load (20); // första laddningsfunktionen () funktionskall O1.load (20, 40); // andra laddningsfunktionen () funktion} Här är funktionslasten () för klassöverbelastning överbelastad. Klassens två överbelastade funktioner kan särskiljas på så sätt att funktionen första belastningen () accepterar endast ett heltalsparametern, medan den andra belastningen () -funktionen accepterar två heltalsparametrar. När objektet av klassens överbelastning kallar funktionen load () med en enda parameter, kallas första laddningsfunktionen (). När objektsamtal laddas () -funktionen passerar två parametrar, kallas funktionen andra belastning ().
Definition av övergripande
Polymorfism uppnådd under körtid kallas "övergripande". Det uppnås genom att använda "arv" och "virtuella funktioner". Funktion som ska överdras föregås av nyckelordet "virtuellt" i en basklass och omdefinieras i en härledd klass utan något sökord.
En av de viktigaste sakerna att komma ihåg i händelse av övergripande är att prototypen för den överrättade funktionen inte får förändras när den härledda klassen omdefinierar den. När överdriven funktion ges ett samtal, bestämmer C ++ vilken version av funktionen som kallas baserat på "typ av objektet pekat av en pekare", genom vilken funktionskallningen är klar.
Implementering av överstyrning i C ++
klassbas {public: virtual void funct () {// virtuell funktion av basklass cout << "Detta är en basklass funct ()"; }}; klass derived1: public base {public: void funct () {// virtuell funktion av basklass omdefinierad i derived1 class cout << "Detta är en derived1 class funct ()"; }}; klass derived2: public base {public: void funct () {// virtuell funktion av basklass omdefinierad i derived2 class cout funkt (); // kalla till derived1 class funct (). * P = & d2; p-> funkt (); // kalla till derived2 class funct (). returnera 0; } Här finns en enda basklass som är offentligt ärvd av två härledda klasser. En virtuell funktion definieras i en basklass med ett nyckelord "virtuellt", och det omdefinieras av både de härledda klasserna utan nyckelord. I huvud () skapar basklassen en pekervariabel 'p' och ett objekt 'b'; 'derived1'-klassen skapar ett objekt d1 och derived2-klassen skapar ett objekt d2'.
Nu tilldelas adressen till basklassens objekt 'b' till pekaren på basklassen 'p'. 'p' ringer till funktionsfunktionen (), så en funktion av basklassen kallas. Därefter tilldelas adress för derived1-klassobjektet 'd1' pekaren 'p', återigen ger den anrop till funct (); här exekveras funktionsfunktionen () av derived1-klassen. Slutligen tilldelas pekaren 'p' till derived2-klassens objekt. Då kallas "p" funktionsfunktion () som exekverar funktions func () av derived2-klassen.
Om derived1 / derived2-klassen inte omdefinierade funct (), skulle funct () av basklassen ha kallats, eftersom virtuell funktion är "hierarkisk".
Viktiga skillnader mellan överbelastning och överstyrning
- Prototypen av en funktion som överbelastas skiljer sig på grund av typ och antal parametrar som överförs till överbelastad funktion. Å andra sidan förändras prototypen för den överstyrda funktionen eftersom en överdriven funktion utför olika åtgärder för olika klasser den tillhör, men med samma typ och antal parametrar.
- Det överbelastade funktionsnamnet föregår inte med något sökord medan namnet på en överdriven funktion föregår endast nyckelordet "Virtual" i basklassen.
- Vilken överbelastad funktion som åberopas beror på typen eller antalet parametrar som överförs till funktionen. Den överstyrda funktionen av vilken klass som åberopas beror på vilken klassens objektadress som tilldelats pekaren, vilken påkallade funktionen.
- Vilken överbelastad funktion som ska åberopas löses under kompileringstiden. Vilken störd funktion som ska åberopas löses under körtiden.
- Konstruktörer kan vara överbelastade men kan inte överskridas.
- Destruktorer kan inte överbelastas, men de kan överskridas.
- Överbelastning uppnår tidig bindning som vilken överbelastad funktion som ska åberopas löses under kompileringstiden. Övergripande uppnår sen bindning som vilken överdriven funktion som kommer att åberopas är löst under körtiden.
Likheter
- Båda tillämpas på medlemmens funktioner i en klass.
- Polymorfismen är det grundläggande begreppet bakom dem båda.
- Funktionsnamnet förblir detsamma medan vi tillämpar överbelastning och övertygande funktionerna.
Slutsats
Överbelastning och överstyrning verkar likartad, men det är inte så. Funktioner kan överbelastas, men någon klass kan inte ytterligare omdefiniera den överbelastade funktionen i framtiden. En virtuell funktion kan inte överbelastas. de kan bara överrullas.
