Functieoverbelasting in C ++: alles wat u moet weten

C ++ is een van die programmeertalen die erg flexibel is en het omvat ook verschillende functies van objectgeoriënteerd programmeren. Overbelasting is een ander kenmerk van deze programmeertaal.De volgende aanwijzingen komen aan bod in dit artikel 'Overbelasting van functies in C ++':

• C ++ Overbelasting
• Soorten overbelasting in C ++
• Wat is functie-overbelasting in C ++
  • Door het aantal argumenten te wijzigen
  • Door verschillende soorten argumenten te hebben
• Voordelen van functie-overbelasting in C ++
• Nadelen van functie-overbelasting in C ++
• Functie Overbelasting en ambiguïteit

C ++ Overbelasting

Wanneer we twee of meer leden van een klasse maken met dezelfde naam maar verschillend in aantal of type parameters, staat dit bekend als C ++ -overbelasting. In C ++ kunnen we overbelasten:

• methoden,
• constructeurs, en
• geïndexeerde eigenschappen

Soorten overbelasting in C ++

Wat is functie-overbelasting in C ++?

Functieoverbelasting in C ++ kan worden gedefinieerd als het proces waarbij twee of meer lidfuncties van een klasse dezelfde naam hebben, maar verschillen in parameters. Bij overbelasting van functies kan de functie opnieuw worden gedefinieerd door verschillende soorten argumenten te gebruiken of een ander aantal argumenten, afhankelijk van de vereiste. Alleen door deze verschillen kan de compiler een onderscheid maken tussen de twee overbelaste functies.

Een van de belangrijkste voordelen van functie-overbelasting is dat het de leesbaarheid van het programma vergroot, omdat we niet steeds weer verschillende namen hoeven te gebruiken voor dezelfde actie.

Door het aantal argumenten te wijzigen

Bij deze manier van functie-overbelasting definiëren we twee functies met dezelfde naam maar een verschillend aantal parameters van hetzelfde type. In het onderstaande programma hebben we bijvoorbeeld twee add () - functies gemaakt om de som van twee en drie gehele getallen te retourneren.

// eerste functie definitie 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 }

Hier wordt gezegd dat de functie add () overbelast is, omdat het twee definities heeft, een die twee argumenten accepteert en een andere die drie argumenten accepteert. Welke add () functie wordt aangeroepen, hangt af van het aantal argumenten.

int main () {add (10, 20) // add () met 2 parameter wordt genoemd add (10, 20, 30) // sum () met 3 parameter wordt genoemd}

#include met behulp van de naamruimte std int add (int a, int b) {cout<< a+b <
In het bovenstaande voorbeeld overbelasten we de functie add () door het aantal argumenten te wijzigen. Eerst definiëren we een add () -functie met twee parameters, en vervolgens overbelasten we deze door opnieuw de add () -functie te definiëren, maar deze keer met drie parameters.
 Door verschillende soorten argumenten te hebben 
Bij deze methode definiëren we twee of meer functies met dezelfde naam en hetzelfde aantal parameters, maar het gegevenstype dat voor deze parameters wordt gebruikt, is verschillend. In dit programma hebben we bijvoorbeeld drie add () -functies, de eerste krijgt twee integer-argumenten, de tweede krijgt twee float-argumenten en de derde krijgt twee dubbele argumenten.
hoe de trimmethode in java te gebruiken
#include met behulp van naamruimte std int add (int x, int y) // eerste definitie {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) }
In het bovenstaande voorbeeld definiëren we de functie add () drie keer. Ten eerste met gehele getallen als parameters, ten tweede met float als parameters en ten derde met double als parameter. 
Daarom overschrijven we de functie add () twee keer.
 Voordelen van functie Overbelasting in C ++ 
We gebruiken functie-overbelasting om geheugenruimte, consistentie en leesbaarheid van ons programma te besparen.
Met het gebruiksfunctie-overbelastingsconcept kunnen we meer dan één functie met dezelfde naam ontwikkelen
Functie-overbelasting toont het gedrag van polymorfisme dat ons in staat stelt ander gedrag te krijgen, hoewel er een link zal zijn die dezelfde naam van de functie gebruikt.
Overbelasting van functies versnelt de uitvoering van het programma.
Functie-overbelasting wordt gebruikt voor hergebruik van code en ook om geheugen te besparen.
Het helpt de applicatie om de klassemethode te laden op basis van het type parameter.
Codeonderhoud is eenvoudig.
 Nadelen van functie Overbelasting in C ++ 
Functieverklaringen die alleen verschillen door het retourtype, kunnen niet worden overbelast met het functie-overbelastingsproces.
Declaraties van ledenfuncties met dezelfde parameters of dezelfde naamtypen kunnen niet worden overbelast als een van deze wordt gedeclareerd als een statische lidfunctie.
klasse XYZ {static void func () void func () // error}
 Functie Overbelasting en ambiguïteit 
Wanneer de compiler niet kan beslissen welke functie hij het eerst moet aanroepen van de overbelaste functies, staat deze situatie bekend als ambiguïteit van functieoverbelasting. De compiler voert het programma niet uit als het een dubbelzinnigheidsfout vertoont. Oorzaken van ambiguïteit van functieoverbelasting:
Typ Conversie.
Functie met standaardargumenten.
Functie met een pass-by-referentie
 Type conversie: 
#inclusief het gebruik van de naamruimte std void-functie (float) void-functie (int) void-functie (float x) {std :: cout<< 'Value of x is : ' <
Het bovenstaande voorbeeld genereert een fout - 'aanroep van overbelaste‘ functie (dubbel) ’is dubbelzinnig”. De functie (3.4) zal de eerste functie aanroepen. De functie (34) roept de tweede functie aan volgens onze voorspelling. Maar dit is niet wat er gebeurt, want in C ++ worden alle drijvende-kommaconstanten behandeld als dubbel en niet als een float. Als we de variabele float vervangen door een dubbele variabele, werkt het programma prima. Daarom noemen we dit een typeconversie-fout van float naar double.
 Functie met standaardargumenten: 
#inclusief het gebruik van de naamruimte std void-functie (int) void-functie (int, int) void-functie (int x) {std :: cout<< 'Value of x is : ' <
Het bovenstaande voorbeeld geeft een foutmelding 'call of overloaded‘ fun (int) ’is ambiguous', dit komt omdat de functie (int y, int z = 12) op twee manieren kan worden aangeroepen:
Door de functie aan te roepen met één argument (en het zal automatisch de waarde van z = 12 aannemen)
Door de functie aan te roepen met twee argumenten.
Wanneer we de functie: functie (12) aanroepen, vullen we de voorwaarde van zowel functie (int) als functie (int, int) volledig in, dus de compiler raakt in een ambiguïteit en toont een fout.
 Functie met pass-by-referentie 
#inclusief het gebruik van de naamruimte std void-functie (int) void-functie (int &) void-functie (int a) {std :: cout<< 'Value of a is : ' < 
Het bovenstaande programma geeft een foutmelding 'call of overloaded‘ fun (int &) ’is ambiguous'. Zoals we zien, neemt de eerste functie één integer-argument en de tweede functie een referentieparameter als argument. In dit geval kan de compiler niet begrijpen welke functie de gebruiker nodig heeft, aangezien er geen syntactisch verschil is tussen de fun (int) en fun (int &), dus het maakt een fout van ambiguïteit.
Hiermee komen we aan het einde van deze functie-overbelasting in C ++. Als je meer wilt weten, bekijk dan de   door Edureka, een vertrouwd online leerbedrijf. Edureka's Java J2EE- en SOA-trainings- en certificeringscursus is ontworpen om u te trainen in zowel kern- als geavanceerde Java-concepten, samen met verschillende Java-frameworks zoals Hibernate & Spring.
 Heeft u een vraag voor ons? Vermeld het in het opmerkingengedeelte van deze blog en we nemen zo snel mogelijk contact met je op. 
hoe je python anaconda gebruikt