Sobrecarga de C ++ (operador y función)
C ++ le permite especificar más de una definición para un function nombre o un operator en el mismo ámbito, que se llama function overloading y operator overloading 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, obviamente, una definición (implementación) diferente.
Cuando llamas a un sobrecargado function o operator, 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 u operador con los tipos de parámetros especificados en las definiciones. El proceso de seleccionar la función u operador sobrecargado más apropiado se llamaoverload resolution.
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 declaraciones de funciones que difieran solo por el tipo de retorno.
A continuación se muestra el ejemplo donde la misma función print() se está utilizando para imprimir diferentes tipos de datos -
#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 se compila y ejecuta el código anterior, 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 retorno y una lista de parámetros.
Box operator+(const Box&);declara el operador de suma que se puede utilizar para adddos objetos Box y devuelve el objeto Box final. La mayoría de los operadores sobrecargados pueden definirse como funciones no miembros ordinarias o funciones miembro de clase. En caso de que definamos la función anterior como una función no miembro de una clase, tendríamos que pasar dos argumentos para cada operando de la siguiente manera:
Box operator+(const Box&, const Box&);A continuación se muestra el ejemplo para mostrar el concepto de operador sobrecarga utilizando 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 usandothis operador como se explica a continuación -
#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 se compila y ejecuta el código anterior, produce el siguiente resultado:
Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400Operadores que se pueden sobrecargar / no sobrecargar
A continuación se muestra la lista de operadores que se pueden sobrecargar:
| + | - | * | / | % | ^ |
| Y | | | ~ | ! | , | = |
| < | > | <= | > = | ++ | - |
| << | >> | == | ! = | && | || |
| + = | - = | / = | % = | ^ = | & = |
| | = | * = | << = | >> = | [] | () |
| -> | -> * | nuevo | nuevo [] | Eliminar | Eliminar [] |
A continuación se muestra la lista de operadores, que no se pueden sobrecargar:
| :: | . * | . | ?: |
Ejemplos de sobrecarga del operador
A continuación, se muestran varios ejemplos de sobrecarga de operadores para ayudarlo a comprender el concepto.