chapter7/chapter7-类.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第7章 类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 类的基本思想是数据抽象（data abstraction）和封装（encapsulation）\n",
    "- 数据抽象是一种依赖于接口（interface）和实现（implementation）分离的编程技术；类的接口包括用户所能执行的操作，类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数\n",
    "- 封装实现了类的接口和实现的分离，封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现部分\n",
    "- 类要想实现数据抽象和封装，需要首先定义一个抽象数据类型（abstract data type），由类的设计者负责考虑类的实现过程，使用该类的程序员则只需要抽象地思考类型做了什么，而无需了解类型的工作细节"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.1 定义抽象数据类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1.2 定义改进的Sales_data类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 类作用域和成员函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 编译器分两步处理类：首先编译成员的声明，然后才轮到成员函数体（如果有的话）；因此，成员函数体可以随意使用类中的其它成员而无须在意这些成员出现的次序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1.4 构造函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 每个类都分别定义了它的对象被初始化的方式，类通过一个或几个特殊的成员函数来控制其对象的初始化过程，这些函数叫做构造函数（constructor）；构造函数的任务是初始化类对象的数据成员，无论何时只要类的对象被创建，就会执行构造函数\n",
    "- 构造函数的名字和类名相同，和其它函数不一样的是，构造函数没有返回类型，除此之外类似于其它的函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 合成的默认构造函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 如果我们的类没有显式地定义构造函数，那么编译器就会为我们隐式地定义一个默认构造函数，又被称为合成的默认构造函数（synthesized default constructor），对于大多数类来说，这个合成的默认构造函数将按照如下规则初始化类的数据成员：如果存在类内的初始值，则用它来初始化成员；否则，默认初始化该成员\n",
    "- 编译器只有在发现类不包含任何构造函数的情况下才会替我们生成一个默认的构造函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 某些类不能依赖于合成的默认构造函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 合成的默认构造函数可能执行错误的操作，例如，如果定义在块中的内置类型或复合类型（比如数组和指针）的对象被默认初始化，则它们的值将是未定义的\n",
    "- 如果类中包含一个其他类类型的成员且这个成员的类型没有默认构造函数，那么编译器将无法初始化该成员"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义Sales_data的构造函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```C++\n",
    "struct Sales_data {\n",
    "    Sales_data() = default; // 要求编译器生成默认的构造函数\n",
    "    Sales_data(const std::string &s): bookNo(s) {}\n",
    "    Sales_data(const std::string &s, unsigned n, double p): bookNo(s), units_sold(n), revenue(p*n) {}\n",
    "    Sales_data(std::istream &);\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1.5 拷贝、赋值和析构"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 除了定义类的对象如何初始化之外，类还需要控制拷贝、赋值和销毁对象时发生的行为；如果我们不主动定义这些操作，则编译器将替我们合成它们；但是必须清楚的一点是，对于某些类来说合成的版本无法正常工作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.2 访问控制与封装"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 我们使用访问说明符（access specifiers）加强类的封装性：定义在public说明符之后的成员在整个程序内可被访问，public成员定义类的接口；定义在private说明符之后的成员可以被类的成员函数访问，但是不能被使用该类的代码访问，private部分封装了（即隐藏了）类的实现细节\n",
    "- 我们可以使用`class`或`struct`中的任何一个来定义类，唯一的区别是默认访问权限不一样；类可以在它的第一个访问说明符之前定义成员，对这种成员的访问权限依赖于类定义的方式，如果使用struct定义，则默认访问权限是public，如果使用class定义，则默认访问权限是private"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.1 友元"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 类可以允许其他类或者函数访问它的非公有成员，方法是令其他类或者函数成为它的友元（friend）；如果类想把一个函数作为它的友元，只需增加一条以friend关键字开始的函数声明语句即可\n",
    "- 友元声明只能出现在类定义的内部，但是在类内出现的具体位置不限（一般在类定义开始或结束前的位置），友元不是类的成员也不受它所在区域访问控制级别的约束\n",
    "- 友元的声明仅仅指定了访问的权限，而非一个通常意义上的函数声明，如果我们希望类的用户能够调用某个友元函数，那么我们就必须在友元声明之外再专门对函数进行一次声明；为了使友元对类的用户可见，我们通常把友元的声明与类本身放置在同一个头文件中（类的外部）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.3 类的其它特性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.1 类成员再探"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 在类中，常有一些规模较小的函数适合于被声明成内联函数，定义在类内部的成员函数是自动inline的；可以在类的内部把inline作为声明的一部分显式地声明成员函数，同样地，也能在类外用inline关键字修饰函数的定义（当然，我们可以在两个地方同时说明inline，不过最好只在类外部定义的地方说明inline）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.3 类类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 每个类定义了唯一的类型，对于两个类来说，即使它们的成员完全一样，这两个类也是两个不同的类型\n",
    "- 就像可以把函数的声明和定义分离开来一样，我们也能仅仅声明类而暂时不定义它\n",
    "```c++\n",
    "class Screen;\n",
    "```\n",
    "- 这种声明有时被称作前向声明（forward declaration），它向程序中引入了名字Screen并指明这是一种类类型；对于类型Screen来说，在它声明之后定义之前是一个不完全类型（incomplete type），也就是说，此时我们已知Screen是一个类类型，但是不清楚它到底包含哪些成员\n",
    "- 不完全类型只能在非常有限的情景下使用：可以定义指向这种类型的指针或引用，也可以声明（但是不能定义）以不完全类型作为参数或者返回类型的函数；对于一个类来说，创建对象之前该类必须被定义过，而不能仅仅是声明，否则编译器无法了解这样的对象需要多少存储空间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.4 友元再探"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 类还可以把其它的类定义成友元，也可以把其他类（之前已定义过的）的成员函数定义成友元，此外，友元函数能定义在类的内部，这样的函数是隐式内联的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 类之间的友元关系"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 如果一个类指定了友元类，则友元类的成员函数可以访问此类包括非公有成员在内的所有成员"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 令友元函数作为友元"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 当把一个成员函数声明成友元时，我们必须明确指出该成员函数属于哪个类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.5 构造函数再探"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.5.1 构造函数初始值列表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 如果成员是const、引用，或者属于某种未提供默认构造函数的类类型，我们必须通过构造函数初始值列表为这些成员提供初值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 成员的初始化顺序与它们在类定义中的出现顺序一致：第一个成员先被初始化，然后第二个，以此类推，构造函数初始值列表中初始值的前后位置关系不会影响实际的初始化顺序\n",
    "```c++\n",
    "class X {\n",
    "    int i;\n",
    "    int j;\n",
    "public:\n",
    "    // 实际上，i先被初始化，因此这里的初始化有错误\n",
    "    X(int val) : j(val), i(j) {}\n",
    "};\n",
    "```\n",
    "- 最好令构造函数初始值的顺序与成员声明的顺序保持一致，而且如果可能的话，尽量避免使用某些成员初始化其它成员"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.5.2 委托构造函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 一个委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程，或者说它把它自己的一些（或全部）职责委托给了其它构造函数\n",
    "- 当一个构造函数委托给另一个构造函数时，受委托的构造函数的初始值列表和函数体被依次执行，然后控制权才会交还给委托者的函数体"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.5.3 默认构造函数的作用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 当对象被默认初始化或值初始化时自动执行默认构造函数\n",
    "- 默认初始化在以下情况下发生：1.当我们在块作用域内不使用任何初始值定义一个非静态变量或者数组时；2.当一个类本身含有类类型的成员且使用合成的默认构造函数时；3.当类类型的成员没有在构造函数初始值列表中显式地初始化时\n",
    "- 值初始化在以下情况下发生：1.在数组初始化的过程中如果我们提供的初始值数量少于数组的大小时；2.当我们不使用初始值定义一个局部静态变量时；3.当我们通过书写形如`T()`的表达式显式地请求值初始化时，其中`T`是类型名（vector的一个构造函数只接受一个实参用于说明vector大小，它就是使用一个这种形式的实参来对它的元素初始化器进行值初始化）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 对于C++的新手程序员来说有一种常犯的错误，它们试图以如下的形式声明一个用默认构造函数初始化的对象：\n",
    "```c++\n",
    "Sales_data obj(); // 错误：声明了一个函数而非对象\n",
    "Sales_data obj2; // 正确：obj2是一个对象而非函数\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.5.4 隐式的类类型转换"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 我们曾经介绍过C++语言在内置类型之间定义了几种自动转换规则，同样的，我们也能为类定义隐式转换规则；如果构造函数只接受一个实参，则它实际上定义了转换为此类类型的隐式转换机制，有时我们把这种构造函数称作转换构造函数（converting constructor）\n",
    "```c++\n",
    "string null_book = \"9-999-99999-9\";\n",
    "// 构造一个临时的Sales_data对象，该对象的units_sold和revenue等于0，bookNo等于null_book\n",
    "item.combine(null_book);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 只允许一步类类型转换"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```c++\n",
    "// 错误：需要用户定义的两种转换：\n",
    "// (1)把“9-999-99999-9”转换成string\n",
    "// (2)再把这个（临时的）string转换成Sales_data\n",
    "item.combine(\"9-999-99999-9\");\n",
    "\n",
    "// 正确：显式地转换成string，隐式地转换成Sales_data\n",
    "item.combine(string(\"9-999-99999-9\"));\n",
    "\n",
    "// 正确：隐式地转换成string，显式地转换成Sales_data\n",
    "item.combine(Sales_data(\"9-999-99999-9\"));\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 抑制构造函数定义的隐式转换"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 在要求隐式转换的程序上下文中，可以通过将构造函数声明为`explicit`加以阻止：\n",
    "```c++\n",
    "class Sales_data {\n",
    "public:\n",
    "    Sales_data() = default;\n",
    "    Sales_data(const std::string &s, unsigned n, double p): bookNo(s), units_sold(n), revenue(p*n) {}\n",
    "    explicit Sales_data(const std::string &s): bookNo(s) {}\n",
    "    explicit Sales_data(std::istream&);\n",
    "} // 此时，没有任何构造函数能用于隐式地创建Sales_data对象\n",
    "```\n",
    "- 关键字`explicit`只对一个实参的构造函数有效，需要多个实参的构造函数不能用于执行隐式转换，所以无须指定`explicit`；只能在类内声明构造函数时使用`explicit`关键字，在类外部定义时不应重复\n",
    "- 当我们用`explicit`声明构造函数时，它将只能以直接初始化的形式使用，而且，编译器将不会在自动转换过程中使用该构造函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 为转换显式地使用构造函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```c++\n",
    "// 正确：实参是一个显式构造的Sales_data对象\n",
    "item.combine(Sales_data(null_book));\n",
    "// 正确：static_cast可以使用explicit的构造函数，强制转换\n",
    "item.combine(static_cast<Sales_data>(cin));\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.5.5 聚合类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 聚合类（aggregate class）使得用户可以直接访问其成员，并且具有特殊的初始化语法形式，当一个类满足如下条件时，我们说它是聚合的：1.所有成员都是public的；2.没有定义任何构造函数；3.没有类内初始值；4.没有基类，也没有virtual函数\n",
    "```c++\n",
    "struct Data {\n",
    "    int ival;\n",
    "    string s;\n",
    "};\n",
    "```\n",
    "- 可以提供一个花括号括起来的成员初始值列表，并用它初始化聚合类的数据成员：\n",
    "```c++\n",
    "// 初始值的顺序必须与声明的顺序一致\n",
    "Data val1 = {0, \"Anna\"};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.6 类的静态成员"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 有的时候类需要它的一些成员与类本身直接相关，而不是与类的各个对象保持关联"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 声明静态成员"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 我们通过在成员的声明之前加上关键字static使得其与类关联在一起，和其他成员一样，静态成员可以是public的或private的，静态数据成员可以是常量、引用、指针、类类型等\n",
    "- 类的静态成员存在于任何对象之外，对象中不包含任何与静态数据成员有关的数据\n",
    "- 静态成员函数也不与任何对象绑定在一起，它们不包含this指针，作为结果，静态成员函数不能声明成const的，而且也不能在static函数体内使用this指针\n",
    "```c++\n",
    "class Account {\n",
    "public:\n",
    "    void calculate() {amount += amount * interestRate;}\n",
    "    static double rate() {return interestRate;}\n",
    "    static void rate(double);\n",
    "private:\n",
    "    std::string owner;\n",
    "    double amount;\n",
    "    static double interestRate;\n",
    "    static double initRate();\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用类的静态成员"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 使用作用域运算符直接访问静态成员\n",
    "```c++\n",
    "double r;\n",
    "r = Account::rate();\n",
    "```\n",
    "- 虽然静态成员不属于类的某个对象，但是我们任然可以使用类的对象、引用或者指针来访问静态成员\n",
    "```c++\n",
    "Account ac1;\n",
    "Account *ac2 = &ac1;\n",
    "r = ac1.rate();\n",
    "r = ac2->rate();\n",
    "```\n",
    "- 成员函数不用通过作用域运算符就能直接使用静态成员（如calculate函数）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义静态成员"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 和其它的成员函数一样，我们既可以在类的内部也可以在类的外部定义静态成员函数，当在类的外部定义静态成员时，不能重复static关键字，该关键字只出现在类内部的声明语句\n",
    "- 因为静态数据成员不属于类的任何一个对象，所以它们并不是在创建类的对象时被定义的，这意味着它们不是由类的构造函数初始化的，而且一般来说，我们不能在类的内部初始化静态成员，相反的，必须在类的外部定义和初始化每个静态成员，和其它对象一样，一个静态数据成员只能定义一次"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}