C++ 语言 this 指针和成员函数

刺骨的言语ヽ痛彻心扉 2022-09-05 12:39 170阅读 0赞

#  C++ 语言 `this` 指针和成员函数 #

## 1. 定义改进的 `Sales` 类 ##

类的数据成员包括：  
`book_no`, `string` 类型，表示 ISBN 编号；  
`sold_num`, `unsigned int` 类型，表示某本书的销量；  
`revenue`, `double` 类型，表示这本书的总销售收入。

revenue [ˈrevənjuː]：n. 财政收入，税收收入，收益

我们的类将包含两个成员函数：`combine` 和 `isbn`。此外，我们还将赋予 `Sales` 另一个成员函数用于返回售出书籍的平均价格，这个函数被命名为 `avg_price`。因为 `avg_price` 的目的并非通用，所以它应该属于类的实现的一部分， 而非接口的一部分。

成员函数的声明必须在类的内部，它的定义则既可以在类的内部也可以在类的外部。

**`struct` 关键字 (struct keyword) 用于定义类的关键字，默认情况下成员是 `public` 的。**  
**`class` 关键字 (class keyword) 用于定义类的关键字，默认情况下成员是 `private` 的。**

从 `class` 继承默认是 `private` 继承，而从 `struct` 继承默认是 `public` 继承。

**访问说明符 (access specifier) 包括关键字 `public` 和 `private`。用于定义成员对类的用户可见还是只对类的友元和成员可见。在类中说明符可以出现多次，每个说明符的有效范围从它自身开始，到下一个说明符为止。**

struct Sales
    {
    	std::string isbn() const { return book_no; }
    	Sales &combine(const Sales &);
    	double avg_price() const;
    
    	std::string book_no;
    	unsigned int sold_num = 0;
    	double revenue = 0.0;
    };
    
    // Sales 的非成员接口函数
    Sales add(const Sales &, const Sales &);
    std::ostream &print(std::ostream &, const Sales &);
    std::istream &read(std::istream &, Sales &);

**定义在类内部的函数是隐式的 `inline` 函数。**

## 2. 定义成员函数 ##

尽管所有成员都必须在类的内部声明，但是成员函数体可以定义在类内也可以定义在类外。对于 `Sales` 类来说，`isbn` 函数定义在了类内，而 `combine` 和 `avg_price` 定义在了类外。

`isbn` 函数的参数列表为空，返回值是一个 `string` 对象。和其他函数一样，成员函数体也是一个块。在此例中，块只有一条 `return` 语句，用于返回 `Sales` 对象的 `book_no` 数据成员。

std::string isbn() const { return book_no; }

## 3. 引入 `this` ##

`this` 指针 (this pointer) 是一个隐式的值，做为额外的实参传递给类的每个非静态成员函数。`this` 指针指向代表函数调用者的对象。

对 `isbn` 成员函数的调用，使用了点运算符来访问 `total` 对象的 `isbn` 成员，然后调用它。

total.isbn();

当我们调用成员函数时，实际上是在替某个对象调用它。如果 `isbn` 指向 `Sales` 的成员，则它隐式地指向调用该函数的对象的成员。在上面所示的调用中，当 `isbn` 返冋 `book_no` 时，实际上它隐式地返回 `total.book_no`。

成员函数通过一个名为 `this` 的额外的隐式参数来访问调用它的那个对象。当我们调用一个成员函数时，用请求该函数的对象地址初始化 `this`。如果调用

total.isbn();

则编译器负责把 `total` 的地址传递给 `isbn` 的隐式形参 `this`，可以等价地认为编译器将该调用重写成了如下的形式：

// 伪代码，用于说明调用成员函数的实际执行过程
    Sales::isbn(&total);

其中，调用 `Sales` 的 `isbn` 成员时传入了 `total` 的地址。

在成员函数内部，我们可以直接使用调用该函数的对象的成员，而无须通过成员访问运算符来做到这一点，因为 `this` 所指的正是这个对象。任何对类成员的直接访问都被看作 `this` 的隐式引用。当 `isbn` 使用 `book_no` 时，它隐式地使用 `this` 指向的成员，就像我们书写了 `this->book_no` 一样。

对于我们来说，`this` 形参是隐式定义的。实际上，任何自定义名为 `this` 的参数或变量的行为都是非法的。我们可以在成员函数体内部使用 `this`，因此尽管没有必要，但我们还是能把 `isbn` 定义成如下的形式：

std::string isbn() const { return this->book_no; }

因为 `this` 的目的总是指向`这个`对象，所以 `this` 是一个常量指针，我们不允许改变 `this` 中保存的地址。

## 4. 引入 const 成员函数 ##

`isbn` 函数的另一个关键之处是紧随参数列表之后的 `const` 关键字，这里 `const` 的作用是修改隐式 `this` 指针的类型。

默认情况下，`this` 的类型是指向类类型非常量版本的常量指针。例如在 `Sales` 成员函数中，`this` 的类型是 `Sales *const`。尽管 `this` 是隐式的，但它仍然需要遵循初始化规则，意味着 (在默认情况下) 我们不能把 `this` 绑定到一个常量对象上。这一情况也就使得我们不能在一个常量对象上调用普通的成员函数。

**如果 `isbn` 是一个普通函数而且 `this` 是一个普通的指针参数，则我们应该把 `this` 声明成 `const Sales *const`。在 `isbn` 的函数体内不会改变 `this` 所指的对象，所以把 `this` 设置为指向常量的指针有助于提高函数的灵活性。**

`this` 是隐式的并且不会出现在参数列表中，所以在哪儿将 `this` 声明成指向常量的指针就成为我们必须面对的问题。**C++ 语言的做法是允许把 `const` 关键字放在成员函数的参数列表之后，紧跟在参数列表后面的 `const` 表示 `this` 是一个指向常量的指针。这样使用 `const` 的成员函数被称作常量成员函数 (`const member function`)。**

在**常量成员函数 (const member function)** 中不能修改对象的普通 (即既不是 `static` 也不是 `mutable`) 数据成员。`const` 成员的 `this` 指针是指向常量的指针，通过区分函数是否是 `const` 可以进行重载。

可以把 `isbn` 的函数体想象成如下的形式：

// 伪代码，说明隐式的 this 指针是如何使用的
    // 下面的代码是非法的：因为我们不能显式地定义自己的 this 指针
    // 谨记此处的 this 是一个指向常量的指针，因为 isbn 是一个常量成员
    std::string Sales::isbn(const Sales *const this)
    {
    	return this->isbn；
    }

因为 `this` 是指向常量的指针，所以常量成员函数不能改变调用它的对象的内容。`isbn` 可以读取调用它的对象的数据成员，但是不能写入新值。

**常量对象，以及常量对象的引用或指针都只能调用常量成员函数。**

## 5. 类作用域和成员函数 ##

类本身就是一个作用域。类的成员函数的定义嵌套在类的作用域之内，`isbn` 中用到的名字 `book_no`，其实就是定义在 `Sales` 内的数据成员。

即使 `book_no` 定义在 `isbn` 之后，`isbn` 也还是能够使用 `book_no`。编译器分两步处理类：首先编译成员的声明，然后才轮到成员函数体 (如果有的话)。因此，成员函数体可以随意使用类中的其他成员而无须在意这些成员出现的次序。

## 6. 在类的外部定义成员函数 ##

当我们在类的外部定义成员函数时，成员函数的定义必须与它的声明匹配。返回类型、参数列表和函数名都得与类内部的声明保持一致。**如果成员被声明成常量成员函数，那么它的定义也必须在参数列表后明确指定 `const` 属性。类外部定义的成员的名字必须包含它所属的类名。**

double Sales::avg_price() const {
    	if (sold_num) {
    		return revenue / sold_num;
    	}
    	else {
    		return 0;
    	}
    }

函数名 `Sales::avg_price()` 使用作用域运算符来说明如下的事实：我们定义了一个名为 `avg_price` 的函数，并且该函数被声明在类 `Sales` 的作用域内。一旦编译器看到这个函数名，就能理解剩余的代码是位于类的作用域的。 当 `avg_price` 使用 `revenue` 和 `sold_num` 时，实际上它隐式地使用了 `Sales` 的成员。

## 7. 定义一个返回 `this` 对象的函数 ##

函数 `combine` 的设计初衷类似于复合赋值运算符 `+=`，调用该函数的对象代表的是赋值运算符左侧的运算对象，右侧运算对象则通过显式的实参被传入函数。

Sales &Sales::combine(const Sales &rhs)
    {
    	// 把 rhs 对象的成员加到 this 对象的成员上
    	sold_num += rhs.sold_num;
    	revenue += rhs.revenue;
    
    	// 返回调用该函数的对象
    	return *this;
    }

当我们的交易处理程序调用如下的函数时，

total.combine(trans);  // 更新变量 total 当前的值

`total` 的地址被绑定到隐式的 `this` 参数上，而 `rhs` 绑定到了 `trans` 上。因此当 `combine` 执行下面的语句时，

sold_num += rhs.sold_num;  // 把 rhs 对象的成员添加到 this 对象的成员中

效果等同于求 `total.sold_num` 和 `trans.sold_num` 的和，然后把结果保存到 `total.sold_num` 中。

一般来说，当我们定义的函数类似于某个内置运算符时，应该令该函数的行为尽量模仿这个运算符。内置的赋值运算符把它的左侧运算对象当成左值返回，因此为了与它保持一致，`combine` 函数必须返回引用类型。因为此时的左侧运算对象是一个 `Sales` 的对象，所以返回类型应该是 `Sales &`。

我们无须使用隐式的 `this` 指针访问函数调用者的某个具体成员，而是需要把调用函数的对象当成一个整体来访问：

return *this;  // 返回调用该函数的对象

**其中，`return` 语句解引用 `this` 指针以获得执行该函数的对象，上面的这个调用返回 `total` 的引用。**

## 8. 类相关的非成员函数 ##

定义非成员函数的方式与定义其他函数一样，通常把函数的声明和定义分离开来。如果函数在概念上属于类但是不定义在类中，则它一般应与类声明 (而非定义) 在同一个头文件内。在这种方式下，用户使用接口的任何部分都只需要引入一个文件。如果非成员函数是类接口的组成部分，则这些函数的声明应该与类在同一个头文件内。

### 8.1 定义 `read` 和 `print` 函数 ###

// 输入的交易信息包括 ISBN、售出总数和售出价格
    istream &read(istream &is, Sales &item)
    {
    	double price = 0;
    	is >> item.book_no >> item.sold_num >> price;
    	item.revenue = price * item.sold_num;
    
    	return is;
    }
    
    ostream &print(ostream &os, const Sales &item)
    {
    	os << item.isbn() << " " << item.sold_num << " " << item.revenue << " " << item.avg_price();
    
    	return os；
    }

`read` 函数从给定流中将数据读到给定的对象里，`print` 函数则负责将给定对象的内容打印到给定的流中。**`read` 和 `print` 分别接受一个各自 IO 类型的引用作为其参数，这是因为 IO 类属于不能被拷贝的类型，因此我们只能通过引用来传递它们。因为读取和写入的操作会改变流的内容，所以两个函数接受的都是普通引用，而非对常量的引用。**

`print` 函数不负责换行。一般来说，执行输出任务的函数应该尽量减少对格式的控制，这样可以确保由用户代码来决定是否换行。

### 8.2 定义 `add` 函数 ###

`add` 函数接受两个 `Sales` 对象作为其参数，返回值是一个新的 `Sales`，用于表示前两个对象的和。

Sales add(const Sales &lhs, const Sales &rhs)
    {
    	// lhs 的数据成员拷贝给 sum
    	Sales sum = lhs;
    	// rhs 的数据成员加到 sum 当中
    	sum.combine(rhs);
    
    	return sum;
    }

在函数体中，我们定义了一个新的 `Sales` 对象并将其命名为 `sum`。`sum` 将用于存放两笔交易的和，我们用 `lhs` 的副本来初始化 `sum`。默认情况下，拷贝类的对象其实拷贝的是对象的数据成员。在拷贝工作完成之后，`sum` 的 `book_no` 、`sold_num` 和 `revenue` 将和 `lhs` 一致。调用 `combine` 函数，将 `rhs` 的 `sold_num` 和 `revenue` 添加给 `sum`。最后，函数返回 `sum` 的副本。

## 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