运算符重载、友元与成员函数指针

1. 从普通函数到运算符

给数列写一个迭代器时,可以先想象三个普通函数:value() 读取当前项,advance() 前进一步,samePosition(other) 判断两个位置是否相同。如果希望它像指针一样使用,就可以分别为它定义 *it、++it 和 it == other。运算符重载为自定义类型提供已有运算符的实现。

以二元运算符 a == b 为例,成员实现相当于 a.operator==(b),左边的 a 是调用者,右边的 b 进入参数列表。非成员实现相当于 operator==(a, b),左右两个对象都进入参数列表。这个差别会直接决定后面的流运算符怎么写。

  • 只能重载语言已经提供且允许重载的运算符。诸如 .、::、?: 和 sizeof 无法重载。
  • 优先级、结合方式和操作数个数保持原来的规则。即使重载了加法和乘法,a + b * c 仍按 a + (b * c) 结合。
  • 普通运算符重载至少涉及一个类或枚举类型,不能重新定义两个整数相加的行为。operator= 必须写成成员函数,详见 对象复制:拷贝构造与拷贝赋值。
  • 重载后的 && 和 || 会求值两个操作数,无法像内置运算符一样用左侧条件保护右侧操作。
  • 让符号的行为符合读者的预期,例如比较返回真假,递增确实前进一步。返回值由具体操作决定,例如加法通常按值返回新结果,前置递增通常返回对当前对象的引用。

2. Fibonacci 迭代器的三个组成部分

迭代器表示当前走到哪里。Fibonacci 数列开头是 1、1、2,前两项的值相同,但位置不同。如果比较的是值,遍历遇到重复元素就可能提前结束。因此,迭代器保存下标,== 比较下标,* 用下标取值。

一个 Fibonacci 对象可以表示从第 2 项开始的 3 项。应该依次读第 2、3、4 项,在第 5 项停止。如果把终点设在第 4 项,那么循环会在读取第 4 项之前退出。由此得到左闭右开范围 [start, start + length)。即使第 5 项在完整数列中确实存在,也不能作为这个范围中的元素读取。

语法操作结果
it == last比较位置真假
*it读取当前项数列中的整数
++it前进一项更新后的迭代器的引用
it++前进一项前进前的迭代器副本

++it 修改当前位置,随后用 return *this; 返回当前对象。对 it++,如果先改位置再返回引用,调用者就拿不到旧位置了。因此先复制当前位置,再递增原对象,最后按值返回旧副本。后置形式的 int 参数用来区分重载,前进的步长仍由实现决定。

下面用一段固定数列展示这套接口,缓存如何扩展可以独立处理。外部项号从 1 开始,内部下标从 0 开始。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class FibonacciIterator;

class Fibonacci {
    inline static constexpr int values_[]{1, 1, 2, 3, 5};
    int start_;
    int length_;
    friend class FibonacciIterator;

public:
    using iterator = FibonacciIterator;
    // 示例的调用条件为 start >= 1、length >= 0、
    // 且所选范围完全落在已有的五项内。
    Fibonacci(int start, int length) : start_(start), length_(length) {}
    iterator begin() const;
    iterator end() const;
};

class FibonacciIterator {
    int index_;

public:
    explicit FibonacciIterator(int position) : index_(position - 1) {}
    bool operator==(const FibonacciIterator& other) const {
        return index_ == other.index_;
    }
    bool operator!=(const FibonacciIterator& other) const {
        return !(*this == other);
    }
    int operator*() const { return Fibonacci::values_[index_]; }
    FibonacciIterator& operator++() {
        ++index_;
        return *this;
    }
    FibonacciIterator operator++(int) {
        auto old = *this;
        ++(*this);
        return old;
    }
};

Fibonacci::iterator Fibonacci::begin() const { return iterator(start_); }
Fibonacci::iterator Fibonacci::end() const { return iterator(start_ + length_); }

片段开头的前向声明让编译器先认识迭代器类的名字,因此可以在 Fibonacci 中写出迭代器的类型别名和函数声明。实际定义 begin()、end() 时,迭代器类已经定义完整。using iterator = FibonacciIterator 让使用者可以写 Fibonacci::iterator。

1
2
3
4
Fibonacci fib(2, 3);
for (auto it = fib.begin(), last = fib.end(); it != last; ++it) {
    std::cout << *it << ' ';  // 1 2 3
}

每次调用 begin() 都得到一个新位置对象,两次遍历可以各自前进。这个例子中的位置指向同一份共享数列,因此只比较下标就够了。对独立容器,遍历应使用同一有效范围里的起点和终点。此示例只实现循环所需的操作,解引用前由调用者保证位置可读。

3. friend 与私有访问

上面的 values_ 是 Fibonacci 的私有成员,迭代器是另一个类。Fibonacci 可以提供一个公开的取值函数,让迭代器通过接口取值。也可以像示例一样,用 friend class FibonacciIterator; 授权迭代器类的成员直接读取内部数据。

如果只有某个成员需要权限,可以在该成员已声明后写出更具体的友元声明,如 friend int FibonacciIterator::operator*() const;。也可以授权一个普通的非成员函数。声明放在 public 或 private 下,授权效果相同。

授权针对直接访问私有成员的代码。 如果获授权的 operator*() 调用了另一个函数,而另一个函数也直接读取私有缓存,后者仍需要自己的访问权限。友元也不会自动双向授权。优先判断协作究竟需要一个公开操作,还是确实需要访问内部实现。

4. 函数对象和 count_if

假设有一组数 3、10、7、12,任务是统计其中几个数小于 10。这里 10 是比较界限,也叫阈值,可以由题目指定,也可以由用户输入。代码里用 limit 表示它。手写循环时可以这样做:

1
2
3
4
5
int limit = 10;
int count = 0;
for (int x : values) {
    if (x < limit) ++count;
}

std::count_if 是 <algorithm> 里的标准库算法,负责遍历并统计满足条件的元素。前两个参数给出范围,第三个参数提供判断条件。这样的真假判断叫谓词。算法处理每个元素时,相当于调用一次 predicate(x),它会提供当前元素 x。阈值是具体题目的信息,必须由判断条件自己带上。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#include <algorithm>
#include <vector>

class LessThan {
    int limit_;

public:
    explicit LessThan(int limit) : limit_(limit) {}
    bool operator()(int x) const { return x < limit_; }
};

auto countBelow(const std::vector<int>& values, int limit) {
    return std::count_if(values.begin(), values.end(), LessThan(limit));
}

LessThan(10) 先创建一个把 10 存进 limit_ 的对象。算法读到 7 时,调用这个对象的 operator()(7),于是 x 是 7,limit_ 是对象保存的 10,判断 7 < 10 成立。换成 LessThan(5),同一组数据只有 3 满足条件,结果从 2 变成 1。

定义了 operator() 的对象可以像函数一样调用,因此叫函数对象。普通函数也能作为谓词。这个场景中,函数对象特别方便,因为不同判断实例可以分别保存自己的阈值。统计偶数等不依赖阈值的任务则只需要相应的判断规则。

5. 流运算符从普通打印函数推导

std::cout << 42 把 42 写到标准输出。左侧是输出流,决定写到哪里。右侧是值,决定写什么。对自定义对象 fib,需要自己定义输出哪些信息。假设对象提供 beg_pos() 和 length() 两个查询,可以先写普通函数:

1
2
3
4
void print(std::ostream& out, const CFibonacci& fib) {
    out << '(' << fib.beg_pos() << ", " << fib.length() << ')';
}
// print(std::cout, fib);

std::ostream 是输出流类型。out 引用调用者传进来的流,可以是终端输出,也可以是文件流。fib 是要输出的对象,const 引用允许读取对象并避免复制。如果希望把 print(std::cout, fib) 改成 std::cout << fib,就把对应函数写成:

1
2
3
4
std::ostream& operator<<(std::ostream& out, const CFibonacci& fib) {
    print(out, fib);
    return out;
}

operator<<(std::cout, fib) 和 std::cout << fib 在这里调用同一个函数。两个操作数按从左到右的顺序放进参数列表。如果把运算符写成 CFibonacci 的普通成员函数,调用者就必须是 fib,写法相当于 fib.operator<<(std::cout),也就是 fib << std::cout。为了保留习惯上的顺序,采用上面的非成员形式。使用公开的查询接口时无需友元。

签名最前面的 std::ostream& 是返回类型。写完后 return out; 把原来的流交回去。std::cout << fib << '\n' 按 (std::cout << fib) << '\n' 结合,第一次输出返回原流,第二次才能接着写换行。输出数列的每一项也一样,遍历时把值写到 out。

6. 输入运算符与对象状态

std::cin >> fib 表示从输入流读取数据,并更新已有的 Fibonacci 对象。因此第二个参数是可修改引用。假定输入格式为 (起点, 长度),而该类构造函数的顺序为 CFibonacci(长度, 起点):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
std::istream& operator>>(std::istream& in, CFibonacci& fib) {
    char open, comma, close;
    int start, length;
    if (!(in >> open >> start >> comma >> length >> close)) {
        return in;
    }
    if (open != '(' || comma != ',' || close != ')' ||
        start < 1 || start > 46 || length < 1 || length > 47 - start) {
        in.setstate(std::ios::failbit);
        return in;
    }
    fib = CFibonacci(length, start);
    return in;
}

先读进局部变量,是为了避免输入错误时把对象改到一半。整数提取失败时,流本身会报告失败。格式或范围不符合要求时,由函数设置 failbit。这样 if (std::cin >> fib) 可以直接判断这次提取是否成功。返回同一个输入流也支持连续读取。

范围上限基于 32 位有符号 int。第 46 项还能表示,第 47 项超出范围。最后一项是 start + length - 1,所以要求 length <= 47 - start。输入 (46, 1) 合法,(46, 2) 失败并保留原对象。

输出若在括号后还打印了数列各项,而输入只读括号参数,后续的数值仍留在流中。需要用文件保存并连续读回对象时,应让两边采用同一数据格式。

7. 非静态成员函数指针

普通函数指针可以直接调用,见 第二章。成员调用 fib.show_elems(5) 还依赖一个具体对象,因为函数要知道处理的是哪一段数列。如果希望先选好操作,之后再决定作用于哪个对象,就可以使用成员函数指针:

1
2
3
4
5
6
using Show = void (CFibonacci::*)(int);
Show action = &CFibonacci::show_elems;

(fib.*action)(5);
CFibonacci* p = &fib;
(p->*action)(5);

读类型时,void 是返回类型,CFibonacci::* 表示它是这个类的成员函数指针,(int) 是显式参数列表。fib.*action 将选定的操作与对象结合,最后的 (5) 传入实参。通过对象指针访问时使用 ->*。如果成员函数声明末尾有 const,指针类型末尾也要有 const。可能为空的成员函数指针需先检查。静态成员函数没有当前对象,可以用普通函数指针。

相关笔记:重载运算符和重载函数、第三章。

使用 Hugo 构建
主题 Stack 由 Jimmy 设计