C++ overbelasting (operator en functie)

Met C++ kunt u meer dan één definitie opgeven voor een functie naam of een operator in hetzelfde bereik, dat functie-overbelasting wordt genoemd en overbelasting van de operator respectievelijk.

Een overbelaste aangifte is een aangifte die wordt gedeclareerd met dezelfde naam als een eerder gedeclareerde aangifte in hetzelfde bereik, behalve dat beide aangiften verschillende argumenten hebben en uiteraard een andere definitie (implementatie).

Wanneer u een overbelaste functie aanroept of operator , bepaalt de compiler de meest geschikte definitie om te gebruiken, door de argumenttypes die u hebt gebruikt om de functie of operator aan te roepen, te vergelijken met de parametertypes die in de definities zijn gespecificeerd. Het proces van het selecteren van de meest geschikte overbelaste functie of operator wordt overbelastingsoplossing genoemd .

Functieoverbelasting in C++

U kunt meerdere definities hebben voor dezelfde functienaam in hetzelfde bereik. De definitie van de functie moet van elkaar verschillen door de typen en/of het aantal argumenten in de argumentenlijst. U kunt functiedeclaraties die alleen verschillen per retourtype niet overbelasten.

Hieronder volgt het voorbeeld waarbij dezelfde functie print() wordt gebruikt om verschillende gegevenstypen af ​​te drukken −

#include <iostream>
using namespace std;
 
class printData {
   public:
      void print(int i) {
        cout << "Printing int: " << i << endl;
      }
      void print(double  f) {
        cout << "Printing float: " << f << endl;
      }
      void print(char* c) {
        cout << "Printing character: " << c << endl;
      }
};

int main(void) {
   printData pd;
 
   // Call print to print integer
   pd.print(5);
   
   // Call print to print float
   pd.print(500.263);
   
   // Call print to print character
   pd.print("Hello C++");
 
   return 0;
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Operators overbelasten in C++

U kunt de meeste ingebouwde operators die beschikbaar zijn in C++ opnieuw definiëren of overbelasten. Een programmeur kan dus ook operators gebruiken met door de gebruiker gedefinieerde typen.

Overbelaste operators zijn functies met speciale namen:het trefwoord "operator" gevolgd door het symbool voor de operator die wordt gedefinieerd. Net als elke andere functie heeft een overbelaste operator een retourtype en een parameterlijst.

Box operator+(const Box&);

declareert de opteloperator die kan worden gebruikt om toe te voegen twee Box-objecten en retourneert het laatste Box-object. De meeste overbelaste operators kunnen worden gedefinieerd als gewone niet-lidfuncties of als klassenlidfuncties. In het geval dat we bovenstaande functie definiëren als een niet-lidfunctie van een klasse, dan zouden we als volgt twee argumenten voor elke operand moeten doorgeven −

Box operator+(const Box&, const Box&);

Hierna volgt het voorbeeld om het concept van operator over laden te laten zien met behulp van een lidfunctie. Hier wordt een object doorgegeven als argument waarvan de eigenschappen zullen worden benaderd met behulp van dit object, het object dat deze operator zal aanroepen kan worden benaderd met behulp van this operator zoals hieronder uitgelegd −

#include <iostream>
using namespace std;

class Box {
   public:
      double getVolume(void) {
         return length * breadth * height;
      }
      void setLength( double len ) {
         length = len;
      }
      void setBreadth( double bre ) {
         breadth = bre;
      }
      void setHeight( double hei ) {
         height = hei;
      }
      
      // Overload + operator to add two Box objects.
      Box operator+(const Box& b) {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
      
   private:
      double length;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};

// Main function for the program
int main() {
   Box Box1;                // Declare Box1 of type Box
   Box Box2;                // Declare Box2 of type Box
   Box Box3;                // Declare Box3 of type Box
   double volume = 0.0;     // Store the volume of a box here
 
   // box 1 specification
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // box 2 specification
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // volume of box 1
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // volume of box 2
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:
   Box3 = Box1 + Box2;

   // volume of box 3
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

Overbelastbare/niet-overbelastbare Operators

Hieronder volgt de lijst met operators die overbelast kunnen worden −

Hieronder volgt de lijst met operators die niet kunnen worden overbelast −

Voorbeelden van overbelasting van operators

Hier zijn verschillende voorbeelden van overbelasting door operators om u te helpen het concept te begrijpen.