Vad är överbelastning i C ++?
C ++ gör det möjligt att skriva flexibel och lätt att förstå koden med begreppet överbelastning. Det gör det möjligt att uppnå olika funktioner inom den befintliga koden med mycket minimala förändringar och därmed minska duplikatkoden. I grund och botten finns det huvudsakligen två primära typer av överbelastning som stöds av C ++.
C ++ gör det möjligt för oss att skriva funktioner med samma namn men med skillnaden i datatyper eller i antalet argument som har skickats till den här funktionen kallas funktionen överbelastning i C ++. Denna funktion gör det möjligt för utvecklare att definiera funktionerna med samma namn inom samma omfattning. Med samma namn representerar funktionerna samma funktionalitet vilket gör det möjligt att uppnå kompileringstid-polymorfism. Funktionens överbelastning har en fördel att den förbättrar kodens läsbarhet.
Det finns en annan funktion som tillhandahålls i C ++ som gör det möjligt att omdefiniera befintlig funktionalitet hos inbyggda operatörer, som kallas Operator Overloading . Denna funktion gör det möjligt att använda inbyggda operatörer på användardefinierade typer. Operatörens överbelastning förenklar koden genom att omdefiniera funktionaliteten enligt användarkraven. I den här artikeln kommer vi att fokusera på både överbelastning av funktionen och överbelastningen av operatören, vi kommer att se detaljerna om den och hur den används i C ++.
Hur fungerar överbelastning i C ++?
- Funktionsöverbelastning: Det låter oss definiera funktionen med samma namn, men den skiljer funktionerna beroende på typen av parametrar som skickas till dem eller antalet parametrar som skickas till dem. Så alla funktioner har samma namn men har antingen olika datatyper eller kommer att ha ett annat antal parametrar som skickas till den. När funktionen anropas väljer kompilatorn funktionen med den matchande parametertypen och matchar antalet argument. Nu kan dess utvecklare välja vilken funktion de ska ringa enligt kraven. De kan välja lämplig funktion genom att lämna parametrarna enligt reglerna.
- Operatörsöverbelastning: Det gör det möjligt för operatörer att arbeta för användardefinierade datatyper, dvs klasser. De befintliga operatörerna är överbelastade och ges kraften att arbeta med den användardefinierade klassen och föremålen. Operatörens överbelastning uppnås genom att definiera funktionen med specialnamnet. Funktionen har namnet "operatör" följt av operatörssymbolen. Vi kan använda operatörssymbolen direkt på den användardefinierade datatypen och utföra operationen. Den nödvändiga åtgärden eller åtgärden definieras i den speciella funktionen av oss. Genom överbelastning av operatörer kan vi utföra operationer av olika typer på samma typ av datatyp.
Typer av överbelastning i C ++
Funktion Överbelastning kan uppnås på alla sätt när det gäller användning av parametrar. När vi säger användning av parametrar det hänvisar till, typ av parametrar eller antal parametrar eller sekvens av parametrar. Så funktion calc (int x, float y) med parametrar (int x, float y) skiljer sig från en funktion definierad som calc (float x, int y) som har olika parametrar med olika datatyp.
Det kan finnas ett antal typer där funktionsöverbelastning kan uppnås. Låt oss se det enkla exemplet på överbelastning av funktioner 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;
)
Här har vi klassvisning som har en överbelastad metodvisning. Showmetoden kommer att anropas beroende på de argument som skickas till den.
Produktion:
Endast meddelande: Välkommen
Ett meddelande med Id: 10 Meddelande: Välkommen
Operatörens överbelastning kan uppnås på nästan alla inbyggda datatyper som finns tillgängliga i C ++. Det finns inga sådana olika typer av överbelastning av operatörerna, men metoderna kan vara olika som används för att uppnå överbelastning av operatörerna. Operatörer som Unary, Binary, Relational, Assignment etc. kan överbelastas i C ++.
Låt oss se det enkla exemplet på överbelastning av ++ operatör. I det här exemplet istället för primitiv datatyp kommer vi att använda ++ operatör på det användardefinierade klassobjektet.
#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 ett objekt vars initiala höjd kommer att ställas in på 80 och kommer att ökas med 5 när vi ringer ++ operatör över den.
Produktion:
Cykelns höjd är: 80
Cykelns höjd är: 85
Regler för överbelastning i C ++
Nedan följer de olika C ++ överbelastningsreglerna enligt följande:
Regler för överbelastning av funktionen
- Vid överbelastning av funktioner måste funktionen skilja sig i fråga om datatyp, antal eller parametrarsekvens. Det kan inte skilja sig helt enkelt på grundval av funktionen för returtyp.
Regler för överbelastning av operatören
- Endast inbyggda operatörer kan överbelastas, de nya operatörerna kan inte överbelastas.
- Det finns fyra operatörer som inte kan överbelastas . (medlemsval), :: (omfattningsupplösning), . * (medlemsval med hjälp av pekaren för att fungera) och?: (ternär operatör).
- Den överbelastade operatören kommer att innehålla minst en operand av den användardefinierade datatypen.
- Det finns vissa operatörer som inte kan överbelastas med hjälp av vänfunktionen, men de kan överbelastas som en medlemsfunktion.
Slutsats
Så överbelastningen i C ++ är den unika funktionen som ger oss flera fördelar. Det finns huvudsakligen två typer av överbelastning, dvs. överbelastning av funktioner och överbelastning av operatörer. Funktionsöverbelastning förbättrar kodläsbarheten och håller därför samma namn för samma åtgärd. Operatörens överbelastning gör det möjligt att omdefiniera operatörens befintliga funktionalitet genom att ge dem speciell mening. Båda är mycket användbara vid programmering i C ++.
Rekommenderade artiklar
Detta är en guide till överbelastning i C ++. Här diskuterar vi dess arbete, regler och två typer av överbelastning i c ++ dvs funktionsöverbelastning och överbelastning av operatörer. Du kan också titta på följande artikel för att lära dig mer -
- Överbelastning i PHP
- Kopiera konstruktör i C ++
- Överbelastning kontra överrider
- Byt uttalande i C ++
- Överbelastning i Java
- Python överbelastning