定义运算符重载的关键字是什么

C++中定义运算符重载的关键字是 `operator`。使用 `operator` 关键字，可以将运算符重载为类的成员函数或全局函数。运算符重载的语法格式为：

- 成员函数的格式为：`返回类型 operator 运算符(参数列表)`，其中返回类型就是运算符操作的结果类型。
- 全局函数的格式为：`返回类型 operator 运算符(参数列表)`，其中返回类型就是运算符操作的结果类型。

需要注意的是，运算符重载函数必须至少有一个参数，因为运算符本身就是一个二元操作符。此外，部分运算符 (如赋值运算符 `=`) 也可以重载为类成员函数，但是必须以类成员函数的形式进行重载。

相关问题

运算符重载c++定义和代码

运算符重载是C++中的一种特性，它允许我们对已有的运算符进行重新定义，以便适应自定义类型的操作。通过运算符重载，我们可以为自定义类添加与其他对象的相加、相减、相乘等操作。

下面是运算符重载的定义和示例代码：

定义：
1. 运算符重载使用特殊的函数名和语法来定义。函数名以`operator`关键字开始，后面跟着要重载的运算符。
2. 运算符重载函数可以作为类的成员函数或全局函数进行定义。
3. 运算符重载函数必须指定参数和返回类型，以及如何执行相应的操作。

示例代码：

class MyNumber {
private:
    int value;

public:
    MyNumber(int num) : value(num) {}

    // 运算符+的重载
    MyNumber operator+(const MyNumber& other) {
        int result = this->value + other.value;
        return MyNumber(result);
    }

    // 运算符<<的重载（全局函数）
    friend std::ostream& operator<<(std::ostream& os, const MyNumber& obj);
};

// 运算符<<的重载（全局函数）
std::ostream& operator<<(std::ostream& os, const MyNumber& obj) {
    os << obj.value;
    return os;
}

使用运算符重载的示例代码：

MyNumber num1(5);
MyNumber num2(10);

MyNumber sum = num1 + num2;  // 使用重载的+运算符进行相加操作

std::cout << "Sum: " << sum << std::endl;  // 使用重载的<<运算符进行输出操作

在上述示例中，我们定义了一个名为`MyNumber`的类，并重载了运算符`+`和`<<`。重载的`+`运算符用于对两个`MyNumber`对象进行相加操作，返回一个新的`MyNumber`对象。重载的`<<`运算符用于在输出流中输出`MyNumber`对象的值。

需要注意的是，不是所有的运算符都可以被重载，例如赋值运算符`=、`.`和`::`等不能被重载。此外，运算符重载也需要遵循一些约定和限制，例如保持运算符的原有语义，避免过度使用运算符重载等。

运算符重载是C++中强大且灵活的特性，可以使我们的代码更加直观和易读。但在使用时需要慎重考虑，并确保符合语义和预期行为。

复数类定义及运算符重载

复数类是一种表示复数的数据类型，由实部和虚部组成。在C++中，我们可以定义复数类，并重载运算符，实现复数的基本运算。

下面是一个简单的复数类定义及运算符重载的示例：

class Complex {
private:
    double real;
    double imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    Complex operator+(const Complex& c) {
        return Complex(real + c.real, imag + c.imag);
    }

    Complex operator-(const Complex& c) {
        return Complex(real - c.real, imag - c.imag);
    }

    Complex operator*(const Complex& c) {
        return Complex(real * c.real - imag * c.imag, real * c.imag + imag * c.real);
    }

    Complex operator/(const Complex& c) {
        double denominator = c.real * c.real + c.imag * c.imag;
        return Complex((real * c.real + imag * c.imag) / denominator, (imag * c.real - real * c.imag) / denominator);
    }

    friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
        os << c.real << "+" << c.imag << "i";
        return os;
    }
};

这个示例中，我们定义了一个`Complex`类，包含实部和虚部两个私有成员变量。我们通过构造函数来初始化这两个成员变量。

接着，我们重载了加、减、乘、除等运算符，实现了复数的基本运算。我们还通过`friend`关键字定义了一个友元函数`operator<<`，用于输出复数对象。

使用这个复数类，我们可以进行如下的运算：

Complex a(2.0, 3.0);
Complex b(4.0, -1.0);

Complex c = a + b;
Complex d = a - b;
Complex e = a * b;
Complex f = a / b;

std::cout << "a = " << a << std::endl;
std::cout << "b = " << b << std::endl;
std::cout << "a + b = " << c << std::endl;
std::cout << "a - b = " << d << std::endl;
std::cout << "a * b = " << e << std::endl;
std::cout << "a / b = " << f << std::endl;

输出结果如下：

a = 2+3i
b = 4-1i
a + b = 6+2i
a - b = -2+4i
a * b = 11+10i
a / b = 0.4+0.7i

这个示例只是一个简单的复数类定义及运算符重载的示例，实际上，我们还可以定义更多的运算符，比如逻辑运算符、比较运算符等，以实现更多的功能。