C++ Overloading Beheersen: Functies & Operators Uitgelegd

C++ stelt u in staat meer dan één definitie voor een functie naam of een operator in dezelfde scope te specificeren, wat respectievelijk function overloading en operator overloading wordt genoemd.

Een overloaded declaratie is een declaratie die gedeclareerd is met dezelfde naam als een eerder gedeclareerde declaratie in dezelfde scope, behalve dat beide declaraties verschillende argumenten hebben en uiteraard verschillende definitie (implementatie).

Wanneer u een overloaded functie of operator aanroept, bepaalt de compiler de meest geschikte definitie om te gebruiken, door de argumenttypen die u hebt gebruikt om de functie of operator aan te roepen te vergelijken met de parametertypen gespecificeerd in de definities. Het proces van het selecteren van de meest geschikte overloaded functie of operator heet overload resolution.

Function Overloading in C++

U kunt meerdere definities hebben voor dezelfde functienaam in dezelfde scope. De definitie van de functie moet van elkaar verschillen op de typen en/of het aantal argumenten in de argumentenlijst. U kunt functiedeclaraties niet overloaden die alleen verschillen in return type.

Hier volgt het voorbeeld waar dezelfde functie print() gebruikt wordt om verschillende datatypen te printen:

 #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;
  // Roep print aan om integer te printen
  pd.print(5);
  // Roep print aan om float te printen
  pd.print(500.263);
  // Roep print aan om karakter te printen
  pd.print("Hello C++");
  return 0;
} 

Wanneer de bovenstaande code gecompileerd en uitgevoerd wordt, produceert het het volgende resultaat:

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

Operators Overloading in C++

U kunt de meeste ingebouwde operators in C++ herdefiniëren of overloaden. Daarmee kan een programmeur operators gebruiken met door de gebruiker gedefinieerde typen.

Overloaded operators zijn functies met speciale namen: het trefwoord "operator" gevolgd door het symbool voor de operator die gedefinieerd wordt. Als elke andere functie, heeft een overloaded operator een return type en een parameterlijst.

 Box operator+(const Box&); 

declareren de opteloperator die gebruikt kan worden om te add twee Box objecten en retourneert het finale Box object. Meeste overloaded operators kunnen gedefinieerd worden als gewone non-member functies of als class member functies. In het geval we de bovenstaande functie definiëren als non-member functie van een klasse, dan zouden we twee argumenten moeten doorgeven voor elke operand als volgt:

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

Hier volgt het voorbeeld om het concept van operator overloading te tonen met een member functie. Hier wordt een object als argument doorgegeven wiens eigenschappen zullen worden benaderd met dit object, het object dat deze operator aanroept kan benaderd worden met 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 om twee Box objecten op te tellen.
  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; // Lengte van een box
  double breadth; // Breedte van een box
  double height; // Hoogte van een box
};
// Hoofdfunctie voor het programma
int main() {
  Box Box1; // Declareer Box1 van type Box
  Box Box2; // Declareer Box2 van type Box
  Box Box3; // Declareer Box3 van type Box
  double volume = 0.0; // Sla de volume van een box hier op
  // box 1 specificatie
  Box1.setLength(6.0);
  Box1.setBreadth(7.0);
  Box1.setHeight(5.0);
  // box 2 specificatie
  Box2.setLength(12.0);
  Box2.setBreadth(13.0);
  Box2.setHeight(10.0);
  // volume van box 1
  volume = Box1.getVolume();
  cout << "Volume of Box1 : " << volume <<endl;
  // volume van box 2
  volume = Box2.getVolume();
  cout << "Volume of Box2 : " << volume <<endl;
  // Tel twee objecten op als volgt:
  Box3 = Box1 + Box2;
  // volume van box 3
  volume = Box3.getVolume();
  cout << "Volume of Box3 : " << volume <<endl;
  return 0;
} 

Wanneer de bovenstaande code gecompileerd en uitgevoerd wordt, produceert het het volgende resultaat:

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

Overloadable/Niet-overloadable Operators

Hier volgt de lijst van operators die overloaded kunnen worden:

Hier volgt de lijst van operators die niet overloaded kunnen worden:

Operator Overloading Voorbeelden

Hier zijn diverse operator overloading voorbeelden om u te helpen het concept te begrijpen.