第 12 章笔记

运算符重载是指在 C++ 中基于 operator 关键字引入对运算符的重载。经过重载的运算符可以被视作函数，典型的结构(以减法为例)：

return Type + operator - + (parameter list)

• 不能重新发明运算，只能基于 C++ 的运算符进行重载
• 不能改变对应运算符的优先级和结合性
• 可以，但是不应该去改变运算符重载的意义（加法就是加法，不能用加法代表乘法）
• 重载的运算符与 bulit-in 运算符的 operand 应该在数量上一致
• 重载运算符中，其参数需要至少有一个是类类型（不能全是 built-in 类型）
• 除了 operator()，其他重载的运算符都不能设置默认参数

运算符重载可以以成员函数或非成员函数的方式来实现：

• 以成员函数进行重载时，通常以 *this 作为第一个 operand
• 注意 C++ 17 以后，== 与 ⇔ 并不遵循此例

// 非成员函数重载
Str operator+ (Str x, Str y)
{
    Str z;
    z.x = x.x + y.x;
    return z;
}
// 成员函数重载
Str operator+(Str rhs)
{
    Str z;
    //x imply this->x
    z.x = x + rhs.x;
    return z;
}

• 可重载，且必须重载为成员函数的运算符：=，(), →，转型运算符
• 可重载，且可以实现非成员函数的运算符：绝大部分
• 不建议重载的运算符：&&，||，,。这类运算符往往需要维护特定的求值顺序，而
  • C++17 之前，重载运算符对执行顺序没有规定
  • C++17 之后，顺序规定，但重载上述运算符会破坏短路逻辑
• 不可重载的运算符

指可以左右算子互换位置的运算符（比如 +，== 等）。对称性运算符需要被设计为非成员重载，是因为：

• 对称性运算符通常牵涉到两个算子之间的运算。这个过程中会为了匹配左右算子类型进行隐式转换。如果声明为成员函数，算子的位置被固定，这将导致某些隐式转换无法正常进行，从而导致计算失败。比如：

class Str
{
    public:
    Str(int x) :val(x) {}
    Str operator+ (const Str& rhs) {...}
    private:
    int val;
};

int main(int argc, char const *argv[])
{
    Str myStr1(2);
    // 可以进行正常运算，4 对应 rhs, 可以通过 Str 的构造函数转化为 Str 类型
    Str myRetStr =myStr1 + 4;
    // 无法正常进行运算，4 不是 Str (this指向的) 类型
    Str myRetStr = 4 + myStr1;
    return 0;
}

• 设计为非成员函数以后，由于不再受 this 的匹配影响，上述例子中的 4 则可以在函数匹配的过程中进行隐式转换。

• 需要声明为 friend，否则无法访问私有数据

移位运算符必须重载为非成员函数。这是因为 C++ 中移位运算符有一个更重要的应用：输入输出流运算符。输入输出流运算符一般的格式为：

StreamObjReference << Object;

• 返回对象为流的引用：为了支持连续的流运算
• 参数为流的引用，以及需要进出流的对象
• 具体的 const 根据输入输出决定

// 简单的输出流重载实现
// 需要声明为友元函数
std::ostream& operator << (std::ostream& ostr, const Str &output)
{
    ostr << output.val;
    return ostr;
}

• 必须以成员函数的形式重载
• 返回为引用：因为赋值等号的左边是目标，右边是值
• 典型例子：copy assignment / move assignment；除此之外参数也可以是其他形式

// 简单的实现
Str& Str::operator= (const Str& rhs)
{
    if(this != &rhs)
    {
        val = rhs.val;
    }
    return *this;
}

该运算符重载用于模拟下标操作。典型的应用是 std::vector。需要考虑的问题有：

• 下标要支持读取
• 下标运算的结果要支持写入

主要的问题在第二个子问题上：

• 首先，要支持写入，那么需要对 ObjA[0] = ObjB 这种形式的运算进行处理。因此，下标运算的返回结果一定是左值，也就是对象的引用。
• 其次，当下标运算的对象为 const 时，这种写入的操作应该被侦测并禁止。因此，我们需要一个专门的 const 实现版本来处理该情况。

// 简单的实现，基于 String 的下标运算重载
class StrVec {
public:
    std::string& operator[](std::size_t n)
        { return elements[n]; }
    // const 版本
    const std::string& operator[](std::size_t n) const
        { return elements[n]; }
private:
    std::string* elements;   // pointer to the first element in the array
};

• 单目运算符，必须重载为成员函数
• 分 Prefix 和 postfix 两种版本

以加法为例， 前缀版本：

• 写法：不带参数 operator++()
• 返回：引用，为了支持连续的使用
• 过程：
  • 自增
  • 返回自增后的结果

后缀版本：

• 写法：带一个没有任何用处的 int 类型参数：operator++(int)
• 返回：自增对象被修改之前的副本
• 过程：
  • 保存副本
  • 对原有的数据进行自增
  • 返回保存的副本

Str& Str::operator++()
{
    ++val;
    return *this;
}

Str Str::operator++(int)
{
    Str ret = *this;
    ++*this;
    return ret;
}

两者都是模拟指针的行为。

• 返回：解引用后内容类型的引用（与下标运算符类似，目的是为了写操作）
• 基于第一条的原因，因此也需要引入 const 版本

int& Str::operator*() 
{
    return *ptr;
}

箭头运算符的重载是一个通过递归的方式访问最终数据成员的过程：

• Base case：返回类型是类类型的指针（bulit-in 指针）
• Normal case：返回类型是普通类类型

实现上，箭头运算符的重载有返回类型，但没有参数

// 返回指针（Base case）
Str* Str::operator->()
{
    return this;
}
// 返回对象（Normal case）
// 编译器会到 Str2 中继续寻找 -> 的定义
Str2 Str::operator->()
{
    return Str2;
}

函数调用运算符允许将对象变为可调用对象，即 obj() 这类型的函数。其最大的特点是接收参数数量不定：

struct Str
{
    Str(int* p):ptr(p){}
    int operator() (int x, int y, int z)
    {
        return *ptr + x + y + z;
    }
    
    int* ptr;
};

int main(int argc, char const *argv[])
{
    int x = 100;
    Str StrPtr(&x);
    // 打印 100 + 1 + 2 + 3 的结果
    std::cout << StrPtr(1,2,3);
    return 0;
}

• 用于自定义类类型与其他类型之间的转换
• 无显式的返回类型
• 需要被定义为 const
  • 类型转换不涉及内容的修改，因此应该被定义为 const
  • 涉及常量的类型转换需要重载为 const
• 写法：

operator type() const {}

需要注意的是，除了自定义的类型转换运算符，程序中很可能还存在其他的重载，这些重载也可能具有（隐式）类型转换的功能，比如：

// 同时定义了 class 到 int 的转换，以及 class 与 int 的加法
// int() 可以转换
operator int() const { return val; }
friend Str operator + (const Str& lhs, const Str& rhs);

// 存在两个候选者
// 4 可以通过 int() 转换为 Str, 也可以通过 + 转换为 Str，因此导致歧义
Str obj(100);
std::cout << (obj + 4);

explicit operator int() const { return val; }

隐式转换还可能带来一些未知的结果。比如下面的例子：

// 使用 cin 输出，逻辑上是不合理的
// 此处，cin 的隐式转换为 istream -> bool -> int
// 根据 cin 是否有效，最终的表达式为 0 << 3 或是 1 << 3
// 也就是非法的输出操作通过隐式转换转变为了合法的移位操作
std::cin << 3;

C++ 20 中：

• 只需定义 == 的重载，编译器会自动推导 != 的重载（3-way comparsion 同理）
• == 会尝试对 operand 进行自动换位，来匹配用户换位的结果，比如

bool operator ==(Str obj, int val) { return obj.x == val; }
// 可以调用
obj == 3;
// C++ 20 之前错误，无法找到匹配的函数
// C++ 20 编译通过
// 编译器会自动尝试 bool operator ==(int val, Str obj)
3 == obj;

• 基类（Base）: 被继承的类
• 派生类（Derive）: 继承的类
• 继承（Inheritance）：is-a 关系，指派生类是基类的一种。

• public：父类的内容对所有人可见
• private：父类的内容只对自己可见
• protect：父类的内容对自己以及其子类可见

可以通过基类的指针和引用指向派生类的对象：

Derive d;
Base& ref = d;
Base* ptr = &d;

• 静态类型：父类指针/引用在编译时的类型，通常为父类的类型
• 动态类型：父类指针/引用在运行期时的类型，通常为其指向的派生类的类型

• 派生类的 scope 属于基类的一部分
• 派生类的 scope 处于基类 scope 的内部，遵循内部 name 隐藏外部 name 的原则
• name 查找原则也是自内向外

• 默认情况下派生类会委托基类中的默认构造函数对继承自基类的部分先行进行构造
• 如果基类中缺乏默认构造函数，那么需要在派生类中显式的调用基类的构造函数
• 对基类的构造必须在初始化阶段：派生类委托基类构造应该在初始化列表中，而不是在函数体中（函数体中的处理处于赋值阶段）

当基类（或派生类）中某个函数被定义为虚函数时，意味着该函数可以通过基类的指针或者引用对其进行调用。其作用是为了实现运行期的动态多态：也就是说，根据调用者的动态类型不同，对应的虚函数可能存在不同的实现方式。这些不同的实现方式通过重写（override）实现。一些注意事项：

• 使用 vritual 关键字定义
• 非静态、非构造函数可以声明为虚函数

虚函数之所以能在运行期与特定类型的对象进行绑定，原因是其维护了一个被称为虚表（vitrual table）的数组。该数组会在派生类对象实例化时生成，包含两部分重要的信息：

• 派生类的类型信息
• 派生类中所有的虚函数的信息

虚函数的动态绑定会根据这个表中的信息完成。在派生类中，只要定义了虚函数的重写，那么虚表中对应的同名函数的绑定，更新就会到当前的派生类上