C++ 语言返回 *this 的成员函数

妖狐艹你老母 2022-09-06 04:49 252阅读 0赞

#  C++ 语言返回 `*this` 的成员函数 #

`set` 函数负责设置光标所在位置的字符或者其他任一给定位置的字符。

class Screen {
    public:
    	Screen &set(char);
    	Screen &set(pos, pos, char);
    	......
    };
    
    inline Screen &Screen::set(char c)
    {
    	contents[cursor] = c;  // 设置当前光标所在位置的新值
    	return *this;  // 将 this 对象作为左值返回
    }
    
    inline Screen &Screen::set(pos r, pos col, char ch)
    {
    	contents[r*width + col] = ch;  // 设置给定位置的新值
    	return *this;  // 将 this 对象作为左值返回
    }

我们的 `set` 成员的返回值是调用 `set` 的对象的引用。返回引用的函数是左值的，意味着这些函数返回的是对象本身而非对象的副本。

如果我们把一系列这样的操作连接在一条表达式中的话，这些操作将在同一个对象上执行。

// 把光标移动到一个指定的位置，然后设置该位置的字符值 
    myscreen.move(4, 0).set('#');

在上面的表达式中，我们首先移动 `myscreen` 内的光标，然后设置 `myscreen` 的 `contents` 成员。也就是说，上述语句等价于

myscreen.move(4, 0);
    myscreen.set('#');

如果我们令 `move` 和 `set` 返回 `Screen` 而非 `Screens&`，则上述语句的行为将大不相同。

// 如果 move 返回 Screen 而非 Screen&
    Screen temp = myscreen.move(4, 0);  // 对返回值进行拷贝
    temp.set('#')  // 不会改变 myscreen 的 contents

假如当初我们定义的返回类型不是引用，则 `move` 的返回值将是 `*this` 的副本，因此调用 `set` 只能改变临时副本，而不能改变 `myscreen` 的值。

## 1. 从 `const` 成员函数返回 `*this` ##

我们继续添加一个名为 `display` 的操作，它负责打印 `Screen` 的内容。我们希望这个函数能和 `move` 以及 `set` 出现在同一序列中，因此类似于 `move` 和 `set`，`display` 函数也应该返回执行它的对象的引用。

从逻辑上来说，显示一个 `Screen` 并不需要改变它的内容，因此我们令 `display` 为一个 `const` 成员，`this` 将是一个指向 `const` 的指针而 `*this` 是 `const` 对象。`display` 的返回类型应该是 `const Sales&`。如果真的令 `display` 返回一个 `const` 的引用，则我们将不能把 `display` 嵌入到一组动作的序列中去：

Screen myscreen;
    // 如果 display 返回常量引用，则调用 set 将引发错误
    myscreen.display(cout).set('*');

即使 `myscreen` 是个非常量对象，对 `set` 的调用也无法通过编译。问题在于 `display` 的 `const` 版本返回的是常量引用，而我们显然无权 `set` —个常量对象。一个 `const` 成员函数如果以引用的形式返回 `*this`，那么它的返回类型将是常量引用。

## 2. 基于 const 的重载 ##

通过区分成员函数是否是 `const` 的，我们可以对其进行重载，其原因与我们之前根据指针参数是否指向 `const` 而重载函数的原因差不多。具体说来，因为非常量版本的函数对于常量对象是不可用的，所以我们只能在一个常量对象上调用 `const` 成员函数。另一方面，虽然可以在非常量对象上调用常量版本或非常量版本，但显然此时非常量版本是一个更好的匹配。

在下面的这个例子中，我们将定义一个名为 `do_disp1ay` 的私有成员，由它负责打印 `Screen` 的实际工作。所有的 `display` 操作都将调用这个函数，然后返回执行操作的对象：

class Screen {
    public:
    	// 根据对象是否是 const 重载了 display 函数
    	Screen &display(std::ostream &os)
    	{
    		do_display(os);
    		return *this;
    	}
    
    	const Screen &display(std::ostream &os) const
    	{
    		do_display(os);
    		return *this;
    	}
    
    private:
    	// 该函数负责显示 Screen 的内容
    	void do_display(std::ostream &os) const { os << contents; }
    
    };

当一个成员调用另外一个成员时，`this` 指针在其中隐式地传递。当 `display` 调用 `do_display` 时，它的 `this` 指针隐式地传递给 `do_display`。而当 `display` 的非常量版本调用 `do_display` 时，它的 `this` 指针将隐式地从指向非常量的指针转换成指向常量的指针。

当 `do_display` 完成后，`display` 函数各自返回解引用 `this` 所得的对象。在非常量版本中，`this` 指向一个非常量对象，因此 `display` 返回一个普通的 (非常量) 引用；而 `const` 成员则返回一个常量引用。

当我们在某个对象上调用 `display` 时，该对象是否是 `const` 决定了应该调用 `display` 的哪个版本：

Screen myscreen(5, 3);
    const Screen blank(5, 3);
    myscreen.set('#').display(cout); // 调用非常量版本
    blank.display(cout);  // 调用常量版本

## 3. 对于公共代码使用私有功能函数 ##

定义一个单独的 `do_display` 函数的原因：

*  一个基本的愿望是避免在多处使用同样的代码。
 *  我们预期随着类的规模发展，`display` 函数有可能变得更加复杂，把相应的操作写在一处而非两处的作用就比较明显了。
 *  我们很可能在开发过程中给 `do_display` 函数添加某些调试信息，而这些信息将在代码的最终产品版本中去掉。 显然，只在 `do_display` 一处添加或删除这些信息要更容易一些。
 *  **这个额外的函数调用不会增加任何开销。因为我们在类内部定义了 `do_display`, 所以它隐式地被声明成内联函数。这样的话，调用 `do_display` 就不会带来任何额外的运行时开销。**

在实践中，设计良好的 C++ 代码常常包含大量类似于 `do_display` 的小函数，通过调用这些函数，可以完成一组其他函数的实际工作。

## References ##

(美) Stanley B. Lippman, (美) Josée Lajoie, (美) Barbara E. Moo 著, 王刚, 杨巨峰 译. C++ Primer 中文版\[M\]. 第 5 版. 电子工业出版社, 2013.  
[https://www.informit.com/store/c-plus-plus-primer-9780321714114][https_www.informit.com_store_c-plus-plus-primer-9780321714114]

[https_www.informit.com_store_c-plus-plus-primer-9780321714114]: https://www.informit.com/store/c-plus-plus-primer-9780321714114