C ++ Funktion Overbelastning

C ++ er et fleksibelt programmeringssprog til generelle formål. Dette programmeringssprog blev oprindeligt oprettet af Bjarne Stroustrup, en dansk datalog, tilbage i 1985. C ++ understøtter polymorfisme, arv og mere. Denne artikel dækker funktionsoverbelastning for at opnå kompileringstidspolymorfisme i C ++ programmeringssproget.

Hvad er en funktion?

En funktion er intet andet end et specifikt stykke kode, der udfører en bestemt opgave baseret på leverede input, og den returnerer de ønskede resultater til brugeren i form af en output. Funktioner bruges til at eliminere gentagne koder i store kodebaser.

Når du har defineret en funktion, kan du genbruge den på et senere tidspunkt, enten i det samme program eller i et andet program.

Funktionssyntaks

En funktion i C ++ har følgende syntaks:

returnType funktionsnavn (parameter_liste)

..
..
returner returværdi;

ReturnType, parameter_list og return statement er valgfri. En funktion i C ++ kan maksimalt returnere en værdi. Hvis en funktion ikke returnerer nogen værdi, skal returnType defineres som ugyldig.

Hvad er funktionsoverbelastning?

I C ++ kan flere funktionsdefinitioner have samme funktionsnavn, men med forskellige parametre. Dette kaldes funktionsoverbelastning. Ved hjælp af funktionsoverbelastningsfunktionen kan polymorfisme til kompileringstid opnås i C++.

Funktioner kan overbelastes på følgende måder:

Antallet af parametre kan være forskelligt
Datatypen for parametrene kan være forskellig
Sekvensen af parametrene kan være forskellig

Returværdien tages dog ikke i betragtning ved funktionsoverbelastning.

Følgende funktioner er overbelastede:

int-tilføjelse (int a, int b)
float addition (float f, gloat g)
float addition (float f, int i)
float addition (int i, float f)
int-tilføjelse (int a, int b, int c)
float addition (float f, float g, float h)

Som du kan se, ved hjælp af funktionens overbelastningsfunktion i C ++, kan der være flere definitioner / funktioner med samme funktionsnavn og i samme omfang.

Uden funktionens overbelastningsfunktion skal du skrive en separat funktion [for eksempel addition_1 (), addition_2 () osv.] For hver variation. For eksempel skal du muligvis skrive addition_1 () for at tilføje to heltal, addition_2 () for at tilføje to floats osv. Som du kan se ovenfor, kan funktionens overbelastningsfunktion imidlertid bruges til at definere flere variationer af funktionen "tilføjelse ()", mens det samme funktionsnavn bevares.

Følgende funktioner betragtes ikke som overbelastede, fordi den eneste forskel mellem disse to er returtypen (returtype betragtes ikke som funktion overbelastning i C ++):

int-tilføjelse (int a, int b)
float addition (int a, int b)

Eksempler

Nu hvor du forstår begrebet funktionsoverbelastning, vil vi gennemgå et par arbejdseksempelprogrammer for at forstå dette koncept mere tydeligt. Vi vil dække følgende eksempler:

Eksempel 1: Enkel funktion
Eksempel 2: Enkel tilføjelsesfunktion
Eksempel 3: Funktionsoverbelastning (1)
Eksempel 4: Funktionsoverbelastning (2)
Eksempel 5: Funktionsoverbelastning (3)

De første to eksempler forklarer, hvordan normale funktioner fungerer i C ++, mens de sidste tre eksempler demonstrerer funktionens overbelastningsfunktion i C++.

Eksempel 1: Enkel funktion

I dette eksempel viser vi, hvordan en simpel funktion kan defineres og kaldes C++. Vi definerer en klasse kaldet "Display" og en offentlig funktion kaldet "display ().”Fra“ main () ”-funktionen kalder vi“ display () ”-funktionen ved hjælp af" Display "-klasseobjektet (d).

#omfatte
ved hjælp af namespace std;
klasse Display

offentlig:
ugyldig visning ()

cout << "Hello World!" << endl;

;
int main ()

Skærm d;
d.Skærm();
returnere 0;

Eksempel 2: Enkel tilføjelsesfunktion

I dette eksempel vil vi demonstrere, hvordan man definerer en simpel “tilføjelse ()” -funktion i C++. Vi definerer en klasse kaldet “DemoAdd” og en offentlig funktion kaldet “tilføjelse ().”Fra funktionen“ main () ”kalder vi funktionen“ addition () ”ved hjælp af klasseobjektet“ DemoAdd ”(d).

I dette eksempel accepterer den aktuelle implementering af funktionen "tilføjelse ()" kun to heltalsparametre. Det betyder, at den aktuelle “tilføjelse ()” - funktion kun er i stand til at tilføje to heltal.

For at tilføje tre heltal i stedet for to, kan en funktion med et andet navn, såsom "addition_1 ()", defineres. I C ++ kan en funktion overbelastes, hvilket betyder, at en anden definition af funktionen "tilføjelse ()" kan defineres for at tilføje tre heltal og beholde det samme navn, dvs.e., “Tilføjelse ().”I det næste eksempel vil vi se på, hvordan man overbelaster funktionen“ tilføjelse () ”.

#omfatte
ved hjælp af namespace std;
klasse DemoAdd

offentlig:
int-tilføjelse (int a, int b)

int-resultat;
resultat = a + b;
returresultat

;
int main ()

DemoTilføj d;
int i1 = 10, i2 = 20, res;
res = d.tilsætning (i1, i2);
cout << "Result = " << res << endl;
returnere 0;

Eksempel 3: Funktionsoverbelastning (1)

I det foregående eksempel definerede vi funktionen "tilføjelse ()" for at tilføje to heltal og returnere det beregnede resultat. Nu i dette eksempel overbelaster vi funktionen "tilføjelse ()" for at tilføje tre heltal. Så vi vil være i stand til at kalde "tilføjelse ()" - funktionen med to heltalargumenter samt tre heltalargumenter.

Uden funktionen overbelastningsfunktion er vi nødt til at skrive en anden funktion med et andet navn.

#omfatte
ved hjælp af namespace std;
klasse DemoAdd

offentlig:
// Første funktionsdefinition af tilføjelse ()
int-tilføjelse (int a, int b)

int-resultat;
resultat = a + b;
returresultat

// Overbelastet version af funktionen addition ()
int-tilføjelse (int a, int b, int c)

int-resultat;
resultat = a + b + c;
returresultat

;
int main ()

DemoTilføj d;
int i1 = 10, i2 = 20, i3 = 30, res1, res2;
res1 = d.tilsætning (i1, i2); // tilføjelse () med 2 parametre
res2 = d.tilsætning (i1, i2, i3); // tilføjelse () med 3 parametre
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
returnere 0;

Eksempel 4: Funktionsoverbelastning (2)

I tidligere afsnit af denne artikel lærte du, at funktionsoverbelastning kan udføres baseret på forskelle i parametertype. Her har vi overbelastet funktionen "tilføjelse ()" baseret på parameterens datatype. I den første version af tilføjelsesfunktionen tilføjer vi to heltalstypevariabler; og i den anden version vil vi tilføje to variabler af flydetypen.

#omfatte
ved hjælp af namespace std;
klasse DemoAdd

offentlig:
// Første definition af tilføjelse ()
int-tilføjelse (int a, int b)

int-resultat;
resultat = a + b;
returresultat

// Definition af overbelastet funktion
float addition (float f, float g)

float resultat
resultat = f + g;
returresultat

;
int main ()

DemoTilføj d;
int i1 = 10, i2 = 20, res1;
flyde f1 = 10.5, f2 = 20.7, res2;
res1 = d.tilsætning (i1, i2); // tilføjelse (int a, int b) kaldes
res2 = d.tilsætning (f1, f2); // tilføjelse (float f, flat g) kaldes
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
returnere 0;

Eksempel 5: Funktionsoverbelastning (3)

I dette eksempel er "addition ()" - funktionen overbelastet baseret på forskelle i rækkefølgen af parameterlisten. Dette er en anden måde at overbelaste en funktion i C på++.

#omfatte
ved hjælp af namespace std;
klasse DemoAdd

offentlig:
// Første funktionsdefinition af tilføjelses () funktion
float addition (int a, float b)

float resultat
resultat = (flyde) a + b;
returresultat

// Overbelastet funktionsdefinition af tilføjelses () funktion
float addition (float a, int b)

float resultat
resultat = a + (flyde) b;
returresultat

;
int main ()

DemoTilføj d;
int i1 = 10;
flyde f1 = 10.5, res1, res2;
res1 = d.tilsætning (i1, fl); // tilføjelse (int a, float b) kaldes
res2 = d.tilsætning (f1, i1); // tilføjelse (float a, int b) kaldes
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
returnere 0;

Konklusion

C ++ er et generelt og fleksibelt programmeringssprog, der er meget brugt på forskellige domæner. Dette programmeringssprog understøtter både kompileringstid og runtime polymorfisme. I denne artikel lærte du, hvordan man opnår polymorfisme med kompileringstid i C ++ ved hjælp af funktionen overbelastningsfunktion. Dette er en meget nyttig funktion i C ++, der hjælper programmører til at skrive læsbar kode. Det kan også være nyttigt til skrivning af genanvendelig kode.