Introduktion till överbelastning av funktioner i C ++
C ++ -programmering har fantastiska funktioner och en av de viktigaste funktionerna är överbelastning av funktioner. Det betyder en kod som har mer än en funktion med samma namn men med de olika argumentlistorna. Argumentlistan betyder sekvensen för argumenten och datatyperna av argument. Funktionsöverbelastning används för att utföra liknande operationer. Den används för att förbättra kodens läsbarhet. Omdefinierade funktionen eftersom det inte är någon mening att skapa två olika funktioner för att utföra samma arbete om och om igen.
Syntax
void add(int a, int b);
void add(float a, float b);
Båda har samma funktion men argumenten är olika. Så om du vill utföra tillägg på olika datatyper med samma funktion kan funktionen överbelastningsfunktion användas i programmering med C ++.
Här är C ++ -koden för att visa överbelastning av funktioner i C ++ -programmering:
Koda:
#include
using namespace std;
void print(int x) (
cout << " Here is the integer " << x << endl;
)
void print(double y) (
cout << " Here is the float " << y << endl;
)
void print(char const *v) (
cout << " Here is the character* " << v << endl;
)
int main() (
print(20);
print(20.30);
print("three");
return 0;
)
Olika sätt att överbelasta funktionen i C ++
Det finns flera sätt att överbelasta en funktion på C ++ programmeringsspråk. Låt oss se hur kan vi göra det:
1. Funktion Överbelastning
Används för att öka kodläsbarheten vid programmering. Det kan definieras som överbelastning 2 eller fler funktioner med samma namn men olika parametrar kallas Funktionsöverbelastning.
Syntax:
DataType Functionname (parameter list)
(
Function body
)
Exempel 1
Här är C ++ -koden för att visa överbelastning av funktioner genom att ändra antalet argument i C ++ -programmering:
Koda:
#include
using namespace std;
class Calculate (
public:
static int addition(int a, int b)(
return a + b;
)
static int addition(int a, int b, int c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
static int addition(int a, int b)(
return a + b;
)
static int addition(int a, int b, int c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
static int addition(int a, int b)(
return a + b;
)
static int addition(int a, int b, int c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)
Exempel 2
Här är C ++ -koden för att visa överbelastning av funktioner genom att ha olika typer av argument i C ++ -programmering:
Koda:
#include
using namespace std;
class Calculate (
public:
int addition(int a, int b)(
return a + b;
)
float addition(float a, float b, float c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
int addition(int a, int b)(
return a + b;
)
float addition(float a, float b, float c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
int addition(int a, int b)(
return a + b;
)
float addition(float a, float b, float c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)
2. Överbelastning av operatören
Det finns flera inbyggda operatörer i programmeringsspråket C ++. En kodare kan använda dessa operatörer för att överbelasta eller omdefiniera dessa inbyggda operatörer. Det är en kompileringstid-polymorfism där en överbelastad operatör används för att utföra uppgifter på användardefinierade datatyper. Nästan många operatörer kan överbelastas i C ++ programmeringsspråk.
Syntax:
ReturnType Classname :: operator OperatorSymbol (parameter list)
(
Function body
)
Exempel 1
Här är C ++ -koden för att visa operatörens överbelastning i C ++ -programmering:
Koda:
#include
using namespace std;
class Demo
(
private:
int count;
public:
Demo(): count(5)()
void operator ++()
(
count = count+1;
)
void DisplayCount() ( cout<<"The Count is : "< );
int main()
(
Demo d;
// this calls void operator ++()" function
++d;
d.DisplayCount();
return 0;
)#include
using namespace std;
class Demo
(
private:
int count;
public:
Demo(): count(5)()
void operator ++()
(
count = count+1;
)
void DisplayCount() ( cout<<"The Count is : "< );
int main()
(
Demo d;
// this calls void operator ++()" function
++d;
d.DisplayCount();
return 0;
)
Exempel 2
Låt oss se hur funktionsöverbelastning faktiskt fungerar? vid programmering genom C ++ -kodningsexempel:
Koda:
#include
using namespace std;
void show(int);
void show(float);
void show(int, float);
int main() (
int x = 10;
float y = 255.5;
show(x);
show(y);
show(x, y);
return 0;
)
void show(int variable) (
cout << "The Integer number is : " << variable << endl;
)
void show(float variable) (
cout << "The Float number is: " << variable << endl;
)
void show(int variable1, float variable2) (
cout << "The Integer number is: " << variable1;
cout << " And The Float number is:" << variable2;
)
Kodförklaring:
I ovanstående kod har vi skapat en funktion för att visa utgången från olika datatyper men om du märker att funktioner är namnet samma och argumenten är olika. Sedan initialiserade vi en variabel som heter x och tilldelade den ett värde och ett värde tilldelat floatvariabel y också. Efter att ha tilldelat värden till x- och y-variabler kallade vi funktionen som visas för att visa ingångsvärde på utgångsskärmen.
Som du kan se funktionsnamnen men argumentet är annorlunda i alla tre fallen. Först kallade vi funktionen bara heltalvariabel, därefter kallade vi showfunktion för att endast visa utgång för flottörvariabel. Slutligen kallade vi showfunktionen som har både heltal och floatvariabler för att visa output på skärmen som output.
Så här fungerar funktionen för överbelastning faktiskt på programmeringsspråket C ++. Beroende på olika datatyper kan samma funktion användas för att utföra en liknande uppsättning operationer.
Exempel 3
Här är C ++ -koden för att visa överbelastning av funktioner i C ++ -programmering:
Koda:
#include
using namespace std;
class X
( int x;
public:
X()()
X(int j)
(
x=j;
)
void operator+(X);
void display();
);
void X :: operator+(X a)
(
int n = x+ax;
cout<<"The addition of two objects is : "< )
int main()
(
X a1(505);
X a2(409);
a1+a2;
return 0;
)#include
using namespace std;
class X
( int x;
public:
X()()
X(int j)
(
x=j;
)
void operator+(X);
void display();
);
void X :: operator+(X a)
(
int n = x+ax;
cout<<"The addition of two objects is : "< )
int main()
(
X a1(505);
X a2(409);
a1+a2;
return 0;
)
Kodförklaring:
I koden ovan skapade vi en klass X och skapade en heltalvariabel x och förklarade sedan två konstruktörer så att vi inte behöver skapa objekt för att kalla funktionen eftersom konstruktören automatiskt initialiserar ett nyskapat klassobjekt precis efter att ett minne har tilldelats . Två funktioner skapas operatör och display för att visa tillägg av två objekt med hjälp av överbelastningskoncept för funktioner i vår kod.
Slutsats
Sammanfattningsvis kan funktionen för överbelastning av funktioner i C ++ användas på flera sätt för att öka kodläsbarheten. Det hjälper till att spara minnesutrymme såväl som kompileringstid vid programmering med C ++ -språket. Polymorfismkoncept för kompileringstid introduceras också genom överbelastningskoncept för operatörer där nästan varje operatör kan överbelastas.
Rekommenderade artiklar
Detta är en guide till funktionsöverbelastning i C ++. Här diskuterar vi de olika sätten att överbelasta funktionen i C ++ tillsammans med olika exempel och kodimplementering. Du kan också titta på följande artikel för att lära dig mer -
- Hur rekursiv funktion fungerar i C ++?
- Topp 3 datatyper i C ++
- Exempel på överbelastning och överbestyrning i C ++
- String Array i C ++ en matris med flera strängar