Funktionsoverbelastning i C ++: Alt hvad du behøver at vide

Denne artikel vil give dig en detaljeret og omfattende viden om Function Overloading i C ++ med masser af eksempler at forstå.

C ++ er et af de programmeringssprog, der er meget fleksibelt, og det dækker også flere funktioner i objektorienteret programmering. Overbelastning er et andet træk ved dette programmeringssprog.Følgende markører vil blive dækket i denne artikel 'Funktionsoverbelastning i C ++' -



C ++ Overbelastning

Når vi opretter to eller flere medlemmer af en klasse med samme navn, men forskellige i antal eller type parametre, er det kendt som C ++ overbelastning. I C ++ kan vi overbelaste:

  • metoder,
  • konstruktører og
  • indekserede egenskaber

Typer af overbelastning i C ++

types-of-overloading-in-c++

Hvad er funktionsoverbelastning i C ++?

Funktionsoverbelastning i C ++ kan defineres som processen med at have to eller flere medlemsfunktioner i en klasse med samme navn, men forskellige i parametre. I funktionsoverbelastning kan funktionen omdefineres enten ved at bruge forskellige typer argumenter eller et andet antal argumenter i henhold til kravet. Det er kun gennem disse forskelle, at kompilatoren kan skelne mellem de to overbelastede funktioner.



En af de største fordele ved funktionsoverbelastning er, at det øger læsbarheden af ​​programmet, fordi vi ikke behøver at bruge forskellige navne til den samme handling igen og igen.

Ved at ændre antallet af argumenter

På denne måde til funktionsoverbelastning definerer vi to funktioner med de samme navne, men et forskelligt antal parametre af samme type. For eksempel har vi i nedenstående program lavet to tilføj () -funktioner for at returnere summen af ​​to og tre heltal.

// første funktionsdefinition int tilføj (int a, int b) {cout<< a+b } // second overloaded function definition int add(int a, int b, int c) { cout << a+b+c }

Her siges tilføjelsesfunktionen () at være overbelastet, da den har to definitioner, en der accepterer to argumenter og en anden som accepterer tre argumenter. Hvilken tilføjelsesfunktion () der kaldes, afhænger af antallet af argumenter.



int main () {add (10, 20) // add () med 2 parameter kaldes add (10, 20, 30) // sum () med 3 parameter kaldes}
#include ved hjælp af namespace std int add (int a, int b) {cout<< a+b <

I ovenstående eksempel overbelaster vi tilføjelsesfunktionen () ved at ændre antallet af argumenter. Først definerer vi en add () -funktion med to parametre, derefter overbelaster vi den ved igen at definere add () -funktionen, men denne gang med tre parametre.

Ved at have forskellige typer argumenter

I denne metode definerer vi to eller flere funktioner med samme navn og samme antal parametre, men datatypen, der bruges til disse parametre, er forskellig. For eksempel har vi i dette program tre tilføj () -funktioner, den første får to heltalargumenter, den anden får to floatargumenter, og den tredje får to dobbeltargumenter.

#include ved hjælp af namespace std int add (int x, int y) // første 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) }

I ovenstående eksempel definerer vi add () -funktionen tre gange. Brug først heltal som parametre, andet ved hjælp af float som parametre og tredje ved hjælp af dobbelt som parameter.
Således tilsidesætter vi add () -funktionen to gange.

Fordele ved funktion Overbelastning i C ++

  • Vi bruger overbelastning af funktioner for at spare hukommelsesplads, konsistens og læsbarhed i vores program.

    c ++ scope-operatør
  • Med brugsfunktionen overbelastningskoncept kan vi udvikle mere end en funktion med samme navn

  • Funktionsoverbelastning viser polymorfismens opførsel, der giver os mulighed for at få forskellig adfærd, selvom der vil være et eller andet link, der bruger det samme navn på funktionen.

  • Funktionsoverbelastning fremskynder udførelsen af ​​programmet.

  • Funktionsoverbelastning bruges til genanvendelighed af koder og også til at spare hukommelse.

  • Det hjælper applikationen med at indlæse klassemetoden baseret på typen af ​​parameter.

  • Kode vedligeholdelse er let.

Ulemper ved funktion Overbelastning i C ++

  • Funktionserklæringer, der kun adskiller sig efter returtype, kan ikke overbelastes med funktionsoverbelastningsprocessen.
  • Medlemsfunktionserklæringer med de samme parametre eller de samme navnetyper kan ikke overbelastes, hvis en af ​​dem erklæres som en statisk medlemsfunktion.
  • klasse XYZ {statisk ugyldig funk () ugyldig funk () // fejl}

Funktionsoverbelastning og tvetydighed

Når kompilatoren ikke er i stand til at bestemme hvilken funktion den skal påberåbe sig blandt de overbelastede funktioner, er denne situation kendt som funktionsoverbelastnings tvetydighed. Compileren kører ikke programmet, hvis det viser tvetydighedsfejl. Årsager til tvetydighed ved overbelastning af funktioner:

  • Type konvertering.
  • Funktion med standardargumenter.
  • Funktion med en forbipasserende reference

Type konvertering:

#include ved hjælp af namespace std ugyldig funktion (float) ugyldig funktion (int) ugyldig funktion (float x) {std :: cout<< 'Value of x is : ' <

i python bruges __init__-metoden i en klasse til

Ovenstående eksempel kaster en fejl - 'opkald af overbelastet 'funktion (dobbelt)' er tvetydig'. Funktionen (3.4) kalder den første funktion. Funktionen (34) kalder den anden funktion i henhold til vores forudsigelse. Men dette er ikke, hvad der sker, fordi i C ++ behandles alle flydende punktkonstanter som dobbelt, ikke som en float. Hvis vi udskifter floatvariablen til en dobbelt variabel, fungerer programmet fint. Derfor kalder vi dette en type konverteringsfejl fra float til double.

Funktion med standardargumenter:

#include ved hjælp af namespace std ugyldig funktion (int) ugyldig funktion (int, int) ugyldig funktion (int x) {std :: cout<< 'Value of x is : ' <

Ovenstående eksempel giver en fejl, der siger 'opkald af overbelastet 'sjov (int)' er tvetydig', det er fordi funktion (int y, int z = 12) kan kaldes på to måder:

  1. Ved at kalde funktionen med et argument (og det vil automatisk tage værdien z = 12)
  2. Ved at kalde funktionen med to argumenter.

Når vi kalder funktionen: funktion (12), udfylder vi fuldstændigt betingelsen for både funktion (int) og funktion (int, int), således at kompilatoren kommer i en tvetydighed viser en fejl.

Funktion med forbipasserende reference

#include ved hjælp af namespace std ugyldig funktion (int) ugyldig funktion (int &) ugyldig funktion (int a) {std :: cout<< 'Value of a is : ' < 

Ovenstående program giver en fejl, der siger 'opkald af overbelastet 'sjov (int &)' er tvetydig'. Som vi ser tager den første funktion et heltalsargument, og den anden funktion tager en referenceparameter som et argument. I dette tilfælde er compileren ikke i stand til at forstå, hvilken funktion der er brug for af brugeren, da der ikke er nogen syntaktisk forskel mellem det sjove (int) og det sjove (int &), så det skyder en tvetydighedsfejl.

Med dette kommer vi til en ende af denne funktionsoverbelastning i C ++. Hvis du ønsker at lære mere, skal du tjekke af Edureka, et betroet online læringsfirma. Edurekas Java J2EE- og SOA-uddannelses- og certificeringskursus er designet til at træne dig til både kerne- og avancerede Java-koncepter sammen med forskellige Java-rammer som Hibernate & Spring.

Har du et spørgsmål til os? Nævn det i kommentarsektionen på denne blog, og vi vender tilbage til dig hurtigst muligt.