运算符重载与类型转换

运算符重载是C++面向对象编程中的一个强大特性，它允许我们为用户定义的类型赋予运算符特殊的含义。通过明智地使用运算符重载，我们可以让程序更加易于编写和阅读。

考虑一个简单的例子：如果我们有一个表示复数的类，定义了加法运算符重载，我们就可以像处理内置类型一样自然地编写代码：

|
Complex a, b, c;
c = a + b;  // 直观的复数加法表达式

相比之下，如果没有运算符重载，我们可能需要编写更冗长的代码：

|
c = add(a, b);  // 不够直观的函数调用方式

运算符重载的基本原理

重载运算符的本质

重载运算符实际上是具有特殊名称的函数：关键字operator后跟要定义的运算符符号。与任何其他函数一样，重载运算符函数具有返回类型、参数列表和函数体。

重载运算符函数的参数数量与运算符的操作数数量相对应。一元运算符有一个参数，二元运算符有两个参数。对于二元运算符，左操作数传递给第一个参数，右操作数传递给第二个参数。

当运算符函数是类的成员函数时，第一个操作数会绑定到隐式的this指针。因此，成员运算符函数的显式参数数量比运算符的操作数数量少一个。

重载的限制和规则

运算符函数必须要么是某个类的成员，要么至少有一个参数是类类型。这个限制确保我们不能改变运算符应用于内置类型时的含义。

|
// 错误：不能重新定义内置类型的运算符
int operator+(int, int);

我们只能重载已有的运算符，不能创造新的运算符符号。例如，我们不能定义operator**来提供乘方运算。

重载运算符保持其原有的优先级和结合性。无论操作数类型如何，表达式x == y + z总是等价于x == (y + z)。

调用重载运算符的方式

通常，我们通过在适当类型的参数上使用运算符来间接调用重载运算符函数。但是，我们也可以像调用普通函数一样直接调用重载运算符函数：

|
// 等价的调用方式
data1 + data2;                    // 正常的表达式
operator+(data1, data2);          // 等价的函数调用
 
// 对于成员运算符函数
data1 += data2;                   // 基于表达式的调用
data1.operator+=(data2);          // 等价的成员函数调用

设计指导原则

在设计类时，我们应该首先考虑类需要提供哪些操作，然后才考虑是否将某个操作定义为重载运算符。那些与运算符有逻辑映射关系的操作是定义为重载运算符的好候选。

如果类执行输入输出操作，应该定义位移运算符以与内置类型的输入输出保持一致。如果类有相等性测试操作，应该定义operator==。如果类有operator==，通常也应该有operator!=。如果类有单一的自然排序操作，应该定义operator<。

重载运算符的返回类型通常应该与内置版本的返回类型兼容：逻辑和关系运算符应该返回bool，算术运算符应该返回类类型的值，赋值和复合赋值运算符应该返回对左操作数的引用。

输入输出运算符的重载

输出运算符的设计

输出运算符的第一个参数通常是对非常量ostream对象的引用。ostream是非常量的，因为向流写入会改变其状态。参数是引用，因为我们无法拷贝ostream对象。

第二个参数通常应该是对要打印的类类型的常量引用。参数是引用以避免拷贝实参，它可以是常量，因为打印对象通常不会改变该对象。

为了与其他输出运算符保持一致，operator<<通常返回其ostream参数。

让我们以一个表示学生信息的类为例：

|
class Student {
    friend std::ostream& operator<<(std::ostream& os, const Student& stu);
public:
    Student(const std::string& name, int age, double score)
        : name_(name), age_(age), 

输出运算符通常应该进行最少的格式化，它们不应该打印换行符。这样的设计让用户能够控制输出的细节。

输入运算符的实现

输入运算符的第一个参数是对要读取的流的引用，第二个参数是对要读入的非常量对象的引用。运算符通常返回给定流的引用。第二个参数必须是非常量的，因为输入运算符的目的是读取数据到这个对象中。

|
std::istream& operator>>(std::istream& is, Student& stu) {
    std::string name;
    int age;
    double score;
    
    is >> name >> age >> score;
    
    if (is) {  // 检查输入是否成功
        stu.name_ = name;
        stu.age_ =

输入运算符必须处理输入可能失败的情况，而输出运算符通常不需要考虑这个问题。输入运算符应该决定在遇到错误时做什么。

输入输出运算符必须是非成员函数

输入输出运算符必须是普通的非成员函数，不能是类的成员函数。如果它们是成员函数，那么左操作数必须是我们类的对象。这样就会导致像student << cout这样的奇怪用法。

由于输入输出运算符通常需要读写类的非公有数据成员，因此它们通常必须声明为友元。

算术和关系运算符

算术运算符的实现

通常，我们将算术和关系运算符定义为非成员函数，以便允许左右操作数进行转换。这些运算符不需要改变任一操作数的状态，因此参数通常是对常量的引用。 算术运算符通常生成一个新值，该值是对其两个操作数进行计算的结果。这个值不同于任一操作数，在局部变量中计算。操作返回该局部变量的副本作为结果。 定义了算术运算符的类通常也定义相应的复合赋值运算符。当一个类同时有这两种运算符时，通常用复合赋值来实现算术运算符会更高效：

|
class Vector2D {
public:
    Vector2D(double x = 0, double y = 0) : x_(x), y_(y) {}
    
    Vector2D& operator+=(const Vector2D& rhs) {
        x_ += rhs.x_;
        y_ += rhs.y_;
        return *this;

相等性运算符的设计

C++中的类通常定义相等运算符来测试两个对象是否等价。通常，它们比较每个数据成员，只有当所有对应成员都相等时，才认为两个对象相等。

|
bool operator==(const Vector2D& lhs, const Vector2D& rhs) {
    return lhs.getX() == rhs.getX() && lhs.getY() == rhs.getY();
}
 
bool operator!=(const Vector2D& lhs, const Vector2D&

这些函数的设计体现了几个重要原则：如果一个类有判断两个对象是否相等的操作，它应该把函数定义成operator==而不是一个普通的命名函数。相等运算符应该具有传递性，即如果a == b和b == c都为真，那么a == c也应该为真。

如果类定义了operator==，它也应该定义operator!=。相等或不等运算符中的一个应该把工作委托给另外一个。

关系运算符的考虑

对于相等运算符已定义的类，通常也会考虑定义关系运算符。特别是，由于关联容器和一些算法使用小于运算符，定义operator<可能会很有用。

但是，对于我们的Vector2D类，可能不存在一种明显的小于关系。我们可能按长度比较向量，也可能按照字典序比较坐标，或者按照角度比较。由于没有单一的逻辑定义，对于这样的类最好不要定义<运算符。

如果存在唯一一种逻辑可靠的小于关系，则类应该定义<运算符。如果类也有==，则当且仅当<的定义和==产生一致的结果时才定义<。

赋值运算符的扩展

额外的赋值运算符

除了拷贝赋值和移动赋值运算符之外，类还可以定义其他赋值运算符来使用别的类型作为右操作数。

例如，我们可以为之前实现的动态数组类添加一个接受花括号列表的赋值运算符：

|
class IntArray {
public:
    IntArray& operator=(std::initializer_list<int> il) {
        // 分配新内存并拷贝列表中的元素
        auto data = allocate_and_copy(il.begin(), il.end());
        free_memory();  // 销毁当前对象中的元素并释放内存
        elements = data.first;
        first_free = cap = data.second;
        return

与拷贝赋值和移动赋值运算符一样，其他重载的赋值运算符也必须定义为成员函数，无论参数类型如何。

复合赋值运算符

复合赋值运算符不要求必须是类的成员，但我们通常倾向于把包括复合赋值在内的所有赋值运算都定义在类的内部。为了与内置类型的复合赋值保持一致，这些运算符应该返回其左操作数的引用：

|
Vector2D& Vector2D::operator+=(const Vector2D& rhs) {
    x_ += rhs.x_;
    y_ += rhs.y_;
    return *this;
}

下标运算符

表示容器的类通常可以通过元素在容器中的位置来访问元素，这些类一般会定义下标运算符operator[]。

下标运算符必须是成员函数。为了与下标的普通含义保持一致，下标运算符通常返回所访问元素的引用。通过返回引用，下标可以出现在赋值运算符的任意一侧。因此，最好同时定义下标运算符的常量和非常量版本：

|
class StringArray {
public:
    std::string& operator[](std::size_t n) {
        return elements[n];
    }
    
    const std::string& operator[](std::size_t n) const {
        return elements[n];
    }
    
private:

当我们在非常量对象上调用下标运算符时，得到普通引用；当在常量对象上调用时，得到常量引用，从而不能给返回的对象赋值。

递增和递减运算符

递增和递减运算符在迭代器类中最常实现，这些运算符使类可以在元素序列中移动。虽然没有语言要求这些运算符必须是类的成员，但由于它们改变操作对象的状态，我们的偏好是将它们设定为成员。

前置版本的定义

为了与内置运算符保持一致，前置运算符应该返回递增或递减后对象的引用。

|
class Counter {
public:
    Counter(int start = 0) : value_(start) {}
    
    // 前置运算符
    Counter& operator++() {
        ++value_;
        return *this;
    }
    
    Counter& operator--() {
        --value_;
        return *this

后置版本的区分

前置和后置版本使用相同的符号，这意味着重载版本具有相同的名称和相同数量及类型的操作数。为了解决这个问题，后置版本接受一个额外的（不被使用的）int类型参数。当我们使用后置运算符时，编译器为这个参数提供一个值为0的实参：

|
// 后置运算符
Counter Counter::operator++(int) {
    Counter ret = *this;  // 保存当前值
    ++*this;              // 使用前置版本完成实际工作
    return ret;           // 返回保存的状态
}
 
Counter Counter::operator--(int) {
    Counter ret = *this;  // 保存当前值
    --*this;

为了与内置运算符保持一致，后置运算符应该返回对象的原值（递增或递减之前的值），返回的形式是一个值而不是引用。

成员访问运算符

解引用运算符（*）和箭头运算符（->）在表示迭代器的类和智能指针类中经常用到。

|
class SmartPointer {
public:
    explicit SmartPointer(std::string* ptr) : ptr_(ptr) {}
    
    std::string& operator*() const {
        return *ptr_;
    }
    
    std::string* operator->() const {
        return

箭头运算符必须是类的成员。解引用运算符不要求是类的成员，但通常应该是成员。

箭头运算符永远不会丢失它成员访问这个基本含义。当我们重载箭头时，我们改变的是箭头从哪个对象当中获取成员，而不能改变箭头获取成员这一事实。

函数调用运算符

如果类重载了函数调用运算符，我们就能像使用函数一样使用该类的对象。因为这样的类同时也能存储状态，所以与普通函数相比它们更加灵活。

|
class Multiplier {
public:
    Multiplier(int factor) : factor_(factor) {}
    
    int operator()(int value) const {
        return value * factor_;
    }
    
private:
    int factor_;
};
 
// 使用示例
Multiplier doubler(2);
int

函数调用运算符必须是成员函数。一个类可以定义多个不同版本的调用运算符，相互之间应该在参数数量或类型上有所区别。

定义了调用运算符的类的对象称为函数对象。这样的对象"行为像函数"一样，因为我们可以调用它们。

函数对象与状态

与任何其他类一样，函数对象类除了operator()之外还可以包含其他成员。函数对象类通常含有一些数据成员，这些成员被用于定制调用运算符中的操作。

|
class Accumulator {
public:
    Accumulator() : sum_(0) {}
    
    void operator()(int value) {
        sum_ += value;
    }
    
    int getSum() const { return sum_; }
    
private:
    int sum_;
};
 
// 使用示例
Accumulator acc;

Lambda表达式与函数对象

当我们编写lambda表达式时，编译器将该表达式翻译成一个未命名类的未命名对象。从lambda生成的类含有一个重载的函数调用运算符。

例如，以下lambda表达式：

|
[](const std::string& a, const std::string& b) {
    return a.size() < b.size();
}

行为类似于下面这个类的一个未命名对象：

|
class StringSizeComparator {
public:
    bool operator()(const std::string& a, const std::string& b) const {
        return a.size() < b.size();
    }
};

默认情况下，从lambda生成的类都包含一个对应该lambda的默认构造函数、赋值运算符以及默认析构函数。它是否包含默认的拷贝/移动构造函数则依常规规则而定。

类型转换运算符

转换运算符的定义

转换运算符是类的一种特殊成员函数，它负责将一个类类型的值转换为其他类型。转换函数一般形式如下：

|
operator type() const;

其中type表示某种类型。转换运算符可以面向任意类型（除了void之外）进行定义，只要该类型能作为函数的返回类型。因此，我们不允许转换为数组或者函数类型，但允许转换为指针或者引用类型。

转换函数必须是类的成员函数，它不能声明返回类型，形参列表也必须为空。转换函数通常应该是const的。

|
class Fraction {
public:
    Fraction(int num, int den = 1) : numerator_(num), denominator_(den) {}
    
    operator double() const {
        return static_cast<double>(numerator_) / denominator_;
    }
    
private:
    int numerator_;
    int denominator_;
};
 

显式转换运算符

类类型转换可能产生意外的结果。为了防止这种问题，新标准引入了显式转换运算符：

|
class Fraction {
public:
    explicit operator double() const {
        return static_cast<double>(numerator_) / denominator_;
    }
    
    // 其他成员...
};
 
Fraction f(3, 4);
double d1 = f;                        // 错误：隐式转换被禁止
double d2 = static_cast<double>(f);   // 正确：显式转换

存在一个例外，编译器会将显式的转换运算符用于条件部分。也就是说，当表达式被用作条件时，显式转换将被隐式地执行。

避免有歧义的转换

如果类中包含一个或多个转换，必须确保在类类型和目标类型之间只存在唯一一种转换方式。有两种情况可能产生多重转换路径。第一种情况是两个类相互提供转换，第二种情况是定义了多个转换规则，而这些转换涉及的类型本身可以通过其他转换联系在来。

|
// 通常不建议：相互转换的两个类
struct A {
    A() = default;
    A(const B&);        // 把B转换成A
    // 其他成员
};
 
struct B {
    operator A() const;  // 也是把B转换成A
    // 其他成员
};
 
A f(const A&);
B b;
A a 

为了解决这种二义性，我们必须显式地调用转换运算符或者转换构造函数。

练习

现在让我们通过一些简单的练习题来巩固本章学到的知识。每道题都涵盖了运算符重载的核心概念，请先尝试独立完成，然后再查看答案。

练习 1：输入输出运算符的实现

为下面的Point3D类实现输入输出运算符，要求输出格式为(x, y, z)。

|
class Point3D {
public:
    Point3D(double x = 0, double y = 0, double z = 0) 
        : x_(x), y_(y), z_(z) {}
    
    double getX() const { return x_; }
    double getY() const { return

|
#include <iostream>
using namespace std;
 
class Point3D {
    friend ostream& operator<<(ostream& os, const Point3D& p);
    friend istream& operator>>(istream& is, Point3D& p);
    
public:
    Point3D

练习 2：算术运算符的重载

为下面的Vector2D类实现加法运算符+和复合赋值运算符+=。

|
class Vector2D {
public:
    Vector2D(double x = 0, double y = 0) : x_(x), y_(y) {}
    double getX() const { return x_; }
    double getY() const { return y_; }
    
private:
    double x_, y_;
};

|
#include <iostream>
using namespace std;
 
class Vector2D {
public:
    Vector2D(double x = 0, double y = 0) : x_(x), y_(y) {}
    
    // 复合赋值运算符（成员函数）
    Vector2D& operator+=(const Vector2D& rhs) {
        x_ +=

练习 3：比较运算符的重载

为Vector2D类实现相等运算符==和不等运算符!=。

|
#include <iostream>
using namespace std;
 
class Vector2D {
public:
    Vector2D(double x = 0, double y = 0) : x_(x), y_(y) {}
    
    double getX() const { return x_; }
    double getY() const { return

练习 4：下标运算符的重载

为下面的SafeArray类实现下标运算符，要求进行边界检查。

|
class SafeArray {
public:
    SafeArray(size_t size);
    ~SafeArray();
    // 实现下标运算符
    
private:
    int* data_;
    size_t size_;
};

|
#include <iostream>
#include <stdexcept>
using namespace std;
 
class SafeArray {
public:
    SafeArray(size_t size) : size_(size) {
        data_ = new int[size_];
        for (size_t i = 0; i < size_; i++) {
            data_[i] = 0;

练习 5：综合应用——简单的复数类

实现一个简单的复数类Complex，支持加法、输出和相等比较。

|
#include <iostream>
using namespace std;
 
class Complex {
    friend ostream& operator<<(ostream& os, const Complex& c);
    
public:
    Complex(double real = 0, double imag = 0) : real_(real), imag_

输入输出运算符必须是友元函数，因为它们的左操作数是流对象，不是类的对象。输出运算符返回ostream引用以支持链式调用，输入运算符需要处理输入失败的情况。

复合赋值运算符（如+=）通常定义为成员函数，因为它需要修改左操作数。算术运算符（如+）通常定义为非成员函数，并使用复合赋值运算符来实现，这样代码更简洁且高效。

比较运算符通常定义为非成员函数。如果类定义了==，通常也应该定义!=。不等运算符可以通过调用相等运算符来实现，避免代码重复。

下标运算符必须是成员函数，通常需要提供const和非const两个版本。非const版本返回引用，允许修改元素；const版本返回const引用，只能读取。进行边界检查可以避免数组越界错误。

这个例子综合运用了多种运算符重载：

1. 输出运算符：友元函数，格式化输出复数
2. 复合赋值运算符：成员函数，修改对象状态
3. 算术运算符：非成员函数，使用复合赋值实现
4. 比较运算符：非成员函数，比较两个对象

这些运算符让复数类的使用更加自然和直观。