c++中的operator的用法

operator有两种用法

 一种是operator overloading（操作符重载）

一种是operator casting（操作隐式转换)

C++可以通过operator实现重载操作符，格式如下：类型T operator 操作符 ()

C++可以通过operator实现重载隐式转换，格式如下： operator T ()

一、操作符重载

1. （）运算符重载

在C++中，operator()是一种函数调用运算符重载。通过重载operator()运算符，你可以使一个对象的实例就像一个函数一样被调用。这对于创建可调用对象（函数对象）非常有用，可以像函数一样使用它们。

以下是一个示例，展示了如何在C++中使用operator()：

#include class MyFunctionObject {
public:
    int operator()(int a, int b) {
        return a + b;
    }
};
int main() {
    MyFunctionObject adder;
    int result = adder(5, 3); // 调用MyFunctionObject实例就像调用函数一样
    std::cout << "Result: " << result << std::endl;
    return 0;
}

在上面的示例中，我们创建了一个名为MyFunctionObject的类，该类重载了operator()运算符，使其能够接受两个整数参数并返回它们的和。然后，在main函数中，我们创建了一个MyFunctionObject的实例adder，并使用adder(5, 3)的方式来调用它，就像调用一个普通的函数一样。

你还可以重载operator()运算符来接受不同类型和数量的参数，以满足你的特定需求。这使你能够创建可调用对象，用于各种不同的情况，例如函数对象、函数指针和函数回调。

2. + 运算符重载

在C++中，operator+是加法运算符的重载形式，它允许你为自定义的类或类型定义加法操作。你可以通过重载operator+来指定两个对象如何相加，以及返回的结果类型。

以下是一个示例，展示了如何在C++中使用operator+：

#include class ComplexNumber {
public:
    ComplexNumber(double real, double imag) : realPart(real), imaginaryPart(imag) {}
    // 重载加法运算符
    ComplexNumber operator+(const ComplexNumber& other) {
        double realSum = realPart + other.realPart;
        double imagSum = imaginaryPart + other.imaginaryPart;
        return ComplexNumber(realSum, imagSum);
    }
    // 获取实部和虚部的值
    double getReal() const { return realPart; }
    double getImaginary() const { return imaginaryPart; }
private:
    double realPart;
    double imaginaryPart;
};
int main() {
    ComplexNumber a(3.0, 4.0);
    ComplexNumber b(1.0, 2.0);
    ComplexNumber c = a + b; // 使用重载的加法运算符，等价于a.operator+(b)
    std::cout << "a + b = " << c.getReal() << " + " << c.getImaginary() << "i" << std::endl;
    return 0;
}

在上面的示例中，我们定义了一个名为ComplexNumber的类，表示复数。我们重载了operator+，使它能够执行复数的加法运算。在main函数中，我们创建了两个ComplexNumber对象a和b，然后使用a + b来执行加法操作，结果保存在c中，并最终打印出了结果。

你可以根据你的需求，重载不同的运算符来定义自定义类型之间的操作。这允许你以更自然的方式使用自定义类，就像使用内置类型一样。

二、操作隐式转换

在C++中，操作符重载（operator overloading）允许您为您自定义的类创建操作符的特定行为。操作符可以进行隐式类型转换，但要小心使用，以避免引起混淆或错误。

隐式类型转换允许将一个类型自动转换为另一个类型，以便操作符能够使用。在操作符重载中，通常使用构造函数和转换运算符来实现隐式类型转换。

以下是一些示例，演示了如何在C++中使用操作符重载和隐式类型转换：

#include class MyNumber {
public:
    MyNumber(int value) : number(value) {}
    // 操作符重载，使得两个 MyNumber 对象可以相加
    MyNumber operator+(const MyNumber& other) {
        return MyNumber(this->number + other.number);
    }
    // 隐式类型转换：将 MyNumber 转换为 int
    operator int() const{
        return number;
    }
private:
    int number;
};
int main() {
    MyNumber num1(5);
    MyNumber num2(10);
    int result = num1 + num2; // 隐式类型转换，MyNumber 被转换为 int
    std::cout << "Result: " << result << std::endl;
    return 0;
}

在上面的示例中，我们定义了一个名为 MyNumber 的自定义类，它包含一个整数成员变量 number。我们实现了 operator+ 运算符的重载，以便可以将两个 MyNumber 对象相加。此外，我们还实现了一个隐式类型转换运算符，将 MyNumber 对象转换为整数。这使得我们可以将 MyNumber 对象与整数相加，而C++会自动执行必要的类型转换。

需要注意的是，const是限制符，表示在该函数内，不会改变数据成员的值。（明确指定const，避免后期维护或重构时，出现错误）。