Funktionsöverbelastning i C ++: Allt du behöver veta

C ++ är ett av de programmeringsspråk som är mycket flexibelt och det täcker också flera funktioner i objektorienterad programmering. Överbelastning är en annan funktion i detta programmeringsspråk.Följande pekare kommer att behandlas i denna artikel 'Funktionsöverbelastning i C ++' -

• C ++ överbelastning
• Typer av överbelastning i C ++
• Vad är funktionsöverbelastning i C ++
  • Genom att ändra antalet argument
  • Genom att ha olika typer av argument
• Fördelar med överbelastning av funktioner i C ++
• Nackdelar med funktionsöverbelastning i C ++
• Funktionsöverbelastning och tvetydighet

C ++ överbelastning

När vi skapar två eller flera medlemmar i en klass med samma namn men olika i antal eller typ av parametrar, är det känt som C ++ överbelastning. I C ++ kan vi överbelasta:

• metoder,
• konstruktörer och
• indexerade egenskaper

Typer av överbelastning i C ++

Vad är funktionsöverbelastning i C ++?

Funktionsöverbelastning i C ++ kan definieras som processen att ha två eller flera medlemsfunktioner i en klass med samma namn, men olika i parametrar. Vid funktionsöverbelastning kan funktionen omdefinieras antingen genom att använda olika typer av argument eller ett annat antal argument enligt kravet. Det är bara genom dessa skillnader som kompilatorn kan skilja mellan de två överbelastade funktionerna.

En av de största fördelarna med funktionsöverbelastning är att det ökar läsbarheten i programmet eftersom vi inte behöver använda olika namn för samma åtgärd om och om igen.

Genom att ändra antalet argument

På detta sätt för funktionsöverbelastning definierar vi två funktioner med samma namn men ett annat antal parametrar av samma typ. Till exempel i det nedan nämnda programmet har vi gjort två add () -funktioner för att returnera summan av två och tre heltal.

// första funktionsdefinition int add (int a, int b) {cout<< a+b } // second overloaded function definition int add(int a, int b, int c) { cout << a+b+c }

Här sägs add () -funktionen vara överbelastad, eftersom den har två definitioner, en som accepterar två argument och en annan som accepterar tre argument. Vilken add () -funktion som ska kallas beror på antalet argument.

int main () {add (10, 20) // add () with 2 parameter will be add (10, 20, 30) // sum () with 3 parameter will be called}

#include using namespace std int add (int a, int b) {cout<< a+b <
I exemplet ovan överbelastar vi funktionen add () genom att ändra antalet argument. Först definierar vi en add () -funktion med två parametrar, sedan överbelastar vi den igen genom att definiera add () -funktionen men den här gången med tre parametrar.
 Genom att ha olika typer av argument 
I den här metoden definierar vi två eller flera funktioner med samma namn och samma antal parametrar, men datatypen som används för dessa parametrar är olika. Till exempel i det här programmet har vi tre add () -funktioner, den första får två helargument, den andra får två floatargument och den tredje får två dubbla argument.
#include using namespace std int add (int x, int y) // first definition {cout<< x+y << endl return 0 } float add(float a, float b) { cout << a+b << endl return 0 } double add(double x, double y) { cout << x+y << endl return 0 } int main() { add(20, 40) add(23.45f, 34.5f) add(40.24, 20.433) }
vad är ide i java
I exemplet ovan definierar vi funktionen add () tre gånger. Först använder vi heltal som parametrar, andra använder float som parametrar och tredje använder dubbelt som parameter. 
Således åsidosätter vi funktionen add () två gånger.
 Fördelar med funktion Överbelastning i C ++ 
Vi använder funktionsöverbelastning för att spara minne, konsistens och läsbarhet i vårt program.
Med användningsfunktionen överbelastningskoncept kan vi utveckla mer än en funktion med samma namn
Funktionsöverbelastning visar beteendet hos polymorfism som gör att vi kan få olika beteende, även om det kommer att finnas någon länk med samma namn på funktionen.
Funktionsöverbelastning påskyndar genomförandet av programmet.
Funktionsöverbelastning används för återanvändning av kod och även för att spara minne.
Det hjälper applikationen att ladda klassmetoden baserat på typ av parameter.
Kodunderhåll är enkelt.
 Nackdelar med funktion Överbelastning i C ++ 
Funktionsdeklarationer som bara skiljer sig åt beroende på sin returtyp kan inte överbelastas med funktionsöverbelastningsprocessen.
Medlemsfunktionsdeklarationer med samma parametrar eller samma namntyper kan inte överbelastas om någon av dem deklareras som en statisk medlemsfunktion.
klass XYZ {static void func () void func () // error}
 Funktionsöverbelastning och tvetydighet 
När kompilatorn inte kan bestämma vilken funktion den ska åberopa först bland de överbelastade funktionerna, är denna situation känd som funktionsöverbelastnings tvetydighet. Kompilatorn kör inte programmet om det visar tvetydighetsfel. Orsaker till tvetydighet för överbelastning av funktioner:
Skriv konvertering.
Funktion med standardargument.
Funktion med ett pass by reference
 Typkonvertering: 
#include använder namnrymd std ogiltig funktion (float) ogiltig funktion (int) ogiltig funktion (float x) {std :: cout<< 'Value of x is : ' <
Ovanstående exempel ger ett fel - ”anrop av överbelastad” funktion (dubbel) ”är tvetydig”. Funktionen (3.4) anropar den första funktionen. Funktionen (34) anropar den andra funktionen enligt vår förutsägelse. Men det här är inte vad som händer för att i C ++ behandlas alla flytpunktskonstanterna som dubbla, inte som en flottör. Om vi ​​byter ut flytvariabeln till en dubbel variabel, fungerar programmet bra. Därför kallar vi detta ett typkonverteringsfel från float till double.
 Funktion med standardargument: 
#include using namespace std void function (int) void function (int, int) void function (int x) {std :: cout<< 'Value of x is : ' <
Ovanstående exempel ger ett fel som säger 'call of overloaded 'fun (int)' is ambiguous', detta beror på att funktion (int y, int z = 12) kan anropas på två sätt:
Genom att anropa funktionen med ett argument (och det tar automatiskt värdet z = 12)
Genom att anropa funktionen med två argument.
När vi kallar funktionen: funktion (12) fyller vi fullständigt villkoret för både funktion (int) och funktion (int, int) så att kompilatorn hamnar i en tvetydighet visar ett fel.
 Funktion med pass by reference 
#include använder namespace std void function (int) void function (int &) void function (int a) {std :: cout<< 'Value of a is : ' < 
Ovanstående program ger ett fel som säger 'call of overloaded 'fun (int &)' is ambiguous'. Som vi ser tar den första funktionen ett heltalargument och den andra funktionen tar en referensparameter som ett argument. I det här fallet kan kompilatorn inte förstå vilken funktion som behövs av användaren eftersom det inte finns någon syntaktisk skillnad mellan roligt (int) och roligt (int &) vilket gör att det blir ett tvetydighetsfel.
Med detta kommer vi till slutet av denna funktionsöverbelastning i C ++. Om du vill veta mer, kolla in   av Edureka, ett pålitligt inlärningsföretag online. Edurekas Java J2EE- och SOA-utbildning och certifieringskurs är utformad för att träna dig för både grundläggande och avancerade Java-koncept tillsammans med olika Java-ramverk som Hibernate & Spring.
 Har du en fråga till oss? Vänligen nämna det i kommentarsektionen på den här bloggen så kommer vi tillbaka till dig så snart som möjligt.