C/C++ Primer 第 I 部分 C++基础

特别需要注意的是：类型 char 和类型 signed char 并不一样。尽管字符型有三种，但是字符的表现形式却只有两种：带符号的和无符号的。类型 char 实际上会表现为上述两种形式中的一种，具体是哪种由编译器决定。

当一个算术表达式中既有无符号数又有 int 值时，那个 int 值就会转换成无符号数。

尽管整型字面值可以存储在带符号类型中，但严格来说，十进制字面值不会时负数。如果我们适用了一个形如-42 的负十进制字面值，那个负号并不在字面值之内，它的作用仅仅是对字面值取负值而已。

由单引号括起来的一个字符称为 char 型字面值，双引号括起来的零个或多个字符则构成字符串字面值。

'a'    //  字符字面值
"Hello World!"   // 字符串字面值

如果两个字符串字面值位置紧邻且仅由空格、缩进和换行符分割，则它们实际上时一个整体。当书写的字符串字面值比较长，写在一行里不太合适时，就可以采取分开书写的方式：

// 分多行书写的字符串字面值
std::cout << "a really, really long string literal "
             "that spans two lines" << std::endl;

当一次定义了两个或多个变量时，对象的名字随着定义也就马上可以使用了。因此在同一条定义语句中，可以用先定义的变量值去初始化后定义的其他变量。

WARNING

初始化不是赋值，初始化的含义时创建变量时赋予其一个初始值，而赋值的含义时把对象的当前值擦除，而以一个新值来替代。

作为 C++11 新标准的一部分，用花括号来初始化变量得到了全面应用，而在此之前这种初始化形式仅在某些收线场合才能适用。这种初始化的形式被称为 列表初始化 。现在，无论时初始化对象还是某些时候为对象赋新值，都可以适用这样一组由花括号括起来的初始值了。

当用于内置类型的变量时，这种初始化形式有一个重要特点：如果我们使用列表初始化且初始值存在丢失信息的风险，则编译器将报错：

long double ld = 3.1415926536;
int a{ld}, b = {ld};         // 错误：转换未执行，因为存在丢失信息的风险
int c(ld), d = ld;           // 正确：转换执行，切确实丢失了部分值

如果定义变量时没有执行初值，则变量被 默认初始化 ，此时变量被赋予了”默认值“。默认值到底是什么由变量类型决定，同时定义变量的位置也会对此有影响。

定义于任何函数体之外的内置类型的变量都被初始化未 0，定义在函数体内部的内质类型变量将 不被初始化 。

因为全局作用域本身没有名字，所以当作用域操作符的左侧为空时，向全局作用域发出请求获取作用域操作符右侧名字对应的变量。

#include <iostream>
// 该程序仅用于说明：函数内部不宜定义与全局变量同名的新变量
int reused = 42;

int main() {
  // 42
  std::count << reused << std::endl;
  int reused = 0;
  // 0
  std::cout << reused << std::endl;
  // 42
  std::count << ::reused << std::end;
}

C++11 新标准规定，允许将变量声明为 constexpr 类型以便由编译器来验证变量值是否是一个常量表达式。声明为 constexpr 的变量一定是一个常量，而且必须用常量表达式初始化

auto 一般会忽略掉顶层 const，同时底层 const 则会保留下来，比如当初始值是一个指向常量的指针时。如果希望推断出 auto 类型时一个顶层 const，则需要明确指出：

const auto f = ci; // ci的推演类型时int， f是const int

还可以将引用类型设为 auto，此时原来的初始化规则仍然适用。

如果 decltype 适用的表达式不是一个变量，则 decltype 返回表达式对应的类型。

另一方面，如果表达式的内容是解引用，则 decltype 将得到引用类型。正如我们所熟悉的那样，解引用指针可以得到指针所指的对象，而且还能给这个对象赋值。因此，decltype (*p)的结果类型就是 int&，而非 int。

对于 decltype 所用的表达式来说，如果变量名加上了一对括号，则得到的类型与不加括号时会有不同。如果 decltype 使用的是一个不加括号的变量，则得到的结果就是该变量的类型；如果给变量加上了一层或多层括号，编译器就会把它当成是一个表达式。变量是一种可以作为赋值语句左值的特殊表达式，所以这样的 decltype 就会得道引用类型。

WARNING

切记：decltype((variable))（注意是双层括号）的结果永远是引用，而 decltype(variable)结果只有当 variable 本身就是一个引用时才是引用。

如果使用等号（=）初始化一个变量，实际上执行的是 拷贝初始化 ，编译器把等号右侧的初始值拷贝到新创建的对象中去。与之相反，如果不使用等号，则执行的是 直接初始化 。

string s5 = "hiya";   // 拷贝初始化
string s6("hiya");    // 直接初始化

在执行读取操作时，string 对象会自动忽略开头的空白（即空格符、换行符、制表符等）并从第一个真正的字符开始读起，直到遇见下一处空白为止。

int main() {
  string s;
  cin >> s;
  cout << s << endl;
  return 0;
}

例如上述程序输入 " Hello World! " ，则输出为 "Hello" ，输出结果中没有任何空格。

如果希望能在最终得道的字符串中保留输入时的空白字符串，这时应该用 getline 函数替代原来的>>运算符。getline 只要一遇到换行符就结束读取操作并返回结果，哪怕输入的一开始就是换行符也是如此。如果输入真的一开始就是换行符，那么所得的结果是个空 string。（注意 getline 只读取而不存储换行符）。

Note:

触发 getline 函数返回的那个换行符实际上被丢掉了，得到的 string 对象并不包含换行符。

其是 size 函数返回的时一个 string::size_type 类型的值。

string 类及其他大多数标准库类型都定义了几种配套的类型。这些配套类型体验了标准库类型与机器无关的特性。类型 size_type 即是其中一种。

尽管我们不太清除 string::size_type 类型的细节，但有一点是肯定的：它是一个无符号类型的值而且能足够存放下任何 string 对象的大小。所有用于存放 string 类的 size 函数返回值的变量，都应该是 string::size_type 类型的。

Tip:

如果一条表达式中已经有了 size（）函数就不要再使用 int 了，这样可以避免混用 int 和 unsigned 可能带来的问题。

当把 string 对象和字符字面值及字符串字面值混在一条语句中使用时，必须确保每个加法运算符（+）的两侧的运算对象至少有一个时 string：

string s4 = s1 + ", ";           // 正确
string s5 = "hello" + ", ";       // 错误：两个运算对象都不是string
string s6 = s1 + ", " + "world";  // 正确：每个加发运算符都一个运算对象是string
string s7 = "hello" + ", " + s2;  // 错误：不能把字面值直接相加

WARNING:

因为某些历史原因，也为了与 C 兼容，所以 C++语言中的字符串字面值并不是标准库类型 string 的对象。切记，字符串字面值与 string 是不同的类型。

C++标准库中除了定义 C++语言特有的功能外，也兼容了 C 语言的标准库。C语言的头文件形如 name.h，C++则将这些文件命名为 cname。也就是去掉了.h 后缀，而在文件名 name 之前添加了字母 c，这里的 c 表示这是一个属于 C 语言标准库的头文件。

因此，cctype 头文件和 ctype.h 头文件的内容是一样的，只不过从命名规范上来讲更符合 C++语言的要求。特别的，在名为 cname 的头文件中定义的名字从属于命名空间 std，而定义在名为.h 的头文件中的则不然。

一般来说，C++程序应该使用名为 cname 的头文件而不使用 name.h 的形式，标准库中的名字总能在命名空间 std 中找到。如果使用.h 形式的头文件，程序员就不得不时刻牢记哪些是从 C 语言那儿继承过来的，哪些又是 C++语言所独有的。

如果想对 string 对象中的每个字符做点什么操作，目前最好的办法是使用 C++11 新标准提供的一种语句： 范围 for 语句。这种语句遍历给定序列中的每个元素并对序列的每个值执行某种操作，其语法形式是：

for (declaration : expression)
    statement

其中，expression 部分是一个对象，用于表示一个序列。declaration 部分负责定义一个变量，该变量将被用于访问序列中的基础元素。每次迭代，declaration 部分的变量会被初始化为 expression 部分的 i 想啊一个元素。

string str("some string");
for (auto c : str)
  cout << c << endl;

如果想要改变 string 对象中的字符的值，必须把循环变量定义成引用类型。记住所谓引用值是给定对象的一个别名，因此当使用引用作为循环控制变量时，这个变量实际上被依次绑定到了序列的每个元素上。使用这个引用，我们就能改变它绑定的字符。

下表运算符 （[ ]）接收的输入参数时 string::size_type 类型的值。string 对象的下表从 0 计起。

通常情况下，可以只提供 vector 对象容纳的元素数量而不用略去初始值。此时库会创建一个 值初始化 元素初值，并把它赋给容器中的所有元素。这个初值由 vector 对象中元素的类型决定。

如果 vector 对象的元素是内置类型，比如 int，则元素初始值自动设为 0.如果元素是某种类型，比如 string，则元素由类默认初始化。

对这种初始化的方式有两个特殊限制：其一，有些类要求必须明确地提供初始值（参见 2.2.1 节），如果 vector 对象中元素的类型不支持默认初始化，我们就必须提供初始化的元素值。对这种类型的对象来说，只提供元素的数量而不设定初始值无法完成初始化工作。

其二，如果只提供了元素的数量而没有设定初始值，只能使用直接初始化。

vector<int> v1(10);       // v1有10个元素，每个值都是0
vector<int> v2{10};       // v2有1个元素，该元素的值是10

vector<int> v3(10, 1);    // v3有10个元素，每个的值都是1
vector<int> v4{10, 1};    // v4有2个元素，值分别是10和1

如果用的是圆括号，可以说提供的值用来构造 vector 对象的。如果用的是花括号，可以表述成我们想列表初始化该 vector 对象。

另一方面，如果初始化时使用了花括号的形式但提供的值又不能用来列表初始化，就要考虑用这样的值来构造 vector 对象了。

vector<string> v5{"hi"};     // 列表初始化，：v5有一个元素
vector<string> v6("hi");     // 错误：不能使用字符串字面值构建vector对象
vector<string> v7{10};       // v7有10个默认初始值的元素
vector<string> v8{10, "hi"}  // v8有10个值为"hi"的元素

如果徐缓体内部包含有向 vector 对象添加元素的语句，则不能使用范围 for 循环，具体原因将在 5.4.3 节详细解释。

WARNING:

方位 for 语句体内不应改变其所遍历序列的大小。

刚接触 C++语言的程序员也许会认为可以通过 vector 对象的下标形式来添加元素，事实并非如此。如前所述，正确的方式是使用 push_back。

WARNING:

vector 对象（以及 string 对象）的下标运算符可用于方位已存在的元素，而不能用于添加元素。

迭代器使用递增（++）运算符来从一个元素移动到一下元素。从逻辑上来说，迭代器的递增和整数的递增类似，整数的递增是在整数值上”加 1“，迭代器的递增则是将迭代器”向前移动一个位置“。

NOTE:

因为 end 返回的迭代器并不实际指示某个元素，所以不能对其进行递增或解引用的操作。

关键概念：泛型编程

之前已经说过，只有 string 和 vector 等一些标准库类型有下标运算符，而并非全都如此。与此类似，所有标准库容器和迭代器都定义了==和!=，但它们中的大多数都没有定义<运算符。因此，只要我们养成使用迭代器和!=的习惯，就不用太再一用的到底是哪种容器类型。

就像不知道 string 和 vector 的 size_type 成员到底是什么类型一样，一般来说我们也不知道（其实也无需知道）迭代器的精准类型。而实际上，哪些拥有迭代器的标准库类型使用 iterator 和 const_iterator 来表示迭代器的类型：

vector<int>::iterator it;     // it 能读写vector<int>的元素
string::iterator it2;         // it2能读写string对象中的字符

vector<int>::const_iterator it3;  // it3只能读元素，不能写元素
string::const_iterator it4;       // it4只能读元素，不能写元素

为了便于专门得到 const_iterator 类型的返回值，C++新标准引入了两个新函数，分别是 cbegin 和 cend： ~auto it3 = v.cbegin(); // it3 的类型是 vector<int>::const_iterator

虽然 vector 对象可以动态的增长，但是也会有一些副作用。已知的一个限制是不能在范围 for 循环中向 vector 对象添加元素。另外一个限制是任何一种可能改变 vector 对象容量的操作，比如 push_back，都会使该 vector 对象的迭代器失效。9.3.6 节将详细解释迭代器是如何失效的。

WARNING:

谨记，但凡使用了迭代器的循环体，都不要向迭代器所属的容器添加元素。

只要两个迭代器指向的是同一个容器中的元素或者尾元素的下一位置，就能将其相减，所得结果是两个迭代器的距离。所谓距离指的是右侧的迭代器向前移动多少位置就能追上左侧迭代器，其类型是名为 different_type 的带符号整数。string 和 vector 都定义了 different_type，因为这个距离可正可负，所以 different_type 是带符号类型的。

不能将数组的内容拷贝给其他数组作为其初始值，也不能用数组为其他数组赋值：

int a[] = {0, 1, 2};
int a2[] = a;          // 错误：不允许使用一个数组初始化另一个数组
a2 = a;                // 错误，不能把一个数组直接赋给另一个数组

WARNING:

一些编译器支持数组的赋值，这就是所谓的 编译器扩展 。但一般来说，最好避免使用非标准特性，因为含有非标准它诶嗯的程序很可能在其他编译器上无法正常工作。

和 vector 一样，数组能存放大多数类型的对象。又因为数组本身就是对象，所以允许定义数组的指针及数组的引用。在这几种情况中，定义存放指针的数组比较简单和直接，但是定义数组的指针或数组的引用就稍微复杂一点了：

int *ptrs[10];       // ptrs是含有10个整型指针的数组
int &refs[10] = /* ? */;    // 错误：不不存在引用的数组
int (*Parray)[10] = &arr;   // Parray指向一个含有10个整数的数组
int (&arrRef)[10] = arr;    // arrRef引用一个含有10个整数的数组

Tip:

要想理解数组声明的含义，最好的办法是从数组的名字开始按照由内向外的顺序阅读。

C++11 新标准引入了两个名为 begin 和 end 的函数。这两个函数与容器中的两个同名成员功能类似，不过数组毕竟不是类类型，因此这两个函数不是成员函数。正确的使用形式时将数组作为它们的参数：

int ia[] = {0,1,2,3,4,5,6,7,8,9};
int *beg = begin(ia);    // 指向ia首元素的指针
int *end = end(ia);      // 指向arr尾元素的下一位置的指针

Note:

一个指针如果指向了某种内置类型数组的尾元素的“下一个位置”，则其具备与 vector 的 end 函数返回的迭代器类似的功能。特别要注意，尾后指针不能执行解引用和递增操作。

两个指针相减的结果的类型时一种名为 ptrdiff_t 的标准库类型，和 size_t 一样，ptrdiff_t 也是一种定义在 cstddef 头文件中的机器相关类型。因为差值可能为负值，所以 ptrdiff_t 时一种带符号类型。

标准库类型限定使用的下标必须粗时无符号类型，而内置的下标运算无此要求。

WARNING:

内置的下标运算符所用的索引值不是无符号类型，这一点与 vector 和 string 不一样。

任何出现字符串字面值的地方都可以用以空字符串结束的字符数组来替代：

• 允许使用以空字符结束的字符数组来初始化 string 对象或为 string 对象赋值。
• 在 string 对象的加法运算中允许使用以空字符串结束的字符数组作为其中一个运算对象（不能两个运算对象都是）；在 string 对象的复合赋值运算中允许使用以空字符结束的字符串数组作为右侧的运算对象。

上述性质反过来就不成立了。为了完成该功能，string 专门提供了一个名为 c_str 的成员函数：

char *str = s;     // 错误：不能用string对象初始化char*
const char *str = s.c_str();  // 正确

我们无法保证 c_str 函数返回的数组一直有效，事实上，如果后续的操作改变了 s 的值就可能让之前的数组失去效用。

WARNING:

如果执行完 c_str()函数后程序想一直都能使用其返回数组，最好将该数组重新拷贝一份。

可以使用数组来初始化 vector 对象。要实现这一亩的，只需要指明需要拷贝区域的首元素地址和尾后地址就可以了：

int int_arr[] = {0,1,2,3,4,5};
vector<int> ivec(begin(int_arr), end(int_arr));

C++的表格是要不然是 右值 ，要不然就是 左值 。这两个名词是从 C 语言继承过来的，原本是为了帮助记忆：左值可以位于赋值语句的左侧，右值则不能。

在 C++语言中，二者的区别就没那么简单了。一个左值表达式的求值结果是一个对象或者一个函数，然而以常量对象为代表的某些左值实际上不能作为赋值语句的左侧运算对象。此外，虽然某些表示的求值结果是对象，但它们是右值而非左值。可以做一个简单的归纳：当一个对象被用作右值的时候，用的是对象的值（内容）；当对象被用作左值的时候，用的是对象的身份（在内存中的位置）。

一个重要的原则（参见 13.6 节将介绍一种例外的情况）是在需要右值的地方可以用左值来替代，但是不能把右值当成左值（也就是位置使用）。当一个左值被当成右值使用时，实际使用的时它的内容（值）。

整型提升 负责把小整数类型转换成较大的整数类型。

如果一个运算对象是无符号类型、另一个运算对象是带符号类型，而且其中的无符号类型不小于带符号类型，那么带符号的运算对象转换成无符号的。

剩下的一种情况是带符号类型大于无符号类型，此时转换的结果依赖于机器。如果无符号类型的所有值都能存在该带符号的类型中，则无符号类型的运算对象转换成带符号类型。如果不能，那么带符号类型的运算对象转换成无符号类型。

一个命名的强制类型转换具有如下形式：

cast-name<type>(expression);

其中 type 是转换的目标类型而 expression 是要转换的值。如果 type 是引用类型，则结果是左值。cast-name 是 static_cast 、 dynamic_cast 、 const_cast 、 reinterpret_cast 中的一种 dynamic_cast 支持类型识别，我们将在 19.2 节对其左更详细的介绍。cast-name 指定了执行的是哪种转换。

任何具有明确定义的类型转换，只要不包含底层 const，都可以使用 static_cast。

const_cast 只能改变运算对象的底层 const（参见 2.4.3 节）。

对于将常量对象转换成非常量对象的行为，我们一般称其为“去掉 const 性质”

reinterpret_cast 通常为运算对象的位模式提供较低层次上的重新解释。例如：

int *ip;
char *pc = reinterpret_cast<char*>(ip);

WARNING:

reinterpret_cast 本质上依赖于机器。要想安全地使用 reinterpret_cast 必须对涉及的类型和编译器实现转换的过程都非常了解。

在早期版本的 C++语言中，显式地进行强制类型转换包含两种形式：

type (expr);            // 函数形式的强制类型转换
(type) expr;            // C语言风格的强制类型转换

根据所涉及的类型不同，旧式的强制类型转换分别具有于 const_cast、 static_cast 或 reinterpret_cast 相似的行为。当我们在某处执行旧式的强制类型转换时，如果换成 const_char 和 static_cast 也合法，则其行为与对应的命名转换一致。如果替换后不合法，则旧式强制类型转换执行与 reinterpret_cast 类似的功能：

char *pc = (char*) ip; // ip是指向整数的指针

的效果与使用 reinterpret_cast 一样。

WARNING:

于命名的强制类型转换相比，旧式的强制类型转换从表现形式来说不是那么清晰明了，容易被看漏，所以一旦转换过程出现问题，追踪起来也更加困难。

当一个 if 语句嵌套在另一个 if 语句内部时，很可能 if 分支会多于 else 分支。这时候问题出现了：我们怎么知道某个给定 else 是和哪个 if 匹配呢？

这个问题通常称作 悬垂 else ，在那些即有 if 语句又有 if else 语句的编程语句中是个普遍存在的问题。不同语言解决该问题的思路也不同，就 C++而言，它规定 else 与离它最近的尚未匹配的 if 匹配，从而消除了程序的二义性。

如前所述，siwtch 的执行流程有可能会跨过某些 case 标签。如果程序跳转到了某个特定的 case，则 switch 结果中该 case 标签之前的部分会被忽略掉。这种忽略掉一部分代码的行为引出了一个有趣的问题：如果被略过的代码中含有变量的定义该怎么办？

答案是：如果在某处一个带有初值的变量位于作用域之外，在另一处该变量位于作用域之内，则从前一处跳转到后一处的行为是非法行为。

case true:
    // 因为程序的执行流程可能绕开下面的初始化语句，所以该switch语句不何方
    string file_name;     // 错误：控制流绕过一个隐式初始化的变量
    int ival = 0;         // 错误：控制流绕过一个显示初始化的变量
    int jval;             // 正确：因为jval没有初始化
    break;
case false:
    // 正确：jval虽然在作用域内，但它没有被初始化
    jval = next_num();    // 正确：给jval赋一个值

C++语言规定，不允许跨过变量的初始化语句直接跳转到该变量作用域内的另一个位置。

在复杂系统中，程序在遇到抛出异常的代码前，其执行路径可能已经经过了多个 try 语句块。例如，一个 try 语句块可能调用了包含另一个 try 语句块的函数，新的 try 语句块可能调用了包含又一个 try 语句块的新函数，以此类推。

寻找处理代码的过程与函数调用链刚好相反。当异常被抛出时，首先搜索抛出该异常的函数。如果没有找到匹配的 catch 子句，终止该函数，并在调用该函数的函数中继续寻找。如果还是没有找到匹配的子句，这个新的函数也被终止，继续搜索调用它的函数。以此类推，沿着调成的执行路径逐层回退，知道找到适当类型的 catch 子句为止。

如果最终还是没能找到匹配的 catch 子句，程序转到名为 terminate 的标准库函数。该函数的行为与系统有关，一般情况下，执行该函数将导致程序非正常退出。

对于普通局部变量对应的对象来说，当函数的控制路径经过变量定义语句时创建该对象，当到达定义所在块末尾时销毁它。我们把只存在于块执行期间的对象称为 自动对象 。当块的执行结束后，块中创建的自动对象的值就编程未定义的了。

局部静态对象 在程序的执行路径第一次经过对象定义语句时初始化，并且直到程序终止才被销毁，再次期间即使对象所在的函数结束也不会对它有影响。

拷贝大的类类型对象或者容器对象比较低效，甚至有的类类型（包括 IO 类型在内）根本就不支持拷贝操作。当某种类型不支持拷贝操作时，函数只能通过引用形参访问该类型的对象。

Best Practies:

如果函数无须改变引用形参的值，最好将其声明为常量引用。

C++语言允许将变量定义成数组的引用（参见 3.5.1 节），基于同样的道理，形参也可以是数组的引用。此时，引用形参绑定对应的实参上，俄语就是绑定到数组上：

// 正确：形参是数组的引用，未读是类型的一部分
void print(int (&arr)[10])
{
  for (auto elem : arr)
    cout << elem << endl;
}

Note：

&arr 两端的括号必不可少（参见 3.5.1 节）

f(int &arr[10]) / 错误：将 arr 声明成了引用的数组 f(int (&arr)[10]) / 正确：arr 是具有 10 个整数的整型数组的引用

和所有数组一样，当将多维数组传递给函数时，真正传递的是指向数组首元素的指针（参见 3.6 节）。因为我们处理的是数组的数组，所以首元素本身就是一个数组，指针就是一个指向数组的指针。数组第二维（以及后面所有维度）的大小都是数组类型的一部分，不能省略：

// matrix指向数组的有元素，该数组的元素是由10个整数构成的数组
void print(int (*matrix)[10], int rowSize) { /* ... */ }

Note：

再一次强调，*matrix 两端的括号必不可少： int *matrix[10]; / 10 个指针构成的数组 int (*matrix)[10]; / 指向含有 10 个整数的数组的指针

我们也可以使用数组的语法定义函数，此时编译器会一如既往地忽略掉第一个维度，所以最好不要把它包括在形参列表内：

// 等价定义
void print(int matrix[][10], int rowSize) { /* ... */ }

matrix 的声明看起来是一个二维数组，实际上形参是指向含有 10 个整数的数组的指针。

如果函数的实参数量未知但是全部实参的类型都相同，我们可以使用 initializer_list 类型的形参。initializer_list 是一种标准库类型，用于表示某种特定类型的值的数组（参见 3.5 节）。initializer_list 类型定义在同名头文件中，它提供的操作如下表所示。

和 vector 一样，initializer_list 也是一种模板类型（参见 3.3 节）。和 vector 不一样的是，initializer_list 对象中的元素永远是常量值，我们无法改变 initializer_list 对象中元素的值。

省略符形参是为了便于 C++程序访问某些特殊的 C 代码而设置的，这些代码使用了名为 varargs 的 C 标准库功能。

WARNING：

省略符形参硬仅仅用于 C 和 C++通用的类型。特别应该注意的是，大多数类类型的对象在传递给省略符形参时都无法正确拷贝。

省略符形参只能出现在形参列表的最后一个位置，它的形式无外乎以下两种：

void foo(parm_list, ...);
void foo(...);

返回一个值的方式和初始化一个变量或形参的方式完全一样：返回的值用于初始化调用点的一个临时量，该临时量就是函数调用的结果。

函数完整后，它所占用的存储空间也随之被释放掉。因此，函数终止意味着局部变量的引用将指向不再有效的内存区域。

如前所述，返回局部对象的引用是错误的；同样，返回局部对象的指针也是错误的。一旦函数完成，局部对象被释放，指针将指向一个不存在的对象。

函数的返回类型决定函数调用是否是左值（参见 4.1.1 节）。调用一个返回引用的函数得到左值，其他返回了类型得到右值。可以像使用其他左值那样来使用返回引用的函数调用，特别是，我们能为返回类型是非常量引用的函数的结果赋值：

char &get_val(string &str, string::size_type ix){
  return str[ix];           // get_val假定索引值是有效的
}

int main {
  string s("a value");
  cout << s << endl;        // 输出a value
  get_val(s, 0) = 'A';      // 将s[0]的值改为A
  cout << s << endl;        // 输出A value

  return 0;
}

把函数调用放在赋值语句的左侧可能看起来有点奇怪，但其实这没什么特别的。返回值是引用，因此调用是个左值，和其他左值一样它也能出现在赋值运算符的左侧。

C++11 新标准规定，函数可以返回花括号的值的列表。类似于其他返回结果，此初的列表也用来对表示函数返回的临时量进行初始化。如果列表为空，临时量执行值初始化（参见 3.3.1 节）；否则，返回的值由函数的返回类型决定。

如果函数返回的内置类型，则花括号包围的列表最多包含一个值，而且该值所占空间不应该大于目标类型的空间（参见 2.2.1 节）。如果函数返回的是类类型，由类本身定义初始值如何使用（参见 3.3.1 节）。

要想在声明 func 时不适用类型别名，我们必须牢记被定义的名字后面数组的维度：

int arr[10];         // arr时一个含有10个整数的数组
int *p1[10];         // p1时一个函数10个指针的数组
int (*p2)[10] = &arr  // p2时一个指针，它指向含有10个整数的数组

和这些声明一样，如果我们想定义一个返回数组指针的函数，则数组的维度必须跟在函数名字之后。然而，函数的形参列表也跟在函数名字后面且形参列表应该先于数组的维度。因此，返回数组指针的函数形式如下所示：

Type (*function(parameter_list))[dimension]

类似于其他数组的声明，Type 表示元素的类型，dimension 表示数组的大小。(*function(parameter_list))两端的扩招 i 必须存在，就像我们定义 p2 时两端必须有括号一样。如果没有这对括号，函数的返回类型将是指针的函数。

举个具体点的例子。下面这个 func 函数的声明没有使用类型别名：

int (*func(int i))[10];

可以按照以下的顺序来逐层理解该声明的含义：

• func(int i)表示调用 func 函数时需要一个 int 类型的实参。
• (*func(int i))意味着我们可以对函数调用的结果执行解引用操作。
• (*func(int i))[10]表示解引用 func 的调用将得到一个大小时 10 的数组。
• int (*func(int i))[10]表示数组中的元素时 int 类型。

在 C++11 标准中还有一种可以简化上述 func 声明的方法，就是使用 尾置返回类型 。任何函数的定义都能使用尾置返回，但是这种形式对于返回类型比较复杂的函数最有效，比如返回类型是函数的指针或数组的引用。尾置返回类型跟在形参列表后面并以一个->符号开头。为了表示函数真正的返回类型跟在形参列表之后，我们在本应该出现返回类型的地方放置一个 auto：

// func接受一个int类型的实参，返回一个指针，该指针指向含有10个整数的数组
auto func(int i) -> int(*)[10];

还有一种情况，如果我们知道函数返回的指针将指向哪个数组，就可以使用 decltype 关键字声明返回类型。例如，下面的函数返回一个指针，该指针根据参数 i 的不同指向两个已知数组中的一个：

int odd[] = {1,3,5,7,9};
int even[] = {0,2,4,6,8};
// 返回一个指针，该指针指向含有5整数的数组
decltype(odd) *arrPtr(int i) {
  return {i % 2} ? &odd : &even;      // 返回一个指向数组的指针
}

有一个地方需要注意：decltype 并不负责把数组类型转换成对应的指针，所以 decltype 的结果是个数组，要想表示 arrPtr 返回指针还必须在函数声明时加一个*符号。

将函数指定为 内联函数 ，通常就是将它在每个调用点上“内联地”展开。

Note：

内联说明只是向编译器发出一个请求，编译器可以选择忽略这个请求。

一般来说，内联机制用于优化规模较小，流程直接、频繁调用的函数。很多编译器都不支持内联递归函数，而且一个 75 行的函数也不大可能在调用点内联地展开。

constexpr 函数 是指能用于常量表达式（参见 2.4.4 节）的函数。定义 constexpr 函数的方法与其他函数类似，不过要遵循几项约定：函数的返回类型及所有形参的类型都得是字面值类型（参见 2.4.4 节），而且函数体中必须有且只有一条 return 语句：

constexpr int new_sz() { return 42; }
constexpr int foo = new_sz();    // 正确：foo是一个常量表达式

执行该初始化任何时，编译器把对 constexpr 函数的调用替换成其结果只。为了能在编译过程中随时展开，constexpr 函数被隐式地指定为内联函数。

constexpr 函数体内也可以包含其他语句，只要这些语句在运行时不执行任何操作就行。例如，constexpr 函数中可以有空语句、类型别名（参见 2.5.1 节）以及 using 声明。

Note:

constexpr 函数不一定返回常量表达式。

和其他函数不一样，内联函数的 constexpr 函数可以在程序中多次定义。毕竟，编译器想展开函数仅有函数声明是不够的，还需要函数的定义。不过对于某个给定的内联函数或者 constexpr 函数来说，它的多个定义必须完全一致。基于这个原因，内联函数和 constexpr 函数通常定义在头文件中。

assert 是一种 预处理宏 。所谓预处理宏其实是一个预处理变量，它的行为有点类似于内联函数。assert 宏使用一个表达式作为它的条件：

assert(expr);

首先对 expr 求值，如果表达式为假（即 0），assert 输出信息并终止程序的执行。如果表达式为真（即非 0），assert 什么也不做。

assert 的行为依赖于一个名为 NDEBUG 的预处理变量的状态。如果定义了 NDEBUG，则 assert 什么也不做。默认状态下没有定义 NDEBUG，此时 assert 将执行运行时检查。

我们可以使用一个#define 语句定义 NDEBUG，从而关闭调试状态。同时，很多编译器都提供了一个命令行选项使我们可以定义预处理变量：

$ CC -D NDEBUG main.c

这条命令的作用等级与在 main.c 文件的一开始写#define NDEBUG。

除了用于 assert 外，也可以使用 NDEBUG 编写自己的条件调试代码。如果 NDEBUG 未定义，将执行#ifndef 和#endif 之间的代码；如果定义了 NDEBUG，这些代码将被忽略掉：

void print(const int ia[], size_t size) {
#ifndef NDEBUG
  // __func__ 是编译器定义的一个局部静态变量，用于存放函数的名字
  cerr << __func__ << ": array size is " << size << endl;
#endif
// ...
}

除了 C++编译器定义的__func__之外，预处理器还定义了另外 4 个对于程序调试很有用的名字：

__FILE__ 存放文件名的字符串字面值

__LINE__ 存放当前行号的整型字面值。

__TIME__ 存当文件编译时间的字符串字面值。

__DATE__ 存放文件编译时期的字符串字面值。

所有算术类型转换的级别都一样。例如，从 int 向 unsigned int 的转换并不比从 int 向 double 的转换级别高。

尽管所有成员都必须在类的内部声明，但是成员函数体可以定义在类内也可以定义在类外。

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

total.isbn()

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

Sales_date::isbn(&total)

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

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

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

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

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

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

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

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

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

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

double Sales_data::avg_price() const {
  if (units_sold)
    return revenue/units_sold;
  else
    return 0;
}

Sales_data total;
Sales_data trans;

我们没有为这些对象提供初始值，因此我们知道它们执行了默认初始化（参见 2.2.1 节）。类通过一个特殊的构造函数来控制默认值初始化过程，这个函数叫做 默认构造函数 。默认构造函数无须任何实参。

如我们所见，默认构造函数有很多方便都有其特殊性。其中之一时，如果我们的类没有显式地定义构造函数，那么编译器就会为我们隐式地定义一个默认构造函数。

编译器创建的构造函数又被称为 合成的默认构造函数 。对于大多数类来说，这个合成的默认构造函数将按照如下规则初始化类的数据成员：

• 如果存在类内的初始值（参见 2.6.1 节），则用它来初始化成员
• 否则，默认初始化（参见 2.2.1 节）该成员。

合成的默认构造函数适合非常简单的类。对于一个普通的类来说，必须定义它自己的默认构造函数，原因有三：第一个原因也是最容易理解的一个原因就是编译器只有在发现类不包含任何构造函数的情况下才会替我们生成一个默认的构造函数。一旦我们定义了一些其他的构造函数，那么除非我们再定义一个默认的构造函数，否则类将没有默认构造函数。这条规则的依据时，如果一个类在某种情况下需要控制对象初始化，那么该类很可能在所有情况下都需要控制。

第二个原因是对于某些类来说，合成的默认构造函数可能执行错误的操作。回忆我们值前介绍过的，如果定义在块中的内置类型或者复合类型（比如数组和指针）的对象被默认初始化（参见 2.2.1 节），则它们的值是未定义的。该准则同样适用于默认初始化的内置类型成员。因此，含有内置类型或复合类型成员的类应该在类的内部初始化这些成员，或者定义一个自己的默认构造函数。否则，用户在创建类的对象时可能得到未定义的值。

第三个原因是有的时候编译器不能为某些类合成默认的构造函数。例如，如果类中包含一个其他类类成员且这个成员的类型没有默认构造函数，那么编译器将无法初始化该成员。对于这样的函数，我们必须自定义默认构造函数，否则该类将没有可用的默认构造函数。

我们从解释默认构造函数的含义开始：

Sales_data() = default

首先请明确一点：因为该构造函数不接受任何实参，所以它是一个默认构造函数。我们定义这个构造函数的目的仅仅是因为我们既需要其他形式的构造函数，也需要默认的构造函数。我们希望这个函数的作用完全等同于值前使用的合成默认构造函数。

在 C++新标准中，如果我们需要默认的行为，那么可以通过在参数列表后面写上 = defualt 来要求编译器生成构造函数。其中，= default 既可以和声明一起出现在类的内部，也可以作用定义出现在类的外部。和其他函数一样，如果= default 在类的内部，则默认构造函数是内联的；如果它在类的外部，则该成员默认情况下不是内联的。

Sales_data(const std::string &s) : bookNo(s) {  }
Sales_data(const std::string &s, unsigned n, double p):
           bookNo(s), units_sold(n), revenue(p*n) {  }

这两个定义中出现了新的部分，即冒号以及冒号和花括号之间的代码，其中花括号定义了（空的）函数体。我们把新出现的部分称为 构造函数初始值列表 ，它负责为新创建的对象的一个或几个数据成员赋初值，构造函数初始值是成员名字的一个列表，每个名字后面紧跟括号括起来的（或者在花括号内的）成员初始值。不同成员的初始化通过逗号分隔开来。

当某个数据成员被构造函数初始值列表忽略时，它将以于合成默认构造函数相同的方式隐式初始化。

Best Practies:

构造函数不应该轻易覆盖掉类内初始值，除非新赋值的值与原值不同。如果你不能使用类内初始值，则所有构造函数都应该显式地初始化每个内置类型的成员。

有一点需要注意，在上面的两个构造函数中函数体都是空的。这是因为这些构造函数的唯一目的就是为数据成员赋初值，一旦没有其他任务需要执行，函数体也就为空了。

构造函数没有返回类型，所以定义从指定的函数名字开始。和其他成员函数一样，当我们在类的外部定义构造函数时，必须指明该构造函数时哪个类的成员。

没有出现在构造函数初始值列表中的成员将通过相应的类内初始值（如果存在的话）初始化，或者执行默认初始值。

尽管编译器能替我们合成拷贝、赋值和销毁的操作，但是必须要清楚的一点是，对于某些类来说合成的版本无法正常工作。特别是，当类需要分配类对象之外的资源时，合成的版本常常会失效。

不过值的注意的是，很多需要动态内存的类能（而且应该）使用 vector 对象或者 string 对象管理必要的存储空间。使用 vector 或者 string 的类能避免分配和释放内存带来的复杂性。

友元的声明仅仅指定了访问的权限，而非一个通常意义上的函数声明。如果我希望类的用户能够调用某个友元函数，那么我们就必须在友元声明之外再专门对函数进行一次声明。

为了使友元对类的用户可见，我们通常把友元的声明与类本身放置再同一个头文件中（类的外部）。

除了定义数据和函数成员之外，类还可以自定义某种类型在类中的别名。由类定义的类型名字和其他成员一样存当访问限制，可以是 public 或者 private 中的一种：

class Screen {
public:
  typedef std::string::size_type pos;
private:
  pos curosr = 0;
  pos heigh = 0, width = 0;
  std::string contents;
};

用来定义类型的成员必须先定义后使用，这一点与普通成员有所区别，具体原因将在 7.4.1 节解释。因此，类型成员通常出现在类开始的地方。

我们可以在类的内部把 inline 作用声明的一部分显式地声明成员函数，同样的，也能在类的外部用 inline 关键字修时函数的定义。

虽然我们无须在声明和定义的地方同时说明 inline，但这么做其实是合法的。不过，最好只在类外部定义的地方说明 inline，这样可以使类更加容易理解。

Note：

和我们在头文件中定义 inline 函数的原因一样（参见 6.5.2 节），inline 成员函数也应该与相应的类定义在同一个头文件中。

有时（但并不频繁）会发生这样一种情况，我们希望能修改类的某个数据成员，即是在一个 const 成员函数内。可以通过在变量的声明中加入 mutable 关键字做到这一点。

一个 可变数据成员 永远不会是 const，即是它是 const 对象的成员。因此，一个 const 成员函数可以改变一个可变成员的值。

class Screen {
public:
  void some_member() const;
private:
  mutable size_t access_ctr;   // 即是在一个const对象内也能呗修改
  // ...
};

void Screen::some_member() const {
  ++access_ctr;
  // ...
}

Note：

当我们提供一个类内初始值时，必须以符号=或者花括号表示

Note：

一个 const 成员函数如果以引用的形式返回*this，那么它的返回类型将是常量引用。

就像可以把函数的声明和定义完全分离开来（参见 6.1.2 节），我们也能仅仅声明类而暂时不定义它：

class Screen; // Screen类的声明

这种声明有时被称作 前向声明 ，它向程序中引入了名字 Screen 并且指明 Screen 时一种类类型。对于类型 Screen 来说，在它声明之后定义之前时一个 不完全类型 ，也就是说，此时我们已知 Screen 时一个类类型，但时不清楚它刀第包含哪些成员。

不完全类型只能在非常有限的情景下使用：可以定义指向这种类型的指针或引用，也可以声明（但是不能定义）以不完全类型作为参数或者返回类型的函数。

在 7.6 节中我们将描述一种例外的情况：直到类被定义之后数据成员才能被声明成这种类类型。换句话说，我们必须首先完成类的定义，然后编译器才能直到存储该数据成员需要多少空间。因为只有当类全部完成后类才算被定义，所以一个类的成员类型不能是该类自己。然而，一旦以各类的名字出现后，它就是被认为是声明过了（但尚未定义），因此类允许包含指向它自身类型的引用或指针：

class Link_screen {
  Screen window;
  Link_screen *next;
  Link_screen *prev;
};

class Screen {
  // Windows_mgr的成员可以访问Screen类的私有部分
  friend class Windows_mgr;
  // ...
};

如果一个类指定了友元类，则友元类的成员函数可以访问词类包括非公有成员在内的所有成员。

必须要注意的一点是，友元关系不存在传递性。也就是说，如果 Windows_mgr 有它自己的友元，则这些友元并不能理所当然地具有访问 Screen 的特权。

Note：

每个类负责控制自己的友元类或友元函数。

当把一个成员函数声明成友元时，我们必须明确指出该成员函数属于哪个类：

class Screen {
  // Windows_mgr::clear必须在Sceen类之前被声明
  friend void Windows_mgr::clear(ScreenIndex);
  // ....
};

要想令某个成员函数作为友元，我们必须仔细组织程序的结果以满足声明和定义的彼此依赖关系。在这个例子中，我们必须按照如下方式设计程序：

• 首先定义 Window_mgr 类，其中声明 clear 函数，但是不定义它。在 clear 使用 Screen 的成员之前必须先声明 Screen。
• 接下来定义 Screen，包括对于 clear 的友元声明
• 最后定义 clear，此时它才可以使用 Screen 的成员。

尽管重载函数的名字相同，但它们仍然是不同的函数。因此，如果一个类想把一组重载函数声明成它的友元，它需要对这组函数中的每个分别声明。

类和非成员函数的声明不是必须在它们的友元声明之前。当一个名字第一次出现在一个友元声明中时，我们隐式地假定该名字在当前作用域中是可见的。然而，友元本身不一定真的声明在当前作用域中（参见 7.2.1 节）。

甚至就算在类的内部定义该函数，我们也必须在类的外部提供相应的声明从而使得函数可见。换句话说，即使我们仅仅是用声明友元的类的成员调用该友元函数，它也必须是被声明过的：

struct X {
  friend void f() { /* 友元函数可以定义在类的内部 */ }
  X() { f(); }                     // 错误：f还没又被声明
  void g();
  void h();
};
void X::g() { return f(); }        // 错误：f还没又被声明
void f();                          // 声明那个定义在X中的函数
void X::h() { return f(); }        // 正确：现在f声明在作用域中了

Note：

请注意，有的编译器并不强制执行上述有关友元的限制规则（参见 7.2.1 节）。

这两种阶段的处理方式只适用于成员函数中使用的名字。声明中使用的名字，包括返回类型或者参数列表中使用的名字，都必须在使用前确保可见。如果某个成员声明使用了类中尚未出现的名字，则编译器将会在定义该类的作用域中继续查找。

一般来说，内层作用域可以重新定义外层作用域中的名字，即是该名字已经在内层作用域中使用过。然而在类中，如果成员使用了外层作用域中的某个名字，而该名字代表一种类型，则类不能在之后重新定义该名字。

Tip:

类型名的定义通常出现在类的开始初，这样就能确保所有使用该类的成员都出现在类名的定义之后。

成员函数中使用的名字按照如下方式解析：

• 首先，在成员函数内查找该名字的声明。和前面一样，只有在函数使用之前出现的声明才被考虑。
• 如果在成员函数内没有找到，则在类内继续查找，这时类的所有成员函数都可以被考虑。
• 如果类内也没找到该名字的声明，在成员函数定义之前的作用域内继续查找。

当成员定义在类的外部时，名字查找的第三不不仅要考虑定义之前的全局作用域中的声明，还需要考虑在成员函数定义之前的全局作用域中的声明。

有时我们可以忽略数据成员初始化和赋值之间的差异，但并非总能这样。如果成员是 const 或者是引用的话，必须将其初始化。类似的，当成员属于某种类类型且该类没有定义默认构造函数时，也必须将这个成员函数初始化。

随着构造函数体一开始执行，初始化就完成了。我们初始化 const 或者引用类型的数据成员的唯一机会就是通过构造函数初始值。

Note：

如果成员是 const、引用，或者属于某种未提供默认构造函数的类类型，我们必须通过构造函数初始值列表为这些成员提供初值。

建议：使用构造函数初始值

在很多类中，初始化和赋值的区别事关底层效率问题：前者直接初始化数据成员，后者则先初始化再赋值。

除了效率问题外更重要的是，一些数据成员必须被初始化。建议读者养成使用构造函数初始值的习惯，这样能避免某些意想不到的编译错误，特别是遇到有的类含有需要构造函数初始值的成员时。

成员的初始化顺序与它们在类定义中出现顺序一致：第一个成员先被初始化，然后第二个，以此类推。构造函数初始值列表中初始值的前后位置关系不会影响实际的初始化顺序。

Best Practies：

最好令构造函数初始值的顺序与成员声明的顺序保持一致。而且如果可能的话，尽量避免使用某些成员初始化其他成员。

Note：

如果一个构造函数为所有参数都提供了默认实参，则它实际上也定义了默认构造函数。

在 4.11.2 节中我们指出，编译器只会自动地执行一步类型转换。

在要求隐式转换的程序上下文中，我们可以通过将构造函数声明为 explicit 加以阻止：

class Sales_data {
public:
  Sales_data() = default;
  Sales_data(const std::string &s, unsigned n, double p):
             bookNo(s), units_sold(n), revenue(p*n) {  }
  explicit Sales_data(const std::string &s) : bookNo(s) {  }
  explicit Sales_data(std::istream&);
  // ...
};

此时，没有任何构造函数能用于隐式地创建 Sales_data 对象，之前的两种用法都无法通过编译：

item.combine(null_book);      // 错误：string构造函数时explicit的
item.combine(cin);            // 错误：istream构造函数时explicit的

关键字 explicit 只对一个实参的构造函数有效。需要多个实参的构造函数不能用于隐式转换，所以无法将这些构造函数指定为 explicit 的。只能在类内声明构造函数时使用 explicit 关键字，在类外部定义时不应重复。

发生隐式转换的一种情况是当我们执行拷贝形式的初始化时（使用=）。此时，我们只能使用直接初始化而不能使用 explicit 构造函数。

Note：

当我们用 explicit 关键字声明构造函数时，它将只能以直接初始化的形式使用。而且编译器将不会在自动转换过程中使用该构造函数。

尽管编译器不会将 explicit 的构造函数用于隐式转换过程，但是我们可以使用这样的构造函数显式地强制进行转换。

我们用过的一些标准库中的类含有单参数的构造函数：

• 接受一个单参数的 const char*的 string 构造函数不是 explicit 的。
• 接受一个容量参数的 vector 构造函数时 explicit 的。

尽管构造函数不能是 const 的，单字面值常量类的构造函数可以是 constexpr 函数。事实上，一个字面值常量类必须至少提供一个 constexpr 构造函数。

constexpr 构造函数可以声明称=default 的形式（或者是删除函数的形式）。否则，constexpr 构造函数就必须既符合构造函数的要求（意味着不能包含返回语句），又复合 constexpr 函数的要求（意味着它能拥有的唯一可执行语句就是返回语句（参见 6.5.2 节））。综合这两点可知，constexpr 构造函数体一般来说应该是空的。我们通过前置关键字 constexpr 就可以声明一个 constexpr 构造函数了。

constexpr 构造函数必须初始化所有数据成员，初始值或者使用 constexpr 构造函数，或者是一条常量表达式。