Sobrecarga de C++ (operador y función)

C++ le permite especificar más de una definición para una función nombre o un operador en el mismo ámbito, lo que se denomina sobrecarga de funciones y sobrecarga de operadores respectivamente.

Una declaración sobrecargada es una declaración que se declara con el mismo nombre que una declaración declarada previamente en el mismo ámbito, excepto que ambas declaraciones tienen argumentos diferentes y una definición (implementación) obviamente diferente.

Cuando llamas a una función sobrecargada o operador , el compilador determina la definición más apropiada para usar comparando los tipos de argumentos que ha usado para llamar a la función o al operador con los tipos de parámetros especificados en las definiciones. El proceso de selección de la función u operador sobrecargado más apropiado se denomina resolución de sobrecarga .

Sobrecarga de funciones en C++

Puede tener varias definiciones para el mismo nombre de función en el mismo ámbito. La definición de la función debe diferir entre sí por los tipos y/o el número de argumentos en la lista de argumentos. No puede sobrecargar las declaraciones de funciones que difieren solo por el tipo de retorno.

El siguiente es el ejemplo donde la misma función print() se está utilizando para imprimir diferentes tipos de datos −

Demostración en vivo

#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;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

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

Sobrecarga de operadores en C++

Puede redefinir o sobrecargar la mayoría de los operadores integrados disponibles en C++. Por lo tanto, un programador también puede usar operadores con tipos definidos por el usuario.

Los operadores sobrecargados son funciones con nombres especiales:la palabra clave "operador" seguida del símbolo del operador que se está definiendo. Como cualquier otra función, un operador sobrecargado tiene un tipo de devolución y una lista de parámetros.

Box operator+(const Box&);

declara el operador de suma que se puede usar para agregar dos objetos Box y devuelve el objeto Box final. La mayoría de los operadores sobrecargados pueden definirse como funciones ordinarias que no son miembros o como funciones miembro de clase. En caso de que definamos la función anterior como una función no miembro de una clase, entonces tendríamos que pasar dos argumentos para cada operando de la siguiente manera −

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

El siguiente es el ejemplo para mostrar el concepto de sobrecarga de operadores usando una función miembro. Aquí se pasa un objeto como argumento a cuyas propiedades se accederá usando este objeto, se puede acceder al objeto que llamará a este operador usando this operador como se explica a continuación −

Demostración en vivo

#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;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

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

Operadores sobrecargables/no sobrecargables

A continuación se muestra la lista de operadores que se pueden sobrecargar −

+	-	*	/	%	^
&	|	~	!	,	=
<	>	<=	>=	++	--
<	>>	==	!=	&&	||
+=	-=	/=	%=	^=	&=
|=	*=	<<=	>>=	[]	()
->	->*	nuevo	nuevo []	eliminar	eliminar []

A continuación se muestra la lista de operadores, que no se pueden sobrecargar −

::

.*

.

?:

Ejemplos de sobrecarga de operadores

Aquí hay varios ejemplos de sobrecarga de operadores para ayudarlo a comprender el concepto.

Sr.No	Operadores y ejemplo
1	Sobrecarga de operadores unarios
2	Sobrecarga de operadores binarios
3	Sobrecarga de operadores relacionales
4	Sobrecarga de operadores de entrada/salida
5	++ y -- Sobrecarga de operadores
6	Sobrecarga de operadores de asignación
7	Llamada de función () Sobrecarga del operador
8	Subíndice [] Sobrecarga de operadores
9	Operador de acceso de miembros de clase -> Sobrecarga