C++ Sobrecarga de operadores y sobrecarga de funciones

C++ Sobrecarga de funciones

En el mismo ámbito, se pueden declarar varias funciones con el mismo nombre que tienen funcionalidades similares, pero los parámetros formales (referidos a la cantidad, tipo o orden de los parámetros) de estas funciones con el mismo nombre deben ser diferentes. No se puede sobrecargar una función solo mediante la diferencia en el tipo de retorno.

En el siguiente ejemplo, se utilizan funciones con el mismo nombre. print() se utiliza para imprimir diferentes tipos de datos:

#include <iostream>
using namespace std;
　
class printData
{
　　　public:
　　　　　　void print(int i)
　　　　　　　　cout << "Los enteros son: " << i << endl;
　　　　　　}
　
　　　　　　void print(double f)
　　　　　　　　cout << "Los números de coma flotante son: " << f << endl;
　　　　　　}
　
　　　　　　void print(char c[])
　　　　　　　　cout << "La cadena es: " << c << endl;
　　　　　　}
};
　
int main(void)
{
　　　printData pd;
　
　　　//　Imprimir entero
　　　pd.print(5);
　　　//　Imprimir número de coma flotante
　　　pd.print(500.263);
　　　//　Imprimir cadena
　　　char c[] = "Hello C++";
　　　pd.print(c);
　
　　　return 0;
}

当上面的代码被编译和执行时，它会产生以下结果：

Los enteros son:　5
Los números de coma flotante son:　500.263
La cadena es: Hello C++

C++ sobreoperación de operadores

puedes sobrecargar la mayoría de los operadores en++ operadores integrados. De esta manera, puedes usar operadores personalizados para tipos de datos personalizados.

Los operadores sobrecargados son funciones con nombres especiales, compuestas por la palabra clave operator seguida del símbolo del operador que se va a sobrecargar. Al igual que otras funciones, los operadores sobrecargados tienen un tipo de retorno y una lista de parámetros.

Box operator+(const Box&);

Se declara el operador de suma para sumar dos objetos Box y devolver el objeto Box final. La mayoría de los operadores sobrecargados pueden definirse como funciones no miembro o como funciones miembro. Si definimos la función anterior como una función no miembro de la clase, necesitamos pasar dos parámetros para cada operación, como se muestra a continuación:

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

El siguiente ejemplo utiliza funciones miembro para ilustrar el concepto de sobrecarga de operadores. Aquí, el objeto se pasa como parámetro y se utilizan this operadores para acceder, como se muestra 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;
　　　　　　}
　　　　　　//　重载　+　运算符，用于将两个 Box 对象相加
　　　　　　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;　　　　　　//　长度
　　　　　　double breadth;　　　　　//　宽度
　　　　　　double height;　　　　　　//　高度
};
//　程序的主函数
int main( )
{
　　　Box Box1;　　　　　　　　　　　　　　　　//　声明 Box1，类型为 Box
　　　Box Box2;　　　　　　　　　　　　　　　　//　声明 Box2，类型为 Box
　　　Box Box3;　　　　　　　　　　　　　　　　//　声明 Box3，类型为 Box
　　　double volume = 0.0;　　　　　//　将体积存储在该变量中
　
　　　//　Box1　详述
　　　Box1.setLength(6.0);　
　　　Box1.setBreadth(7.0);　
　　　Box1.setHeight(5.0);
　
　　　//　Box2　详述
　　　Box2.setLength(12.0);　
　　　Box2.setBreadth(13.0);　
　　　Box2.setHeight(10.0);
　
　　　//　Box1　的体积
　　　volume = Box1.getVolume();
　　　cout << "Box1的体积：" << volume << endl;
　
　　　//　Box2　的体积
　　　volume = Box2.getVolume();
　　　cout << "Box2的体积：" << volume << endl;
　
　　　//　将两个对象相加，得到 Box3
　　　Box3　= Box1　+　Box2;
　
　　　//　Box3　的体积
　　　volume = Box3.getVolume();
　　　cout << "Box3的体积：" << volume << endl;
　
　　　return 0;
}

当上面的代码被编译和执行时，它会产生以下结果：

Box1的体积：　210
Box2的体积：　1560
Box3的体积：　5400

可重载运算符/不可重载运算符

以下是可重载的运算符列表：

以下是不可重载的运算符列表：

• .: Operador de acceso a miembro

• .*, ->*: Operador de acceso a puntero de miembro

• ::: Operador de ámbito

• sizeof: Operador de longitud

• ?:: Operador de condición

• #: Símbolo de preprocesamiento

Ejemplo de sobrecarga de operadores

A continuación, se proporcionan varios ejemplos de sobrecarga de operadores para ayudarlo a comprender mejor el concepto.