Hvad er overbelastning i C ++?
C ++ gør det muligt at skrive fleksibel og let at forstå kode ved hjælp af konceptet kendt som Overloading. Det giver mulighed for at opnå forskellige funktioner inden for den eksisterende kode med meget minimale ændringer, hvilket reduceres ved at reducere duplikatkoden. Grundlæggende er der hovedsageligt to primære typer overbelastning, som understøttes af C ++.
C ++ giver os mulighed for at skrive funktioner med samme navn, men med forskellen i datatyper eller i antallet af argumenter, der er sendt til det, er denne funktion kendt som Funktion Overbelastning i C ++. Denne funktion giver udviklere mulighed for at definere funktionerne med det samme navn inden for det samme omfang. Med det samme navn repræsenterer funktionerne den samme funktionalitet, hvilket gør det muligt at opnå kompileringstid-polymorfisme. Funktionens overbelastning har en fordel, at det forbedrer kodens læsbarhed.
Der er en anden funktion, der findes i C ++, som tillader omdefinering af den eksisterende funktionalitet hos indbyggede operatører, der kaldes Operatøroverbelastning . Denne funktion tillader brug af indbyggede operatører på brugerdefinerede typer. Operatøroverbelastning forenkler koden ved at omdefinere funktionaliteten i henhold til brugerens krav. I denne artikel vil vi fokusere på både funktionsoverbelastning og operatørens overbelastning, vi vil se detaljerne om den, og hvordan den bruges i C ++.
Hvordan fungerer overbelastning i C ++?
- Funktion Overbelastning: Det giver os mulighed for at definere funktionen med samme navn, men den adskiller funktionerne afhængigt af typen af parametre, der er sendt til dem, eller antallet af parametre, der er sendt til dem. Så alle funktioner har det samme navn, men har enten en anden datatype eller får et andet antal parametre sendt til den. Når funktionen kaldes, vælger kompilatoren funktionen med den matchende parametertype og matcher antallet af argumenter. Nu kan dens udviklere vælge, hvilken funktion de skal ringe i henhold til kravene. De kan vælge den passende funktion ved at videregive parametrene efter reglerne.
- Operatøroverbelastning: Det giver operatører mulighed for at arbejde for brugerdefinerede datatyper, dvs. klasser. De eksisterende operatører overbelastes og får strømmen til at operere på den brugerdefinerede klasse og objekter. Operatøroverbelastning opnås ved at definere funktionen med det specielle navn. Funktionen har navnet 'operatør' efterfulgt af operatørsymbolet. Vi kan bruge operatørsymbolet direkte på den brugerdefinerede datatype og udføre handlingen. Den nødvendige handling eller handling er defineret i den specielle funktion af os. Ved hjælp af operatøroverbelastning kan vi udføre operationer af forskellige typer på samme type datatype.
Typer af overbelastning i C ++
Funktion Overbelastning kan opnås under alle omstændigheder med hensyn til brug af parametre. Når vi siger brug af parametre, det refererer til, type parametre eller antal parametre eller rækkefølgen af parametre. Så funktion calc (int x, float y) med parametre (int x, float y) er forskellig fra en funktion defineret som calc (float x, int y), som har forskellige parametre med den forskellige datatype.
Der kan være et antal typer, hvor funktionsoverbelastning kan opnås. Lad os se det enkle eksempel på funktionsoverbelastning i C ++.
#include
using namespace std;
class Display (
public:
static void show (char message() ) (
cout<< "Only Message:" << message << endl;
)
static void show (int messageId, char message()) (
cout<< "Message with Id:";
cout << messageId << " Message:" << message << endl;
)
);
int main (void) (
Display obj;
char message() = "Welcome";
int messageId = 10;
obj.show(message); //calling overloaded function with 1 parameter
obj.show(messageId, message);//calling overloaded function with 2 parameters
return 0;
)
Her har vi klassevisning, der viser en overbelastet metodevis. Showmetoden kaldes afhængigt af de argumenter, der er sendt til den.
Produktion:
Eneste besked: Velkommen
En meddelelse med Id: 10 Meddelelse: Velkommen
Operatøroverbelastning kan opnås på næsten alle de indbyggede datatyper, der er tilgængelige i C ++. Der er ikke som sådan forskellige typer operatøroverbelastning, men fremgangsmåderne kan være forskellige, som bruges til at opnå operatøroverbelastning. Operatører som Unary, Binary, Relational, Assignment osv. Kan overbelastes i C ++.
Lad os se det enkle eksempel på overbelastning af ++ operatøren. I dette eksempel i stedet for primitiv datatype, bruger vi ++ operator på det brugerdefinerede klasseobjekt.
#include
using namespace std;
class Bike (
private:
int height;
public:
Bike (): height (80) () //constructor which initializes the height variable
void operator ++() (
height = height + 5;
)
void Specs () (
cout << "The height of the bike is: " < )
);
int main(void)
(
Bike bike;
bike.Specs();
++bike; //calling overloaded operator
bike.Specs();
return 0;
)#include
using namespace std;
class Bike (
private:
int height;
public:
Bike (): height (80) () //constructor which initializes the height variable
void operator ++() (
height = height + 5;
)
void Specs () (
cout << "The height of the bike is: " < )
);
int main(void)
(
Bike bike;
bike.Specs();
++bike; //calling overloaded operator
bike.Specs();
return 0;
)
Så vi har et objekt, hvis oprindelige højde indstilles til 80 og øges med 5, når vi kalder ++ operatør over det.
Produktion:
Cykelens højde er: 80
Cykelens højde er: 85
Regler for overbelastning i C ++
Nedenfor er de forskellige regler for overbelastning af C ++ som følger:
Regler for overbelastning af funktionen
- Ved overbelastning af funktioner skal funktionen variere med hensyn til datatype, antal eller rækkefølgen af parametre. Det kan ikke adskille sig blot på grundlag af funktionen for returneringstype.
Regler for overbelastning af operatøren
- Kun indbyggede operatører kan overbelastes, de nye operatører kan ikke overbelastes.
- Der er fire operatører, som ikke kan overbelastes, disse er . (medlemsvalg), :: (omfangsopløsning), . * (medlemsvalg ved hjælp af markøren til at fungere) og?: (ternary operator).
- Den overbelastede operatør vil indeholde mindst en operand af den brugerdefinerede datatype.
- Der er visse operatører, der ikke kan overbelastes ved hjælp af venfunktionen, men de kan overbelastes som en medlemsfunktion.
Konklusion
Så overbelastningen i C ++ er den unikke funktion, der giver os flere fordele. Der er hovedsageligt to typer overbelastning, dvs. funktionsoverbelastning og operatøroverbelastning. Funktion overbelastning forbedrer kodelæsbarheden og bevarer det samme navn til den samme handling. Operatøroverbelastning gør det muligt at omdefinere operatørens eksisterende funktionalitet ved at give dem særlig mening. Begge er meget nyttige til programmering i C ++.
Anbefalede artikler
Dette er en guide til overbelastning i C ++. Her diskuterer vi dets arbejde, regler og to typer overbelastning i c ++ dvs. funktionsoverbelastning og operatøroverbelastning. Du kan også se på den følgende artikel for at lære mere -
- Overbelastning i PHP
- Kopier konstruktør i C ++
- Overbelastning vs overdrivning
- Skift erklæring i C ++
- Overbelastning i Java
- Python-overbelastning