C++不允许重载运算符的底层原理

C++运算符重载的基本概念

在深入探讨 C++ 不允许重载某些运算符的底层原理之前，我们先来回顾一下运算符重载的基本概念。运算符重载是 C++ 的一个重要特性，它允许程序员为自定义类型（如类和结构体）定义运算符的行为。通过运算符重载，我们可以使自定义类型像内置类型一样使用常见的运算符，提高代码的可读性和表达力。

例如，对于一个简单的 Point 类表示二维平面上的点，我们可以重载 + 运算符来实现两个点的相加：

#include <iostream>

class Point {
public:
    int x;
    int y;

    Point(int a, int b) : x(a), y(b) {}

    // 重载 + 运算符
    Point operator+(const Point& other) const {
        return Point(x + other.x, y + other.y);
    }
};

int main() {
    Point p1(1, 2);
    Point p2(3, 4);
    Point result = p1 + p2;
    std::cout << "Result: (" << result.x << ", " << result.y << ")" << std::endl;
    return 0;
}

在上述代码中，我们为 Point 类重载了 + 运算符，使得可以像操作内置类型一样使用 + 运算符来对两个 Point 对象进行相加操作。

C++ 不允许重载的运算符

虽然 C++ 允许对许多运算符进行重载，但也有一些运算符是不允许重载的，这些运算符包括：

作用域解析运算符 ::
成员选择运算符 .
成员指针选择运算符 .*
三元条件运算符 ? :
长度运算符 sizeof

接下来我们深入探讨这些运算符不允许重载的底层原理。

作用域解析运算符 `::`

作用域解析运算符 :: 主要用于指定命名空间、类或结构体的作用域，以访问特定作用域内的成员。它的主要功能是在复杂的命名空间和类层次结构中明确地定位标识符。

例如，在下面的代码中，我们通过 :: 来访问全局变量 globalVar：

#include <iostream>

int globalVar = 10;

void func() {
    int globalVar = 20;
    std::cout << "Local globalVar: " << globalVar << std::endl;
    std::cout << "Global globalVar: " << ::globalVar << std::endl;
}

int main() {
    func();
    return 0;
}

如果允许重载 :: 运算符，将会导致作用域的语义变得模糊不清。作用域解析是编译器在编译阶段进行名称查找和绑定的重要机制，它依赖于固定的语法规则。重载 :: 运算符会破坏这种固定性，使得编译器无法按照现有的规则准确地解析作用域。例如，假设 :: 可以重载，那么在 a::b 这样的表达式中，编译器将无法确定 :: 是原本的作用域解析含义，还是用户自定义的重载含义，这将给编译过程带来极大的复杂性和不确定性。

成员选择运算符 `.`

成员选择运算符 . 用于访问对象的成员（数据成员或成员函数）。它是紧密绑定在对象和其成员之间的一种语法结构。

考虑以下简单的类：

class MyClass {
public:
    int value;
    void printValue() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.value = 42;
    obj.printValue();
    return 0;
}

在上述代码中，通过 . 运算符我们可以方便地访问 obj 对象的 value 数据成员和 printValue 成员函数。如果允许重载 . 运算符，会破坏对象成员访问的直接性和直观性。. 运算符的语义是明确且固定的，它直接连接对象和其成员。重载它将使代码的可读性和可维护性大大降低，因为其他程序员看到 obj.someMember 这样的表达式时，无法再确定它是普通的成员访问，还是被重载后的特殊含义。而且从编译器实现的角度来看，成员访问是基于对象的内存布局和偏移量进行的，重载 . 运算符将打破这种基于内存结构的直接访问机制，增加编译器实现的难度。

成员指针选择运算符 `.*`

成员指针选择运算符 .* 用于通过对象指针访问对象的成员，它与成员选择运算符 . 密切相关，但适用于指针的情况。

例如：

class MyClass {
public:
    int value;
    void printValue() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    MyClass* objPtr = new MyClass();
    objPtr->value = 42;
    (objPtr->*(&MyClass::printValue))();
    delete objPtr;
    return 0;
}

这里 (objPtr->*(&MyClass::printValue))() 通过成员指针选择运算符调用了 printValue 函数。不允许重载 .* 运算符的原因与不允许重载 . 运算符类似。它的语义也是固定且基于对象内存布局和指针操作的。重载 .* 运算符会破坏这种基于指针的成员访问的确定性和直观性，使得代码变得难以理解和维护。编译器在处理 .* 运算符时，依赖于特定的对象指针解引用和成员偏移计算规则，重载将打乱这些规则，增加编译的复杂性。

三元条件运算符 `? :`

三元条件运算符 ? : 是一个简洁的条件表达式，它的语法为 condition? expression1 : expression2。当 condition 为真时，返回 expression1 的值，否则返回 expression2 的值。

例如：

#include <iostream>

int main() {
    int a = 10;
    int b = 20;
    int result = a > b? a : b;
    std::cout << "Result: " << result << std::endl;
    return 0;
}

不允许重载 ? : 运算符主要是出于保持其简洁性和确定性的考虑。? : 运算符的语法和语义是 C++ 语言中相对特殊且固定的。它在编译时的处理方式与普通的二元或一元运算符不同，它涉及到条件分支和值的选择逻辑。如果允许重载，将会破坏这种简洁的条件求值语义，使得代码变得复杂且难以预测。而且从编译器优化的角度来看，? : 运算符的现有实现已经经过了精心优化，重载它可能会干扰编译器对条件表达式的优化策略，影响代码的执行效率。

长度运算符 `sizeof`

sizeof 运算符用于获取数据类型或变量所占用的字节数。例如：

#include <iostream>

int main() {
    int num;
    std::cout << "Size of int: " << sizeof(int) << " bytes" << std::endl;
    std::cout << "Size of num: " << sizeof(num) << " bytes" << std::endl;
    return 0;
}

sizeof 运算符不允许重载是因为它的结果是在编译时确定的，它依赖于编译器对数据类型的内部表示和内存布局的知识。重载 sizeof 运算符将违背这种编译时求值的特性，因为重载意味着在运行时可能会有不同的行为，这与 sizeof 的编译时特性相冲突。编译器在编译阶段根据已知的数据类型信息来计算 sizeof 的结果，如果允许重载，编译器将无法在编译时准确地确定 sizeof 的值，从而破坏了整个编译过程的确定性和稳定性。

总结不允许重载运算符的共性

综合以上对不允许重载的运算符的分析，我们可以总结出一些共性。这些运算符大多具有以下特点：

语义固定且明确：它们的语义在 C++ 语言中是非常固定和基础的，重载会破坏这些运算符原本清晰的语义，导致代码的可读性和可维护性下降。
与编译机制紧密相关：许多不允许重载的运算符依赖于编译器特定的编译机制，如作用域解析、成员访问、编译时求值等。重载这些运算符将干扰编译器的正常工作流程，增加编译的复杂性和不确定性。
保持语言的简洁性和稳定性：不允许重载这些运算符有助于保持 C++ 语言的简洁性和稳定性，避免引入过多复杂和难以理解的行为，使得代码在不同编译器和环境下具有一致的表现。

通过深入理解这些不允许重载运算符的底层原理，我们能更好地掌握 C++ 语言的特性，编写出更健壮、可读的代码。在实际编程中，虽然不能重载这些运算符，但我们可以通过其他方式来实现类似的功能，同时要始终遵循 C++ 语言的设计原则和规范。

C++不允许重载运算符的底层原理

C++运算符重载的基本概念

C++ 不允许重载的运算符

作用域解析运算符 ::

成员选择运算符 .

成员指针选择运算符 .*