【C++】类与对象(末):static、友元与拷贝优化

🔥 H.莓飛: 个人主页
✨ 心不畏死,踏屍前行。
📦 代码仓库:cocatrice_csdn_code
📖 博主简介:

概览
- 构造函数体与初始化列表
- 初始化顺序与未初始化的内置类型成员
- 类型转换与 explicit
- static 成员变量与 static 成员函数
- 静态成员的典型用途
- 友元函数与友元类
- 内部类与匿名对象
- 拷贝时的编译器优化
核心知识
类的六个默认成员函数在前面已经逐个展开过,构造函数怎么写、析构函数什么时候被调用、拷贝构造与赋值重载怎么区分,这几件事都已经落到代码上。这一篇要处理构造函数身上剩下的几个疑问:冒号后面那一串到底做了什么,一个类里有好多个成员时谁先被初始化,只写声明不写初值的 int 成员在读出来的时候是什么值。
剩下的篇幅分给另外几件在写代码时容易出错的事情。单参构造函数会把一个 int 悄悄变成类对象,这个转换有时有用,有时会在重载解析里插一脚。静态成员属于类而不属于对象,它的存储位置与访问方式都和普通成员不同。友元为突破封装而存在,单向、不传递,用一次耦合就多一分。内部类与匿名对象是两处语法糖,前者让关联紧密的两个类贴在一起,后者让一次性调用的对象不必起名字。
编译器的拷贝省略这一件事放在最后三节里讲。它不影响程序正确性,却会让所有靠打印计数得到的结论失准,所以这一篇的实测都带上编译选项,把优化开着与关掉的两种结果并排摆出来。

图 1 从初始化列表到匿名对象的一条主线
一、构造函数体与初始化列表
构造函数有两个执行阶段,写惯了函数体赋值的人容易把这件事忽略掉。成员在进入函数体之前就已经构造完毕,函数体里写的语句属于赋值;真正决定成员初值的地方是初始化列表(member initializer list),也就是构造函数名后面那个冒号引出来的部分。两者在语义上差别很大,对内置类型来说结果看起来一样,对引用、const 成员、以及没有默认构造函数的类类型成员来说,能写的位置只有一个。
下面这个例子把两个阶段都用打印标出来。Date 里放了一个 Time 类型的成员 _t,Time 的构造函数在函数体里打印一行,Date 的构造函数在函数体里打印一行,运行之后哪一行先出现在屏幕上,就说明哪个阶段先执行。同一份代码里还放了声明处缺省值与初始化顺序两个对照组,后面会分别用到。
1// 文件:/home/cocatrice/cpp05/demo/init_list.cpp 2#include <iostream> 3using namespace std; 4 5class Time 6{ 7public: 8 Time(int hour = 0) 9 : _hour(hour) 10 { 11 cout << "Time 的构造函数体:_hour = " << _hour << endl; 12 } 13 14 int GetHour() const 15 { 16 return _hour; 17 } 18 19private: 20 int _hour; 21}; 22 23class Date 24{ 25public: 26 Date(int year, int month, int day, int& ref) 27 : _year(year) 28 , _month(month) 29 , _t(12) 30 , _ref(ref) 31 , _n(1) 32 { 33 cout << "Date 的构造函数体开始执行" << endl; 34 _day = day; 35 } 36 37 void Print() const 38 { 39 cout << _year << "-" << _month << "-" << _day 40 << ",_t = " << _t.GetHour() 41 << ",_ref = " << _ref 42 << ",_n = " << _n << endl; 43 } 44 45private: 46 int _year; 47 int _month; 48 int _day; 49 Time _t; 50 int& _ref; 51 const int _n; 52}; 53 54class Default 55{ 56public: 57 Default(int& ref) 58 : _ref(ref) 59 {} 60 61 void Print() const 62 { 63 cout << _year << "-" << _month << "-" << _day 64 << ",_t = " << _t.GetHour() 65 << ",_n = " << _n << endl; 66 } 67 68private: 69 int _year = 1; 70 int _month = 1; 71 int _day; 72 Time _t = 1; 73 int& _ref; 74 const int _n = 1; 75}; 76 77class Item 78{ 79public: 80 Item(const char* name) 81 : _name(name) 82 { 83 cout << "初始化 " << _name << endl; 84 } 85 86private: 87 const char* _name; 88}; 89 90class Order 91{ 92public: 93 Order() 94 : _b("第二行") 95 , _a("第一行") 96 {} 97 98private: 99 Item _a; 100 Item _b; 101}; 102 103int main() 104{ 105 int year = 2025; 106 Date d1(2024, 7, 14, year); 107 d1.Print(); 108 109 cout << "---- 声明处给了缺省值的对象 ----" << endl; 110 Default d2(year); 111 d2.Print(); 112 113 cout << "---- 初始化顺序看声明,不看列表 ----" << endl; 114 Order o; 115 return 0; 116} 117
1# 所属目录:/home/cocatrice/cpp05/demo 2init_list.cpp: In constructor ‘Order::Order()’: 3init_list.cpp:100:7: warning: ‘Order::_b’ will be initialized after [-Wreorder] 4 Item _b; 5 ^ 6init_list.cpp:99:7: warning: ‘Item Order::_a’ [-Wreorder] 7 Item _a; 8 ^ 9init_list.cpp:93:2: warning: when initialized here [-Wreorder] 10 Order() 11 ^ 12$ ./init_list 13Time 的构造函数体:_hour = 12 14Date 的构造函数体开始执行 152024-7-14,_t = 12,_ref = 2025,_n = 1 16---- 声明处给了缺省值的对象 ---- 17Time 的构造函数体:_hour = 1 181-1-4197597,_t = 1,_n = 1 19---- 初始化顺序看声明,不看列表 ---- 20初始化 第一行 21初始化 第二行 22
回显的第一行是 Time 的构造函数体,说明初始化的动作发生在函数体之前,_t(12) 这一条已经把 Time 的构造函数跑完了,Date 自己的函数体才轮到执行。顺序颠倒过来写不会有任何变化,初始化列表里各项的书写顺序不参与决定执行的先后。Date 的构造函数把 _day 放在函数体里赋值,这个成员因此没有走初始化列表,稍后会看到它的值有多不可靠。

图 2 一个对象构造时走的两步
初始化列表在写法上有几条必须遵守的规矩。它必须以冒号开始,各项之间用逗号分隔,每个成员后面跟一对括号,括号里放初值或者表达式。同一个成员在列表里只能出现一次,重复写会让编译器直接报错,报错信息里点名说这个成员被初始化了多次。
1# 所属目录:/home/cocatrice/cpp05/demo 2err9.cpp: In constructor ‘A::A(int)’: 3err9.cpp:8:2: error: multiple initializations given for ‘A::_a1’ 4 A(int a) 5 ^ 6
哪几类成员必须写在初始化列表里,这是最常考的一点。引用成员没有默认值可赋,const 成员一旦构造完成就不能再改,没有默认构造函数的类类型成员拿不到一个可用的初始状态,这三类成员如果不写进列表,编译器会在构造函数的位置停下。三份报错分别针对这三种情况,其中引用与 const 两份带 -fpermissive 标记,意思是加上这个选项就能降级成警告放过去,代价是把问题留到运行期。
1# 所属目录:/home/cocatrice/cpp05/demo 2err2.cpp: In constructor ‘Date::Date(int)’: 3err2.cpp:8:2: error: uninitialized reference member ‘Date::_ref’ [-fpermissive] 4 Date(int year) 5 ^ 6
1# 所属目录:/home/cocatrice/cpp05/demo 2err3.cpp: In constructor ‘Date::Date(int)’: 3err3.cpp:8:2: error: uninitialized member ‘Date::_n’ with ‘const’ type ‘const int’ [-fpermissive] 4 Date(int year) 5 ^ 6
1# 所属目录:/home/cocatrice/cpp05/demo 2err1.cpp: In constructor ‘Date::Date(int)’: 3err1.cpp:20:15: error: no matching function for call to ‘Time::Time()’ 4 : _year(year) 5 ^ 6err1.cpp:20:15: note: candidates are: 7err1.cpp:8:2: note: Time::Time(int) 8 Time(int hour) 9 ^ 10err1.cpp:8:2: note: candidate expects 1 argument, 0 provided 11err1.cpp:5:7: note: constexpr Time::Time(const Time&) 12 class Time 13 ^ 14err1.cpp:5:7: note: candidate expects 1 argument, 0 provided 15err1.cpp:5:7: note: constexpr Time::Time(Time&&) 16err1.cpp:5:7: note: candidate expects 1 argument, 0 provided 17
第一份报错针对引用成员 _ref,第二份针对 const 成员 _n,第三份针对 Time 类型成员 _t。第三份的信息最长,编译器把三个候选构造函数列了出来,Time::Time(int) 需要一个参数却拿到零个,编译器合成的拷贝构造与移动构造同样需要一个参数。看懂了这份输出,就明白为什么没有默认构造的类类型成员必须在列表里逐个喂初值。
C++11 起还可以在成员声明的位置直接给缺省值,写法与初始化列表不冲突,两者的关系是列表优先。一个成员既在声明处给了缺省值、又出现在初始化列表里,最终生效的是列表里的那一份;反过来,一个成员只有声明处的缺省值,那么所有没在列表里提到它的构造函数,都会用这个缺省值初始化它。测试机上的 g++ 4.8.5 对这项特性的态度值得记一笔,加上 -std=c++11 一切正常,换成 -std=c++98 只给出警告而不是错误,程序照样算出 1。
1# 所属目录:/home/cocatrice/cpp05/demo 2$ ./err10 31 4
1# 所属目录:/home/cocatrice/cpp05/demo 2err10.cpp:14:11: warning: non-static data member initializers only available with -std=c++11 or -std=gnu++11 [enabled by default] 3 int _a = 1; 4 ^ 5$ ./err10_98 61 7
既然每个成员都要走初始化列表,那么没写进列表的成员会走到哪里去,就成了一个必须回答的问题。答案是它也会走初始化列表,用声明处的缺省值,或者用默认构造。内置类型没有默认构造,编译器也不会替它清零,于是读到什么值取决于这块内存上原来放着什么。实测里把 _day 从列表里拿掉之后,同一个程序在 -O0 下打印 4197597,在 -O2 下打印 4197142,两个数字都没有意义,编译器对这种情况一个字也不提醒,因为后面要不要给 _day 赋值它看不出来。
1# 所属目录:/home/cocatrice/cpp05/demo 2$ ./init_list_O2 3Time 的构造函数体:_hour = 12 4Date 的构造函数体开始执行 52024-7-14,_t = 12,_ref = 2025,_n = 1 6---- 声明处给了缺省值的对象 ---- 7Time 的构造函数体:_hour = 1 81-1-4197142,_t = 1,_n = 1 9---- 初始化顺序看声明,不看列表 ---- 10初始化 第一行 11初始化 第二行 12
初始化顺序是这一节最容易被忽略的一条。成员按照它们在类里声明的先后被初始化,与初始化列表里写的先后没有关系,编译器对顺序不一致的情况会给一条 -Wreorder 警告。init_list.cpp 里既有这个警告也有一组直接观察顺序的打印,Order 类里 _a 声明在前、_b 声明在后,构造函数把 _b 写在列表前面,运行时先打印的仍然是 _a 那一行。
顺序写反的危害在内置类型上看得更清楚。下面这个 edge.cpp 里 _a2 声明在 _a1 之前,列表里先写 _a1(a) 再写 _a2(_a1),本意是让 _a2 拿到 _a1 的值,实际执行时 _a2 先被初始化,它读到的是 _a1 尚未初始化的内容。关掉优化时打印 32765,打开 -O2 时打印 0,两个值都是垃圾数据,区别只在于栈上原先留着什么。为了排除偶然性,同一个程序里用定位 new(placement new)把一块内存先写成 0x55 再在上面构造对象,取出的成员正好是 1431655765,也就是 0x55555555。
1// 文件:/home/cocatrice/cpp05/demo/edge.cpp 2#include <iostream> 3#include <cstring> 4#include <new> 5using namespace std; 6 7class Reorder 8{ 9public: 10 Reorder(int a) 11 : _a1(a) 12 , _a2(_a1) 13 {} 14 15 void Print() const 16 { 17 cout << "_a1 = " << _a1 << ",_a2 = " << _a2 << endl; 18 } 19 20private: 21 int _a2; 22 int _a1; 23}; 24 25class Uninit 26{ 27public: 28 Uninit() 29 {} 30 31 void Print() const 32 { 33 cout << "_a = " << _a << ",_b = " << _b << endl; 34 } 35 36private: 37 int _a; 38 int _b; 39}; 40 41int main() 42{ 43 Reorder r(1); 44 r.Print(); 45 46 char* raw = new char[sizeof(Uninit)]; 47 memset(raw, 0x55, sizeof(Uninit)); 48 Uninit* p = new (raw) Uninit(); 49 p->Print(); 50 cout << "这块内存事先被写成了 0x55,0x55555555 = " << 0x55555555 << endl; 51 p->~Uninit(); 52 delete[] raw; 53 54 int arr[3] = { 1, 2, 3 }; 55 cout << "sizeof(arr) = " << sizeof(arr) << ",数组名不退化" << endl; 56 return 0; 57} 58
1# 所属目录:/home/cocatrice/cpp05/demo 2edge.cpp: In constructor ‘Reorder::Reorder(int)’: 3edge.cpp:22:6: warning: ‘Reorder::_a1’ will be initialized after [-Wreorder] 4 int _a1; 5 ^ 6edge.cpp:21:6: warning: ‘int Reorder::_a2’ [-Wreorder] 7 int _a2; 8 ^ 9edge.cpp:10:2: warning: when initialized here [-Wreorder] 10 Reorder(int a) 11 ^ 12edge.cpp: In constructor ‘Reorder::Reorder(int)’: 13edge.cpp:22:6: warning: ‘Reorder::_a1’ will be initialized after [-Wreorder] 14 int _a1; 15 ^ 16edge.cpp:21:6: warning: ‘int Reorder::_a2’ [-Wreorder] 17 int _a2; 18 ^ 19edge.cpp:10:2: warning: when initialized here [-Wreorder] 20 Reorder(int a) 21 ^ 22edge.cpp: In function ‘int main()’: 23edge.cpp:12:12: warning: ‘r.Reorder::_a1’ is used uninitialized in this function [-Wuninitialized] 24 , _a2(_a1) 25 ^ 26edge.cpp:43:10: note: ‘r’ was declared here 27 Reorder r(1); 28 ^ 29$ ./edge_O0 30_a1 = 1,_a2 = 32765 31_a = 1431655765,_b = 1431655765 32这块内存事先被写成了 0x55,0x55555555 = 1431655765 33sizeof(arr) = 12,数组名不退化 34 35$ ./edge_O2 36_a1 = 1,_a2 = 0 37_a = 1431655765,_b = 1431655765 38这块内存事先被写成了 0x55,0x55555555 = 1431655765 39sizeof(arr) = 12,数组名不退化 40

图 3 成员按声明顺序初始化
二、类型转换
一个只带一个参数、并且没有加 explicit 的构造函数,在编译器眼里同时是一份转换规则。写 A aa1 = 1; 的时候,编译器先调用 A(int) 构造一个临时的 A 对象,再用这个临时对象去初始化 aa1。这一路走下来本该有一次构造加一次拷贝构造,实际运行时只打印了一次构造,原因在最后三节会讲清楚,编译器把中间那份临时对象省掉了。
构造函数的入口除了上面那种还能接受这几种写法。const A& aa2 = 3; 用一个 const 引用接住转换出来的临时对象,临时对象的生命周期被延长到引用的作用域结束。A aa3 = {2, 2}; 用花括号把两个参数喂给双参构造函数,这是 C++11 起才有的列表初始化(list initialization),在 -std=c++98 下编不过。类类型之间同样能互相转换,只要目标类型存在一个接受源类型的构造函数,B b = aa3; 就会调用 B(const A&)。
1// 文件:/home/cocatrice/cpp05/demo/convert.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A(int a = 0) 9 : _a1(a) 10 , _a2(a) 11 { 12 cout << "A(int) 构造,两个成员都是 " << a << endl; 13 } 14 15 A(int a1, int a2) 16 : _a1(a1) 17 , _a2(a2) 18 { 19 cout << "A(int, int) 构造," << a1 << " 与 " << a2 << endl; 20 } 21 22 int GetA1() const 23 { 24 return _a1; 25 } 26 27 int GetA2() const 28 { 29 return _a2; 30 } 31 32private: 33 int _a1; 34 int _a2; 35}; 36 37class B 38{ 39public: 40 B(const A& a) 41 : _b(a.GetA1() + a.GetA2()) 42 { 43 cout << "B(const A&) 构造,A 的两个成员相加得到 " << _b << endl; 44 } 45 46private: 47 int _b; 48}; 49 50class C 51{ 52public: 53 C(int c = 0) 54 : _c(c) 55 {} 56 57 operator int() const 58 { 59 cout << "operator int() 被调用一次" << endl; 60 return _c; 61 } 62 63private: 64 int _c; 65}; 66 67class D 68{ 69public: 70 D(int d = 0) 71 : _d(d) 72 {} 73 74 explicit operator int() const 75 { 76 cout << "explicit operator int() 被调用一次" << endl; 77 return _d; 78 } 79 80private: 81 int _d; 82}; 83 84int main() 85{ 86 cout << "---- 单参构造带来的隐式转换 ----" << endl; 87 A aa1 = 1; 88 const A& aa2 = 3; 89 A aa3 = {2, 2}; 90 91 cout << "---- 类类型之间的隐式转换 ----" << endl; 92 B b = aa3; 93 const B& rb = aa3; 94 95 cout << "---- 转换运算符被自动调用 ----" << endl; 96 C c(7); 97 int x = c; 98 cout << "int x = c 之后 x = " << x << endl; 99 cout << "c + 1 = " << c + 1 << endl; 100 cout << "c > 1 的结果是 " << (c > 1) << endl; 101 102 cout << "---- explicit 的转换运算符只能显式调用 ----" << endl; 103 D d(9); 104 int y = (int)d; 105 cout << "int y = (int)d 之后 y = " << y << endl; 106 return 0; 107} 108
1# 所属目录:/home/cocatrice/cpp05/demo 2convert.cpp: In function ‘int main()’: 3convert.cpp:87:4: warning: variable ‘aa1’ set but not used [-Wunused-but-set-variable] 4 A aa1 = 1; 5 ^ 6convert.cpp:88:11: warning: unused variable ‘aa2’ [-Wunused-variable] 7 const A& aa2 = 3; 8 ^ 9convert.cpp:92:4: warning: variable ‘b’ set but not used [-Wunused-but-set-variable] 10 B b = aa3; 11 ^ 12convert.cpp:93:11: warning: unused variable ‘rb’ [-Wunused-variable] 13 const B& rb = aa3; 14 ^ 15$ ./convert 16---- 单参构造带来的隐式转换 ---- 17A(int) 构造,两个成员都是 1 18A(int) 构造,两个成员都是 3 19A(int, int) 构造,2 与 2 20---- 类类型之间的隐式转换 ---- 21B(const A&) 构造,A 的两个成员相加得到 4 22B(const A&) 构造,A 的两个成员相加得到 4 23---- 转换运算符被自动调用 ---- 24operator int() 被调用一次 25int x = c 之后 x = 7 26operator int() 被调用一次 27c + 1 = 8 28operator int() 被调用一次 29c > 1 的结果是 1 30---- explicit 的转换运算符只能显式调用 ---- 31explicit operator int() 被调用一次 32int y = (int)d 之后 y = 9 33
编译阶段的两条警告与转换无关,属于变量定义了却没有使用,编译器也会提醒一句。回显里的转换线索集中在构造函数的打印上,四次转换各打印了一次构造,拷贝构造一次都没有出现。转换运算符的部分值得单独看:C 类里定义了 operator int() const,于是 int x = c、c + 1、c > 1 三处都在背后调用了它,回显里三行「operator int() 被调用一次」对应的是同一个函数。
转换的方向反过来说也成立,一个类可以同时作为转换的起点与转换的终点,这两种规则凑在一起时编译器的选择会变得微妙,本章不做展开。把隐式转换关掉的办法是给构造函数加 explicit,加上之后 A aa1 = 1; 这类写法会被拒绝,编译器给出的信息是没法把 int 转成 A。
1# 所属目录:/home/cocatrice/cpp05/demo 2err8.cpp: In function ‘int main()’: 3err8.cpp:18:10: error: conversion from ‘int’ to non-scalar type ‘A’ requested 4 A aa1 = 1; 5 ^ 6
转换运算符前面也能加 explicit。D 类里的 explicit operator int() const 只在显式写法下生效,实测中 int y = (int)d 能过,把括号去掉就编不过了。判断一个隐式转换会不会发生,看的就是这条规则:构造函数与转换运算符只要没被 explicit 拦住,编译器就会在类型不匹配的时候自己动手。

图 4 单参构造的隐式转换路径
三、static 成员变量
用 static 修饰的成员变量叫静态成员变量(static member variable)。它属于类而不属于某个对象,同一个类的所有对象共用这一份,存放在静态存储区,对象本身的内存里没有它的位置。写法上分成两截,类里面只写声明,定义与初始值放在类外面的源文件里,int A::_scount = 0; 这一行的作用域是类外,所以要带上类名限定。
下面这个 static_member.cpp 把静态变量当成一个存活计数器用,构造时加一,析构时减一,中间用花括号圈出一个作用域,观察计数在块内块外的变化。地址与 sizeof 的对照也放在同一个程序里,便于一次跑完。
1// 文件:/home/cocatrice/cpp05/demo/static_member.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A() 9 : _a(0) 10 { 11 ++_scount; 12 cout << "构造,当前存活 " << _scount << " 个" << endl; 13 } 14 15 A(const A& aa) 16 : _a(aa._a) 17 { 18 ++_scount; 19 cout << "拷贝构造,当前存活 " << _scount << " 个" << endl; 20 } 21 22 ~A() 23 { 24 --_scount; 25 cout << "析构,当前存活 " << _scount << " 个" << endl; 26 } 27 28 static int GetCount() 29 { 30 return _scount; 31 } 32 33 static const int* GetStaticAddr() 34 { 35 return &_scount; 36 } 37 38 static int SGetA(int a) 39 { 40 return a; 41 } 42 43 int GetA() const 44 { 45 return _a; 46 } 47 48private: 49 int _a; 50 static int _scount; 51}; 52 53int A::_scount = 0; 54 55void Func(A aa) 56{ 57 cout << "传值传参,函数内的计数是 " << A::GetCount() << endl; 58} 59 60void FuncRef(const A& aa) 61{ 62 cout << "const 引用传参,函数内的计数是 " << A::GetCount() << endl; 63} 64 65int main() 66{ 67 cout << "程序刚开始,A::GetCount() = " << A::GetCount() << endl; 68 A aa1; 69 { 70 A aa2; 71 cout << "块内,A::GetCount() = " << A::GetCount() << endl; 72 } 73 cout << "块外,A::GetCount() = " << A::GetCount() << endl; 74 75 cout << "用对象调用静态成员函数 " << aa1.GetCount() << endl; 76 cout << "用类名调用静态成员函数 " << A::GetCount() << endl; 77 78 cout << "sizeof(A) = " << sizeof(A) << ",静态成员不占对象的空间" << endl; 79 cout << "对象 aa1 的地址 " << &aa1 << endl; 80 cout << "静态成员 _scount 的地址 " << A::GetStaticAddr() << endl; 81 cout << "sizeof 静态成员函数指针 " << sizeof(&A::SGetA) 82 << ",sizeof 非静态成员函数指针 " << sizeof(&A::GetA) << endl; 83 84 Func(aa1); 85 FuncRef(aa1); 86 return 0; 87} 88
1# 所属目录:/home/cocatrice/cpp05/demo 2$ ./static_member 3程序刚开始,A::GetCount() = 0 4构造,当前存活 1 个 5构造,当前存活 2 个 6块内,A::GetCount() = 2 7析构,当前存活 1 个 8块外,A::GetCount() = 1 9用对象调用静态成员函数 1 10用类名调用静态成员函数 1 11sizeof(A) = 4,静态成员不占对象的空间 12对象 aa1 的地址 0x7ffc770b5960 13静态成员 _scount 的地址 0x6021b4 14sizeof 静态成员函数指针 8,sizeof 非静态成员函数指针 16 15拷贝构造,当前存活 2 个 16传值传参,函数内的计数是 2 17析构,当前存活 1 个 18const 引用传参,函数内的计数是 1 19析构,当前存活 0 个 20
回显里的信息可以分成下面这三组来做对照。第一组是计数的变化,程序开始时是 0,进块前构造一个对象变成 1,块内构造第二个变成 2,出块时第二个对象析构回到 1,计数跟着对象的生死走。第二组是调用方式,aa1.GetCount() 与 A::GetCount() 得到同一个结果,静态成员函数不依赖对象就能调用。第三组是地址与大小,sizeof(A) 是 4,只算了那个 int 成员;对象 aa1 在栈上,地址是 0x7ffc770b5960;静态成员 _scount 的地址是 0x6021b4,落在数据段里,两者相差几个数量级。
静态成员的位置可以直接从符号表里读出来。用 nm 把调试符号还原成可读名字之后,_scount 显示为 B 类型,也就是未初始化数据段(.bss),而对象成员只存在于栈或者堆上,符号表里根本没有它们的名字。
1# 所属目录:/home/cocatrice/cpp05/demo 2$ nm -C static_member | grep -i scount 30000000000400cdc t _GLOBAL__sub_I__ZN1A7_scountE 400000000006021b4 B A::_scount 5
类内声明处不能给静态成员初值,这一点与前面小节里的普通成员正相反。普通成员靠声明处缺省值得到初值,静态成员在声明处写初值会被编译器直接拦下来,理由是内联初始化对非 const 的静态成员不成立。
1# 所属目录:/home/cocatrice/cpp05/demo 2err4.cpp:12:23: error: ISO C++ forbids in-class initialization of non-const static member ‘A::_scount’ 3 static int _scount = 0; 4 ^ 5
反过来,类外定义那一行如果漏写,编译阶段一切正常,错误要到链接的时候才出现。这类报错的形态与编译期完全不同,它说的是某个符号没有定义,末尾还会多出一行 collect2 的失败信息。漏写定义这种情况在分成多个源文件的项目里出现得更多,因为声明在头文件里、定义本该写在某个源文件里,两边对不上时编译器各看各的都是对的。
1# 所属目录:/home/cocatrice/cpp05/demo 2/tmp/ccLaWHQC.o: In function `A::A()': 3err6.cpp:(.text._ZN1AC2Ev[_ZN1AC5Ev]+0xa): undefined reference to `A::_scount' 4err6.cpp:(.text._ZN1AC2Ev[_ZN1AC5Ev]+0x13): undefined reference to `A::_scount' 5/tmp/ccLaWHQC.o: In function `A::GetCount()': 6err6.cpp:(.text._ZN1A8GetCountEv[_ZN1A8GetCountEv]+0x6): undefined reference to `A::_scount' 7collect2: error: ld returned 1 exit status 8
静态存储期还有一个常考的题目,就是对象的构造与析构顺序。下面这个程序里有四个类,C 类型的全局对象 c 在 main 之前构造,A 与 B 的局部对象在 main 里构造,D 类型的静态局部对象 d 只在第一次执行到声明处时构造一次,析构阶段又落在后面。
1// 文件:/home/cocatrice/cpp05/demo/dtor_order.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A() { cout << "A 构造" << endl; } 9 ~A() { cout << "A 析构" << endl; } 10}; 11 12class B 13{ 14public: 15 B() { cout << "B 构造" << endl; } 16 ~B() { cout << "B 析构" << endl; } 17}; 18 19class C 20{ 21public: 22 C() { cout << "C 构造" << endl; } 23 ~C() { cout << "C 析构" << endl; } 24}; 25 26class D 27{ 28public: 29 D() { cout << "D 构造" << endl; } 30 ~D() { cout << "D 析构" << endl; } 31}; 32 33C c; 34 35int main() 36{ 37 A a; 38 B b; 39 static D d; 40 cout << "main 的 return 之前" << endl; 41 return 0; 42} 43
1# 所属目录:/home/cocatrice/cpp05/demo 2$ ./dtor_order 3C 构造 4A 构造 5B 构造 6D 构造 7main 的 return 之前 8B 析构 9A 析构 10D 析构 11C 析构 12
构造顺序是 c 先于所有局部对象,局部对象之间按声明的先后,静态局部对象 d 与局部对象同处一个作用域,也在这一批里。析构顺序要分两段看,a 与 b 是自动存储期,它们在 main 返回处按构造的逆序析构;c 与 d 的析构都排在程序退出阶段,d 的构造晚于 c,因此 d 先析构、c 最后析构。全部输出里最后一行是 C 析构,对应的正是最先构造的那个全局对象。

图 5 静态成员与对象成员的内存位置
四、static 成员函数
用 static 修饰的成员函数叫静态成员函数(static member function)。它的定义与普通成员函数没有区别,差别在于编译器不会给它传 this 指针,因此它没有办法知道自己是哪个对象调用的。这一条限制直接决定了它能碰什么:静态成员没有 this 指针也能访问,它属于类;非静态成员必须通过某个对象才能访问,静态成员函数里没有这个对象,写出来就会报错。
调用静态成员函数有两种写法,一是用对象调用,aa1.GetCount(),二是用类名加作用域限定调用,A::GetCount(),两种写法在实测里给出同一个结果。第二种写法体现了静态成员突破类域的效果,只要拿到了类名,不需要任何对象就能访问到这个函数。突破类域与绕过访问限定是两件事,静态成员如果声明在 private 区域,类外依旧碰不到它,要靠公开接口或者友元才能进去。
在静态成员函数里直接写非静态成员的后果在下面这段代码里可以看到。
1# 所属目录:/home/cocatrice/cpp05/demo 2err5.cpp: In static member function ‘static int A::GetA()’: 3err5.cpp:14:11: error: invalid use of member ‘A::_a’ in static member function 4 int _a = 1; 5 ^ 6err5.cpp:10:10: error: from this location 7 return _a; 8 ^ 9err5.cpp:11:2: warning: control reaches end of non-void function [-Wreturn-type] 10 } 11 ^ 12
报错的行号指向成员变量的使用处,编译器给出的理由是静态成员函数里用到了无效的成员,也就是它找不到 this。绕过这条限制的办法有两种:把需要访问的对象作为参数传进来,写成 static int SGetA(A aa) 这种形式,通过参数里的对象去访问成员;或者干脆改用非静态成员函数,让编译器把 this 传进去。
静态成员函数与普通成员函数在内存里的形态也不同。前面 static_member.cpp 的回显里有一组 sizeof 对照,静态成员函数的指针占 8 字节,非静态成员函数的指针占 16 字节。原因在于非静态成员函数需要额外的信息来定位对象,指针里不止存了函数入口,静态成员函数与普通函数没有区别,一个 8 字节的地址就够了。
五、静态成员的典型用途
静态成员最直接的用处是让整个类共享一份状态。static_member.cpp 里的 _scount 就是一个例子,构造与析构各自改一次这个变量,任何时刻读出来的都是当前存活的对象个数。这类计数不需要作用在某个对象上,用类名加静态函数就能读到,写起来比在外部维护一个全局变量更有约束,因为计数只在这个类的成员函数里改得到。
把静态成员当计数器用还有第二种形态,给每个对象发一个不同的编号。做法是在构造函数里把静态变量自增之后赋给自己的非静态成员,静态变量记住的是已经发出去多少个号,非静态成员记住的是这个对象自己的号。两个变量分工明确,前者在静态区里只有一份,后者每个对象各有一份。
静态局部对象的作用是让构造在整个程序里只发生一次。dtor_order.cpp 里的 static D d; 写在 main 的函数体里,程序执行到这一行时构造,之后再执行到这里也不会构造第二份,因此它常被用来做需要延迟初始化又只能有一份的东西。这份唯一性有代价,静态局部对象的析构排在程序退出阶段,它的生命周期与函数调用无关,析构顺序又不容易在代码里一眼看清,所以放在函数里管理资源时要多留意一层。
静态成员的代价与它的便利来自同一个地方,它是一份全局状态,而全局状态在程序里没有自然的作用域边界。任何能访问到它的人都能改它,因此把可变状态放进静态成员,等于把这个类变成了隐式的共享点。除此之外,静态成员的初始化发生在程序启动阶段,多个翻译单元里定义的静态对象谁先谁后并没有明确保证,跨文件的静态对象互相依赖时要格外小心。
静态成员与静态成员函数这两件事到这里都讲完了。再往下走一层,能不能让类外面的普通函数或者另一个类也访问到私有成员,这是友元要处理的事情。
六、友元函数与友元类
访问限定符把私有成员圈在类里面,友元(friend)是这套规则上开的一个口子。声明的方式是在函数或者类的声明前面加 friend 关键字,并且把这份声明写在某个类的内部。被声明成友元的函数可以访问这个类的私有与保护成员,被声明成友元的类,它的所有成员函数都可以访问对方的私有与保护成员。
友元函数不是类的成员函数,这一点决定了很多细节。它没有 this 指针,也没有隐含的对象,因此参数里必须把要访问的对象显式传进来。它可以声明在类里面的任何位置,放在 public 区域与放在 private 区域没有任何区别,编译器看的是 friend 这个关键字而不是访问限定符。一个函数可以同时是多个类的友元,只要在每个类里都写一遍同事的声明。
下面这一段程序里面一共安排出了三个类,分别是 A、B 与 C。A 把普通函数 Func 声明成友元,同时把类 B 声明成友元;B 也把 Func 声明成友元;C 什么都没写,只能走 A 的公开接口。Func 的参数同时用到 A 与 B 两个类型,因此在 A 的定义之前需要一行前置声明 class B;,否则 Func 的声明里那个 B 类型编译器认不出来。
1// 文件:/home/cocatrice/cpp05/demo/friend_demo.cpp 2#include <iostream> 3using namespace std; 4 5class B; 6 7class A 8{ 9 friend void Func(const A& aa, const B& bb); 10 friend class B; 11 12public: 13 A(int a1 = 0, int a2 = 0) 14 : _a1(a1) 15 , _a2(a2) 16 {} 17 18 int GetSum() const 19 { 20 return _a1 + _a2; 21 } 22 23private: 24 int _a1; 25 int _a2; 26}; 27 28class B 29{ 30 friend void Func(const A& aa, const B& bb); 31 32public: 33 B(int b1 = 0, int b2 = 0) 34 : _b1(b1) 35 , _b2(b2) 36 {} 37 38 void Func1(const A& aa) 39 { 40 cout << "B::Func1 读 A 的私有成员 " << aa._a1 41 << ",读自己的 " << _b1 << endl; 42 } 43 44 void Func2(const A& aa) 45 { 46 cout << "B::Func2 读 A 的私有成员 " << aa._a2 47 << ",读自己的 " << _b2 << endl; 48 } 49 50private: 51 int _b1; 52 int _b2; 53}; 54 55void Func(const A& aa, const B& bb) 56{ 57 cout << "Func 读 A 的私有成员 " << aa._a1 << " 与 " << aa._a2 58 << ",读 B 的私有成员 " << bb._b1 << " 与 " << bb._b2 << endl; 59} 60 61class C 62{ 63public: 64 void Func(const A& aa) 65 { 66 cout << "C::Func 不是友元,只能走公开接口 " << aa.GetSum() << endl; 67 } 68}; 69 70int main() 71{ 72 A aa(1, 2); 73 B bb(3, 4); 74 Func(aa, bb); 75 bb.Func1(aa); 76 bb.Func2(aa); 77 C cc; 78 cc.Func(aa); 79 return 0; 80} 81
1# 所属目录:/home/cocatrice/cpp05/demo 2 3$ ./friend_demo 4Func 读 A 的私有成员 1 与 2,读 B 的私有成员 3 与 4 5B::Func1 读 A 的私有成员 1,读自己的 3 6B::Func2 读 A 的私有成员 2,读自己的 4 7C::Func 不是友元,只能走公开接口 3 8
四行输出正好覆盖了四种互不相同的访问身份。Func 是 A 与 B 双方的友元,所以它能一次读完两个类的私有成员,输出里出现了 1、2、3、4 这四个内部的数字。B::Func1 与 B::Func2 是 B 的成员函数,B 被 A 声明为友元类,因此它们能读到 A 的私有成员,同时读自己类的成员。C::Func 与 A 之间没有任何友元关系,它读不到 A 的私有成员,只能调用公开的 GetSum,拿到的 3 是两个私有成员相加的结果。
把 Func 的 friend 声明去掉之后,同一个函数立刻编不过。报错的位置在函数体里访问私有成员的那几行,编译器给出的信息是成员是私有的,紧接着一行补充说明报错发生在当前的上下文里,也就是函数 Func 内部。这类报错里编译器通常会给出两个候选解释,一是指出访问权限不足,二是指出成员名字本身不存在,看报错时要确认到底是哪一种。
1# 所属目录:/home/cocatrice/cpp05/demo 2err7.cpp: In function ‘void func(const A&)’: 3err7.cpp:13:6: error: ‘int A::_a1’ is private 4 int _a1; 5 ^ 6err7.cpp:18:13: error: within this context 7 cout << aa._a1 << endl; 8 ^ 9
友元关系在方向上有两条限制,一条关于对称性,一条关于传递性。第一是不对称,A 把 B 声明为友元,只意味着 B 能访问 A 的私有成员,A 并不能因此访问 B 的私有成员,访问的通行证是单向发的。第二是不能传递,A 把 B 当友元、B 把 C 当友元,C 与 A 之间没有任何关系,C 读不到 A 的私有成员。这两条都来自同一个设计意图,友元是一种明确的、点对点的授权,而不是可以在类之间流传的权限。

图 6 友元关系的单向性
友元带来的便利与它同时带来的代价一样明显。它把两个本来只通过公开接口打交道的类绑在一起,任何一个类改动了内部的成员,友元那边都可能要跟着改,耦合度因此上升,封装也被开了一个口子。实际用的时候一般是给运算符重载或者两个联系极紧的类开友元,能不写就不写。
七、内部类
定义在另一个类里面的类叫内部类(nested class)。它是一个完全独立的类,与定义在全局的类相比只多了一条约束,它受外部类的类域与访问限定符限制,类外面想用它就得带上外部类的名字,写成 A::B 这种形式。内部类与外部类之间没有对象上的包含关系,外部类的对象里不会多出内部类的成员。
下面这个程序里 A 有一个公开的内部类 B 和一个藏在 private 位置的内部类 Hidden,B 的成员函数要读 A 的私有成员,因此参数里必须传一个 A 的对象进来。
1// 文件:/home/cocatrice/cpp05/demo/inner_demo.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 class B 9 { 10 public: 11 B(int b = 0) 12 : _b(b) 13 { 14 cout << "内部类 B 构造了,_b = " << _b << endl; 15 } 16 17 void Func(const A& a) 18 { 19 cout << "内部类读外部类的私有静态成员 _k = " << _k << endl; 20 cout << "内部类读外部类对象的私有成员 a._h = " << a._h << endl; 21 cout << "内部类读自己的成员 _b = " << _b << endl; 22 } 23 24 private: 25 int _b; 26 }; 27 28 A(int h = 1) 29 : _h(h) 30 {} 31 32 B MakeB(int b) 33 { 34 return B(b); 35 } 36 37private: 38 class Hidden 39 { 40 public: 41 Hidden() 42 { 43 cout << "藏在私有位置的内部类构造了" << endl; 44 } 45 }; 46 47 static int _k; 48 int _h; 49}; 50 51int A::_k = 1; 52 53int main() 54{ 55 cout << "sizeof(A) = " << sizeof(A) << ",外部类对象里只有自己的成员" << endl; 56 cout << "sizeof(A::B) = " << sizeof(A::B) << ",内部类是另一个独立的类" << endl; 57 A aa(1); 58 A::B bb = aa.MakeB(2); 59 bb.Func(aa); 60 return 0; 61} 62
1# 所属目录:/home/cocatrice/cpp05/demo 2 3$ ./inner_demo 4sizeof(A) = 4,外部类对象里只有自己的成员 5sizeof(A::B) = 4,内部类是另一个独立的类 6内部类 B 构造了,_b = 2 7内部类读外部类的私有静态成员 _k = 1 8内部类读外部类对象的私有成员 a._h = 1 9内部类读自己的成员 _b = 2 10
两行 sizeof 说明了第一个要点。A 的对象占 4 字节,里面只有一个 int 成员 _h,内部类 B 虽然写在 A 里面,它并没有成为 A 的成员,因此不占 A 的空间。B 自己单独算一次大小,也是 4 字节,它有自己的成员 _b。构造 B 的对象要写成 A::B bb = aa.MakeB(2),对象本身与 A 的对象 aa 是两个独立的对象。
接下来三行说明内部类默认是外部类的友元。B::Func 直接读到了 A 的私有静态成员 _k,也读到了外部对象 a 的私有成员 _h,这两处访问在类外面都会被拒绝。需要注意参数 a 的作用,内部类没有外部类的 this 指针,它只是被授予了访问权限,具体读哪个外部对象的成员,仍然要从参数里传进来。
内部类放在 private 或者 protected 位置时,它就成了外部类私有的东西,类外面既不能构造它的对象,也不能用它的名字。这种写法常出现在两个类联系极紧的场景里,一个类存在的意义就是给另一个类提供服务,把服务提供者藏在调用者内部,外面就碰不到它了。
1# 所属目录:/home/cocatrice/cpp05/demo 2err11.cpp: In function ‘int main()’: 3err11.cpp:8:8: error: ‘class A::Hidden’ is private 4 class Hidden 5 ^ 6err11.cpp:26:5: error: within this context 7 A::Hidden h; 8 ^ 9
内部类的这个特性可以解一道不能用循环的题。题目要求算 1 加 2 一直加到 n,同时不许用乘除法,不许用 for、while、if、else、switch、case 这些关键字,条件判断语句也不能用。思路是把累加放进构造函数里,外部类需要几个数就构造几个对象,构造的过程本身就是循环。
1// 文件:/home/cocatrice/cpp05/demo/jz64.cpp 2#include <iostream> 3using namespace std; 4 5class Solution 6{ 7private: 8 class Sum 9 { 10 public: 11 Sum() 12 { 13 _ret += _i; 14 ++_i; 15 } 16 }; 17 18public: 19 int Sum_Solution(int n) 20 { 21 Sum arr[n]; 22 return _ret; 23 } 24 25private: 26 static int _i; 27 static int _ret; 28}; 29 30int Solution::_i = 1; 31int Solution::_ret = 0; 32 33int main() 34{ 35 Solution st; 36 cout << "Sum_Solution(10) = " << st.Sum_Solution(10) << endl; 37 Solution st2; 38 cout << "Sum_Solution(100) = " << st2.Sum_Solution(100) << endl; 39 return 0; 40} 41
1# 所属目录:/home/cocatrice/cpp05/demo 2jz64.cpp: In member function ‘int Solution::Sum_Solution(int)’: 3jz64.cpp:21:7: warning: unused variable ‘arr’ [-Wunused-variable] 4 Sum arr[n]; 5 ^ 6$ ./jz64 7Sum_Solution(10) = 55 8Sum_Solution(100) = 6105 9
静态成员 _i 是当前要加进去的数,_ret 是累加的结果。每构造一个 Sum 对象,_ret 加上 _i,再把 _i 加一。Sum_Solution 里的 Sum arr[n]; 一次构造出 n 个对象,构造函数被调用 n 次,_ret 里装的就是从 1 加到 n 的结果。Sum 被放在 Solution 的 private 区域,外面拿不到这个类,累加的过程只能由 Solution 自己的成员函数触发。
第二次调用打印的是 6105 而不是 5050,这个结果值得多想一步。静态成员只在第一次使用时初始化一次,第一次调用结束后 _ret 停在 55,_i 停在 11,第二次调用并没有把它们复位,于是从 11 加到 110 得到 6050,再加上残留的 55 正好是 6105。静态成员属于类而不属于某个对象,Solution 的两个对象 st 与 st2 共用同一份 _i 与 _ret,这正是前面静态成员一节的结论在具体题目上的体现。要让它每次都从 1 开始,需要在进入累加之前把两个静态成员复位。
Sum arr[n]; 这行数组的长度是函数参数,编译期并不确定,严格按 C++ 标准这是不允许的。编译时加上 -Wall 只会提示 arr 定义了没有使用,加上 -pedantic 才能看到标准层面的警告,GCC 把它当作一项扩展来支持。同样的功能用 Sum* p = new Sum[n]; 加 delete[] p; 也可以实现,这条路径在标准里是合法的。
1# 所属目录:/home/cocatrice/cpp05/demo 2jz64.cpp: In member function ‘int Solution::Sum_Solution(int)’: 3jz64.cpp:21:7: warning: unused variable ‘arr’ [-Wunused-variable] 4 Sum arr[n]; 5 ^ 6$ ./jz64 7Sum_Solution(10) = 55 8Sum_Solution(100) = 6105 9 10jz64.cpp: In member function ‘int Solution::Sum_Solution(int)’: 11jz64.cpp:21:12: warning: ISO C++ forbids variable length array ‘arr’ [-Wvla] 12 Sum arr[n]; 13 ^ 14jz64.cpp:21:7: warning: unused variable ‘arr’ [-Wunused-variable] 15 Sum arr[n]; 16 ^ 17(上面是加 -pedantic 之后的输出) 18

图 7 内部类与外部类的关系
八、匿名对象
只写类名加一对括号、不给这个对象取名字,这样造出来的对象叫匿名对象。A(); 构造一个默认对象,A(1); 构造一个带参数的对象,两种写法都没有变量名。没有名字意味着后面的语句里没有办法再提到它,因此它的生命周期只到这一行结束,同一行里用完立刻析构。
下面这个程序把有名对象与匿名对象的析构时机放在一起对照,末尾还有一处把临时对象接到 const 引用上的写法。
1// 文件:/home/cocatrice/cpp05/demo/anon.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A(int a = 0) 9 : _a(a) 10 { 11 cout << "A(int a) 构造,_a = " << _a << endl; 12 } 13 14 ~A() 15 { 16 cout << "~A() 析构,_a = " << _a << endl; 17 } 18 19 int GetA() const 20 { 21 return _a; 22 } 23 24private: 25 int _a; 26}; 27 28class Solution 29{ 30public: 31 int Sum_Solution(int n) 32 { 33 cout << "Sum_Solution 收到 " << n << endl; 34 return n; 35 } 36}; 37 38A MakeA() 39{ 40 return A(7); 41} 42 43int main() 44{ 45 cout << "有名对象" << endl; 46 A aa1; 47 cout << "匿名对象 A()" << endl; 48 A(); 49 cout << "匿名对象 A(1)" << endl; 50 A(1); 51 cout << "有名对象 A aa2(2)" << endl; 52 A aa2(2); 53 cout << "用匿名对象调一次成员函数" << endl; 54 cout << Solution().Sum_Solution(10) << endl; 55 cout << "把匿名对象的返回值接到 const 引用上" << endl; 56 const A& ra = MakeA(); 57 cout << "ra.GetA() = " << ra.GetA() << endl; 58 cout << "这一行之后 ra 还在用" << endl; 59 cout << "main 的最后一行" << endl; 60 return 0; 61} 62
1# 所属目录:/home/cocatrice/cpp05/demo 2 3$ ./anon 4有名对象 5A(int a) 构造,_a = 0 6匿名对象 A() 7A(int a) 构造,_a = 0 8~A() 析构,_a = 0 9匿名对象 A(1) 10A(int a) 构造,_a = 1 11~A() 析构,_a = 1 12有名对象 A aa2(2) 13A(int a) 构造,_a = 2 14用匿名对象调一次成员函数 15Sum_Solution 收到 10 1610 17把匿名对象的返回值接到 const 引用上 18A(int a) 构造,_a = 7 19ra.GetA() = 7 20这一行之后 ra 还在用 21main 的最后一行 22~A() 析构,_a = 7 23~A() 析构,_a = 2 24~A() 析构,_a = 0 25
回显里的信息可以分成下面这两组来对照。第一组是构造与析构的配对,A(); 这一行之后紧接着就是一行析构,A(1); 同理,而 A aa1; 与 A aa2(2); 的析构都排在 main 的最后一行之后。第二组是三行析构的顺序,_a 为 2 的那个对象先析构,接着是接到引用上的 _a 为 7 的对象,最后是 _a 为 0 的 aa1,析构顺序与构造顺序正好相反。
Solution().Sum_Solution(10) 这行把这套规则用到了实处,Solution 的匿名对象只用来调一次成员函数,调完即析构,函数体里的那行打印也在同一行完成。标准库里的仿函数经常这么写,排序时传入的比较器往往只需要一个临时对象,写 sort(a, a + 8, greater<int>()) 就够了,greater() 就是一个匿名对象。
把匿名对象接到 const 引用上会改变它的生命周期。const A& ra = MakeA(); 里 MakeA 返回的是一个临时对象,绑定到 const 引用之后,这个临时对象的生命周期被延长到引用的作用域结束,因此后面几行通过 ra 读它仍然有效,回显里 ra.GetA() 拿到了 7。延长只对绑定在这一处的引用成立,换成非 const 引用就绑不上临时对象了。

图 8 匿名对象与临时对象的生命周期
九、拷贝时的编译器优化
前面几节里出现过好几次「本该两次构造,实际只打印了一次」的现象。A aa1 = 1; 用转换构造函数造一个临时对象,再用它初始化 aa1,按理说有一次构造加一次拷贝构造;按值传参的函数调用,按理说实参到形参要走一次拷贝构造。实测里这些拷贝都没有出现,原因在于标准给编译器开了一道口子,允许它在特定场合直接把对象构造到最终的位置上,跳过中间的临时对象与拷贝构造。这道口子叫拷贝省略(copy elision)。
下面这个程序用一个计数类统计八种写法里的构造、拷贝、赋值、析构次数。Count 的四个静态计数在每组用例前复位一次,Report 打印这一组的结果。
1// 文件:/home/cocatrice/cpp05/demo/elide.cpp 2#include <iostream> 3using namespace std; 4 5class Count 6{ 7public: 8 Count(int a = 0) 9 : _a(a) 10 { 11 ++ctor; 12 } 13 14 Count(const Count& c) 15 : _a(c._a) 16 { 17 ++copy; 18 } 19 20 Count& operator=(const Count& c) 21 { 22 _a = c._a; 23 ++assign; 24 return *this; 25 } 26 27 ~Count() 28 { 29 ++dtor; 30 } 31 32 static void Reset() 33 { 34 ctor = copy = assign = dtor = 0; 35 } 36 37 static void Report(const char* name) 38 { 39 cout << name << " 构造 " << ctor << " 拷贝 " << copy 40 << " 赋值 " << assign << " 析构 " << dtor << endl; 41 } 42 43private: 44 int _a; 45 static int ctor; 46 static int copy; 47 static int assign; 48 static int dtor; 49}; 50 51int Count::ctor = 0; 52int Count::copy = 0; 53int Count::assign = 0; 54int Count::dtor = 0; 55 56void ByValue(Count c) 57{ 58} 59 60void ByConstRef(const Count& c) 61{ 62} 63 64Count MakeAnon() 65{ 66 return Count(1); 67} 68 69int main() 70{ 71 Count::Reset(); 72 { 73 Count n(1); 74 ByValue(n); 75 Count::Report("有名对象传值传参 "); 76 } 77 78 Count::Reset(); 79 { 80 ByValue(1); 81 Count::Report("隐式转换传值传参 "); 82 } 83 84 Count::Reset(); 85 { 86 ByValue(Count(1)); 87 Count::Report("匿名对象传值传参 "); 88 } 89 90 Count::Reset(); 91 { 92 Count n(1); 93 ByConstRef(n); 94 Count::Report("const 引用传参 "); 95 } 96 97 Count::Reset(); 98 { 99 ByConstRef(Count(1)); 100 Count::Report("const 引用传匿名 "); 101 } 102 103 Count::Reset(); 104 { 105 MakeAnon(); 106 Count::Report("返回值丢掉 "); 107 } 108 109 Count::Reset(); 110 { 111 Count r = MakeAnon(); 112 Count::Report("返回值初始化新对象"); 113 } 114 115 Count::Reset(); 116 { 117 Count r; 118 r = MakeAnon(); 119 Count::Report("返回值赋给已有对象"); 120 } 121 return 0; 122} 123
1# 所属目录:/home/cocatrice/cpp05/demo 2 3$ ./elide 4有名对象传值传参 构造 1 拷贝 1 赋值 0 析构 1 5隐式转换传值传参 构造 1 拷贝 0 赋值 0 析构 1 6匿名对象传值传参 构造 1 拷贝 0 赋值 0 析构 1 7const 引用传参 构造 1 拷贝 0 赋值 0 析构 0 8const 引用传匿名 构造 1 拷贝 0 赋值 0 析构 1 9返回值丢掉 构造 1 拷贝 0 赋值 0 析构 1 10返回值初始化新对象 构造 1 拷贝 0 赋值 0 析构 0 11返回值赋给已有对象 构造 2 拷贝 0 赋值 1 析构 1 12
八行输出里面只有两行的拷贝次数不是零。有名对象传值传参那一组拷贝了 1 次,这是实参已经有名字、编译器没有临时对象可以省,只能调用一次拷贝构造;返回值赋给已有对象那一组是 2 次构造加 1 次赋值,因为赋值运算符没法省略,赋值必然发生一次。剩下的六组拷贝数都是零,包括隐式转换传值、匿名对象传值、返回值丢掉、返回值初始化新对象这几种写法,临时对象被直接构造到了目标位置上。
把默认的 -O0、打开优化的 -O2、以及关掉省略的 -O0 -fno-elide-constructors 三档放在一起跑,差别就清楚了。
1# 所属目录:/home/cocatrice/cpp05/demo 2$ ./elide_O0 3有名对象传值传参 构造 1 拷贝 1 赋值 0 析构 1 4隐式转换传值传参 构造 1 拷贝 0 赋值 0 析构 1 5匿名对象传值传参 构造 1 拷贝 0 赋值 0 析构 1 6const 引用传参 构造 1 拷贝 0 赋值 0 析构 0 7const 引用传匿名 构造 1 拷贝 0 赋值 0 析构 1 8返回值丢掉 构造 1 拷贝 0 赋值 0 析构 1 9返回值初始化新对象 构造 1 拷贝 0 赋值 0 析构 0 10返回值赋给已有对象 构造 2 拷贝 0 赋值 1 析构 1 11 12$ ./elide_O2 13有名对象传值传参 构造 1 拷贝 1 赋值 0 析构 1 14隐式转换传值传参 构造 1 拷贝 0 赋值 0 析构 1 15匿名对象传值传参 构造 1 拷贝 0 赋值 0 析构 1 16const 引用传参 构造 1 拷贝 0 赋值 0 析构 0 17const 引用传匿名 构造 1 拷贝 0 赋值 0 析构 1 18返回值丢掉 构造 1 拷贝 0 赋值 0 析构 1 19返回值初始化新对象 构造 1 拷贝 0 赋值 0 析构 0 20返回值赋给已有对象 构造 2 拷贝 0 赋值 1 析构 1 21 22$ ./elide_no 23有名对象传值传参 构造 1 拷贝 1 赋值 0 析构 1 24隐式转换传值传参 构造 1 拷贝 1 赋值 0 析构 2 25匿名对象传值传参 构造 1 拷贝 1 赋值 0 析构 2 26const 引用传参 构造 1 拷贝 0 赋值 0 析构 0 27const 引用传匿名 构造 1 拷贝 0 赋值 0 析构 1 28返回值丢掉 构造 1 拷贝 1 赋值 0 析构 2 29返回值初始化新对象 构造 1 拷贝 2 赋值 0 析构 2 30返回值赋给已有对象 构造 2 拷贝 1 赋值 1 析构 2 31
前面两档编译选项下跑出来的输出逐字相同。这一点值得记下来,拷贝省略与开不开优化没有关系,-O0 下编译器照样做这件事,因此不能靠调低优化挡位来保留拷贝构造的调用。第三档加上 -fno-elide-constructors 之后,隐式转换传值、匿名对象传值、返回值丢掉这三组的拷贝数由 0 变成 1,返回值初始化新对象那一组由 0 变成 2,返回值赋给已有对象那一组也由 0 变成 1,对应的析构次数据此增加。
标准允许省略拷贝的场合可以归成下面三类。用一个临时对象初始化同类型的另一个对象,编译器可以直接在这块内存上构造最终对象;函数按值返回一个临时对象,返回值可以直接构造在调用方的接收位置;按值传参而实参本身是临时对象,形参可以直接在实参的位置上构造。这三类写法的共同点是最终对象的位置在构造开始之前就已经确定,中间那次搬运纯属多余。

图 9 拷贝省略的三类场合
十、优化在标准里的地位
这条例外不是编译器的自作主张,它写在语言标准里面,名称同样是拷贝省略。标准给出的表述是编译器被允许省略拷贝构造与析构函数的调用,也就是说省略与否由实现决定,程序不能假设这件事一定发生,也不能假设它一定不发生。同一份代码在不同编译器、同一个编译器的不同版本上,打印出来的构造与析构次数都可能不同。
容易被忽略的一点是,省略的是调用而不是函数本身。拷贝构造函数在那些场合里仍然必须是可用的,如果它被声明成私有或者被删除,程序会直接编译失败,尽管编译器本来打算跳过这次调用。也就是说,写出一个拷贝构造函数并把它放到 private 区域,并不能因为「这次拷贝会被省略」而绕开编译器的检查。
在这条规则的两个档位上,GCC 给出的开关并不在优化选项里。-fno-elide-constructors 属于 C++ 方言选项,也就是说编译器把「省不省拷贝」当作语言层面的实现选择来管理,而不是当作优化等级的一部分,这与前面 -O0 与 -O2 输出一致的现象互相印证。
C++17 之前,这些场合里省略是允许的;到了 C++17,其中一部分场合改成了必须省略,也就是无论编译器怎么想都得省掉这次拷贝。本机上的 g++ 是 4.8.5,只认得 -std=c++98 与 -std=c++11 两个档位,更高的标准连选项都不认,因此这一条在本机上没有办法给出实测对照,只能作为标准演变的方向记下来。
1# 所属目录:/home/cocatrice/cpp05/demo 2g++: error: unrecognized command line option ‘-std=c++14’ 3g++: error: unrecognized command line option ‘-std=c++17’ 4
十一、优化会让计数实验失效
计数与打印是两种观察手段,它们在拷贝省略面前都会失真。为了避免只相信程序自己的打印,这一节换一种方式,用调试器在构造函数上下断点,统计构造被调用的次数并打印调用栈。下面的程序里 Make 按值返回一个临时对象,Call 按值接收一个对象,两处都会牵涉到拷贝构造。
1// 文件:/home/cocatrice/cpp05/demo/stackdepth.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A(int a) 9 : _a(a) 10 { 11 cout << "A(int) 构造" << endl; 12 } 13 14 A(const A& aa) 15 : _a(aa._a) 16 { 17 cout << "A(const A&) 拷贝构造" << endl; 18 } 19 20private: 21 int _a; 22}; 23 24A Make() 25{ 26 return A(1); 27} 28 29void Call(A aa) 30{ 31 cout << "Call 体内" << endl; 32} 33 34int main() 35{ 36 A a1 = Make(); 37 Call(a1); 38 return 0; 39} 40
1# 所属目录:/home/cocatrice/cpp05/demo 2 3$ ./stackdepth 4A(int) 构造 5A(const A&) 拷贝构造 6Call 体内 7
在 A::A(int) 与 A::A(const A&) 两个位置各下一个断点,每个断点命中时打印一次调用栈,两档的输出差别很直接。
1# 所属目录:/home/cocatrice/cpp05/demo 2$ gdb -batch -x gdb.cmd ./stackdepth 3Breakpoint 1 at 0x4008c5: file stackdepth.cpp, line 9. 4Breakpoint 2 at 0x4008fc: file stackdepth.cpp, line 15. 5=== 命中 A::A(int) === 6#0 A::A (this=0x7fffffffe490, a=1) at stackdepth.cpp:9 7#1 0x00000000004007fa in Make () at stackdepth.cpp:26 8#2 0x000000000040083e in main () at stackdepth.cpp:36 9A(int) 构造 10=== 命中 A::A(A const&) === 11#0 A::A (this=0x7fffffffe4a0, aa=...) at stackdepth.cpp:15 12#1 0x0000000000400851 in main () at stackdepth.cpp:37 13A(const A&) 拷贝构造 14Call 体内 15[Inferior 1 (process 17006) exited normally] 16
1# 所属目录:/home/cocatrice/cpp05/demo 2$ gdb -batch -x gdb.cmd ./stackdepth_noelide 3Breakpoint 1 at 0x4008eb: file stackdepth.cpp, line 9. 4Breakpoint 2 at 0x400922: file stackdepth.cpp, line 15. 5=== 命中 A::A(int) === 6#0 A::A (this=0x7fffffffe460, a=1) at stackdepth.cpp:9 7#1 0x00000000004007fa in Make () at stackdepth.cpp:26 8#2 0x0000000000400851 in main () at stackdepth.cpp:36 9A(int) 构造 10=== 命中 A::A(A const&) === 11#0 A::A (this=0x7fffffffe490, aa=...) at stackdepth.cpp:15 12#1 0x000000000040080d in Make () at stackdepth.cpp:26 13#2 0x0000000000400851 in main () at stackdepth.cpp:36 14A(const A&) 拷贝构造 15=== 命中 A::A(A const&) === 16#0 A::A (this=0x7fffffffe480, aa=...) at stackdepth.cpp:15 17#1 0x0000000000400864 in main () at stackdepth.cpp:36 18A(const A&) 拷贝构造 19=== 命中 A::A(A const&) === 20#0 A::A (this=0x7fffffffe4a0, aa=...) at stackdepth.cpp:15 21#1 0x0000000000400877 in main () at stackdepth.cpp:37 22A(const A&) 拷贝构造 23Call 体内 24[Inferior 1 (process 17018) exited normally] 25
默认档下拷贝构造函数的断点一共命中两次。A(int) 那一次的栈帧里能看到它由 Make 调用,返回值直接落在 main 的接收位置上,拷贝构造函数只被 main 调用了一次,对应的是 Call(a1) 这次按值传参。关掉省略之后一共命中四次,多出来的两次拷贝构造一次挂在 Make 的栈帧上,另一次挂在 main 里初始化 a1 的那一行上,正好是编译器本来打算省掉的两处搬运。
断点计数与打印计数给出的是同一个结论:观察对象构造的次数时,编译器可以合法地把次数改掉。构造与析构里有副作用时,这一点最容易被忽略,日志少了一行、计数小了一个、文件句柄少关一次,都可能是因为这次调用被省略了。要观察真实的调用次数,编译时加上 -fno-elide-constructors;要判断一段代码在不同编译器上的行为,前提是这些副作用不参与程序的正确性。

图 10 计数实验为什么会被优化破坏
实例代码
工程结构
所有源文件都放在 /home/cocatrice/cpp05/demo 目录里,共 24 个 .cpp。
1# 所属目录:/home/cocatrice/cpp05/demo 2/home/cocatrice/cpp05/demo 3 init_list.cpp 初始化列表、声明处缺省值与初始化顺序 4 edge.cpp 顺序写反、定位 new 与未初始化的内置类型 5 convert.cpp 单参构造的隐式转换与转换运算符 6 static_member.cpp 静态成员的计数、地址与 sizeof 对照 7 dtor_order.cpp 全局对象、局部对象与静态局部对象的构造析构顺序 8 friend_demo.cpp 友元函数与友元类 9 inner_demo.cpp 内部类、私有内部类与类域 10 jz64.cpp 用内部类与静态成员算 1 加到 n 11 anon.cpp 匿名对象与临时对象的生命周期 12 elide.cpp 拷贝省略的八组用例与三档对照 13 stackdepth.cpp 构造函数调用的调用栈观察 14 composite.cpp 把本章要点串起来的综合程序 15 err1.cpp 到 err12.cpp 十二个故意编不过的文件 16
目录里实际的文件清单与上面这份一致,用 ls 数一遍是 24 个源文件。
1# 所属目录:/home/cocatrice/cpp05/demo 2$ ls -1 *.cpp | sort 3anon.cpp 4composite.cpp 5convert.cpp 6dtor_order.cpp 7edge.cpp 8elide.cpp 9err10.cpp 10err11.cpp 11err12.cpp 12err1.cpp 13err2.cpp 14err3.cpp 15err4.cpp 16err5.cpp 17err6.cpp 18err7.cpp 19err8.cpp 20err9.cpp 21friend_demo.cpp 22init_list.cpp 23inner_demo.cpp 24jz64.cpp 25stackdepth.cpp 26static_member.cpp 27--- 文件个数 --- 2824 29
编译命令一行一个文件,常用的选项是 -std=c++11 与 -Wall,把警告打开之后初始化顺序与未使用变量的提示都会显示出来。文件多的时候可以写成一个循环,把十二个能编过的文件一次跑完。
1# 所属目录:/home/cocatrice/cpp05/demo 2$ g++ -std=c++11 -Wall -O0 -o init_list init_list.cpp 3$ for f in init_list edge convert static_member dtor_order friend_demo inner_demo jz64 anon elide stackdepth composite; do 4> g++ -std=c++11 -Wall -O0 -o $f $f.cpp 5> done 6
完整代码
本章其余演示程序的完整代码已经在核心知识各节里逐一给出,这里补齐用于复现报错的十二个文件。每个文件都只保留能触发报错的那几行,编译命令统一是 g++ -std=c++11 -Wall -o errN errN.cpp。
第一个文件里的类成员是一个没有默认构造函数的类型,构造函数没有把它写进初始化列表,编译器找不到可用的构造函数。
1// 文件:/home/cocatrice/cpp05/demo/err1.cpp 2#include <iostream> 3using namespace std; 4 5class Time 6{ 7public: 8 Time(int hour) 9 : _hour(hour) 10 {} 11 12private: 13 int _hour; 14}; 15 16class Date 17{ 18public: 19 Date(int year) 20 : _year(year) 21 {} 22 23private: 24 int _year; 25 Time _t; 26}; 27 28int main() 29{ 30 Date d(2024); 31 return 0; 32} 33
第二个文件的成员是一个引用,引用必须在构造的时候绑定到一个对象上,初始化列表里没有写它。
1// 文件:/home/cocatrice/cpp05/demo/err2.cpp 2#include <iostream> 3using namespace std; 4 5class Date 6{ 7public: 8 Date(int year) 9 : _year(year) 10 {} 11 12private: 13 int _year; 14 int& _ref; 15}; 16 17int main() 18{ 19 int year = 2025; 20 Date d(year); 21 return 0; 22} 23
第三个文件的成员是一个 const 对象,同样必须在初始化列表里给出初值。
1// 文件:/home/cocatrice/cpp05/demo/err3.cpp 2#include <iostream> 3using namespace std; 4 5class Date 6{ 7public: 8 Date(int year) 9 : _year(year) 10 {} 11 12private: 13 int _year; 14 const int _n; 15}; 16 17int main() 18{ 19 Date d(2024); 20 return 0; 21} 22
第四个文件在类内的静态成员声明处直接写了初值,这个位置只允许声明。
1// 文件:/home/cocatrice/cpp05/demo/err4.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A() 9 {} 10 11private: 12 static int _scount = 0; 13}; 14 15int main() 16{ 17 A aa; 18 return 0; 19} 20
第五个文件在静态成员函数里直接访问了非静态成员,静态成员函数没有 this 指针。
1// 文件:/home/cocatrice/cpp05/demo/err5.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 static int GetA() 9 { 10 return _a; 11 } 12 13private: 14 int _a = 1; 15}; 16 17int main() 18{ 19 cout << A::GetA() << endl; 20 return 0; 21} 22
第六个文件的静态成员只有在类内的声明,没有写类外的定义,程序在链接阶段找不到这个符号。
1// 文件:/home/cocatrice/cpp05/demo/err6.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A() 9 { 10 ++_scount; 11 } 12 13 static int GetCount() 14 { 15 return _scount; 16 } 17 18private: 19 static int _scount; 20}; 21 22int main() 23{ 24 A aa; 25 cout << A::GetCount() << endl; 26 return 0; 27} 28
第七个文件里有一个普通函数访问了类的私有成员,类里没有把它声明成友元。
1// 文件:/home/cocatrice/cpp05/demo/err7.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A(int a1 = 0) 9 : _a1(a1) 10 {} 11 12private: 13 int _a1; 14}; 15 16void func(const A& aa) 17{ 18 cout << aa._a1 << endl; 19} 20 21int main() 22{ 23 A aa(1); 24 func(aa); 25 return 0; 26} 27
第八个文件的构造函数加了 explicit,主函数里仍然用隐式转换的写法初始化对象。
1// 文件:/home/cocatrice/cpp05/demo/err8.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 explicit A(int a = 0) 9 : _a(a) 10 {} 11 12private: 13 int _a; 14}; 15 16int main() 17{ 18 A aa1 = 1; 19 return 0; 20} 21
第九个文件把同一个成员在初始化列表里写了两次。
1// 文件:/home/cocatrice/cpp05/demo/err9.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A(int a) 9 : _a1(a) 10 , _a1(a + 1) 11 {} 12 13private: 14 int _a1; 15}; 16 17int main() 18{ 19 A aa(1); 20 return 0; 21} 22
第十个文件在成员声明处给了缺省值,这是一个 C++11 才支持的特性,用它配合 -std=c++98 编译时会看到不同等级的反应。
1// 文件:/home/cocatrice/cpp05/demo/err10.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 void Print() const 9 { 10 cout << _a << endl; 11 } 12 13private: 14 int _a = 1; 15}; 16 17int main() 18{ 19 A aa; 20 aa.Print(); 21 return 0; 22} 23
第十一个文件的内部类藏在外部类的 private 区域,类外面构造了它的对象。
1// 文件:/home/cocatrice/cpp05/demo/err11.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7private: 8 class Hidden 9 { 10 public: 11 Hidden() 12 { 13 cout << "内部类构造" << endl; 14 } 15 }; 16 17public: 18 A() 19 { 20 Hidden h; 21 } 22}; 23 24int main() 25{ 26 A::Hidden h; 27 return 0; 28} 29
第十二个文件写成了 A aa1();,本意是构造一个对象,实际声明了一个返回 A 的函数。
1// 文件:/home/cocatrice/cpp05/demo/err12.cpp 2#include <iostream> 3using namespace std; 4 5class A 6{ 7public: 8 A() 9 { 10 cout << "A 构造" << endl; 11 } 12}; 13 14int main() 15{ 16 A aa1(); 17 cout << sizeof(aa1) << endl; 18 return 0; 19} 20
正常情况
十二个能编过的文件逐个编译,结果如下。
1# 所属目录:/home/cocatrice/cpp05/demo 2[通过但有提示] init_list.cpp 3init_list.cpp: In constructor ‘Order::Order()’: 4init_list.cpp:100:7: warning: ‘Order::_b’ will be initialized after [-Wreorder] 5[通过但有提示] edge.cpp 6edge.cpp: In constructor ‘Reorder::Reorder(int)’: 7edge.cpp:22:6: warning: ‘Reorder::_a1’ will be initialized after [-Wreorder] 8[通过但有提示] convert.cpp 9convert.cpp: In function ‘int main()’: 10convert.cpp:87:4: warning: variable ‘aa1’ set but not used [-Wunused-but-set-variable] 11[通过] static_member.cpp 12[通过] dtor_order.cpp 13[通过] friend_demo.cpp 14[通过] inner_demo.cpp 15[通过但有提示] jz64.cpp 16jz64.cpp: In member function ‘int Solution::Sum_Solution(int)’: 17jz64.cpp:21:7: warning: unused variable ‘arr’ [-Wunused-variable] 18[通过] anon.cpp 19[通过] elide.cpp 20[通过] stackdepth.cpp 21[通过] composite.cpp 22
十二个文件全部通过,其中四个文件带着编译提示。init_list.cpp 与 edge.cpp 的提示是初始化顺序与列表里的顺序不一致,convert.cpp 的提示是变量赋值之后没有使用,jz64.cpp 的提示是数组定义了没有使用。这四条都属于代码本身的问题,编译器的信息里直接给出了文件名与行号,按提示改写法即可。
抽三个程序看看运行时的输出,一个是静态局部对象的构造析构顺序,一个是友元关系的四条输出,一个是匿名对象的生命周期。
1# 所属目录:/home/cocatrice/cpp05/demo 2$ ./dtor_order 3C 构造 4A 构造 5B 构造 6D 构造 7main 的 return 之前 8B 析构 9A 析构 10D 析构 11C 析构 12$ ./friend_demo 13Func 读 A 的私有成员 1 与 2,读 B 的私有成员 3 与 4 14B::Func1 读 A 的私有成员 1,读自己的 3 15B::Func2 读 A 的私有成员 2,读自己的 4 16C::Func 不是友元,只能走公开接口 3 17$ ./anon 18有名对象 19A(int a) 构造,_a = 0 20匿名对象 A() 21A(int a) 构造,_a = 0 22~A() 析构,_a = 0 23匿名对象 A(1) 24A(int a) 构造,_a = 1 25~A() 析构,_a = 1 26有名对象 A aa2(2) 27A(int a) 构造,_a = 2 28用匿名对象调一次成员函数 29Sum_Solution 收到 10 3010 31把匿名对象的返回值接到 const 引用上 32A(int a) 构造,_a = 7 33ra.GetA() = 7 34这一行之后 ra 还在用 35main 的最后一行 36~A() 析构,_a = 7 37~A() 析构,_a = 2 38~A() 析构,_a = 0 39
常见报错
十二个报错文件一起编译,编译器给出的第一条错误行如下。err10.cpp 是唯一编过的一个,它的表现放在下一节的边界情况里说明。
1# 所属目录:/home/cocatrice/cpp05/demo 2[编不过] err1.cpp 3err1.cpp:20:15: error: no matching function for call to ‘Time::Time()’ 4[编不过] err2.cpp 5err2.cpp:8:2: error: uninitialized reference member ‘Date::_ref’ [-fpermissive] 6[编不过] err3.cpp 7err3.cpp:8:2: error: uninitialized member ‘Date::_n’ with ‘const’ type ‘const int’ [-fpermissive] 8[编不过] err4.cpp 9err4.cpp:12:23: error: ISO C++ forbids in-class initialization of non-const static member ‘A::_scount’ 10[编不过] err5.cpp 11err5.cpp:14:11: error: invalid use of member ‘A::_a’ in static member function 12err5.cpp:10:10: error: from this location 13[编不过] err6.cpp 14collect2: error: ld returned 1 exit status 15[编不过] err7.cpp 16err7.cpp:13:6: error: ‘int A::_a1’ is private 17err7.cpp:18:13: error: within this context 18[编不过] err8.cpp 19err8.cpp:18:10: error: conversion from ‘int’ to non-scalar type ‘A’ requested 20[编不过] err9.cpp 21err9.cpp:8:2: error: multiple initializations given for ‘A::_a1’ 22[编过] err10.cpp 23[编不过] err11.cpp 24err11.cpp:8:8: error: ‘class A::Hidden’ is private 25err11.cpp:26:5: error: within this context 26[编不过] err12.cpp 27err12.cpp:17:20: error: ISO C++ forbids applying ‘sizeof’ to an expression of function type [-fpermissive] 28
成员没有默认构造函数时编不过。 类里的成员 _t 是 Time 类型,Time 只有一个带参数的构造函数,编译器在为 Date 生成构造函数时需要先构造 _t,找不到能用的构造函数就停在原地。报错里会把这个类型的候选构造函数一并列出,看到 candidate 那几行就可以确认是参数不匹配还是根本没有默认构造。解决办法是把 _t 写进 Date 的初始化列表。
1# 所属目录:/home/cocatrice/cpp05/demo 2err1.cpp: In constructor ‘Date::Date(int)’: 3err1.cpp:20:15: error: no matching function for call to ‘Time::Time()’ 4 : _year(year) 5 ^ 6err1.cpp:20:15: note: candidates are: 7err1.cpp:8:2: note: Time::Time(int) 8 Time(int hour) 9 ^ 10err1.cpp:8:2: note: candidate expects 1 argument, 0 provided 11err1.cpp:5:7: note: constexpr Time::Time(const Time&) 12 class Time 13 ^ 14err1.cpp:5:7: note: candidate expects 1 argument, 0 provided 15err1.cpp:5:7: note: constexpr Time::Time(Time&&) 16err1.cpp:5:7: note: candidate expects 1 argument, 0 provided 17
引用成员与 const 成员必须在初始化列表里初始化。 这两类成员没有默认状态,引用必须绑定到一个已经存在的对象,const 对象必须在出生时就有值,因此构造函数体里再赋值已经来不及。报错末尾的 -fpermissive 表示编译器允许把这条错误降级为警告继续编下去,代价是运行时的行为不再有保证。
1# 所属目录:/home/cocatrice/cpp05/demo 2err2.cpp: In constructor ‘Date::Date(int)’: 3err2.cpp:8:2: error: uninitialized reference member ‘Date::_ref’ [-fpermissive] 4 Date(int year) 5 ^ 6
1# 所属目录:/home/cocatrice/cpp05/demo 2err3.cpp: In constructor ‘Date::Date(int)’: 3err3.cpp:8:2: error: uninitialized member ‘Date::_n’ with ‘const’ type ‘const int’ [-fpermissive] 4 Date(int year) 5 ^ 6
静态成员不能在类内声明处给初值。 静态成员不属于任何一个对象,它的定义只能出现在类外,因此类内这个位置只负责声明,写初值会被拒绝。报错信息里的 in-class initialization 指的就是这个位置。
1# 所属目录:/home/cocatrice/cpp05/demo 2err4.cpp:12:23: error: ISO C++ forbids in-class initialization of non-const static member ‘A::_scount’ 3 static int _scount = 0; 4 ^ 5
静态成员函数里访问非静态成员。 静态成员函数没有 this 指针,编译器在它里面解析 _a 这个名字时找不到绑定的对象,因此直接报无效使用。报错有两行,第二行 from this location 指出成员声明的位置,用来提示这个名字到底属于谁。
1# 所属目录:/home/cocatrice/cpp05/demo 2err5.cpp: In static member function ‘static int A::GetA()’: 3err5.cpp:14:11: error: invalid use of member ‘A::_a’ in static member function 4 int _a = 1; 5 ^ 6err5.cpp:10:10: error: from this location 7 return _a; 8 ^ 9err5.cpp:11:2: warning: control reaches end of non-void function [-Wreturn-type] 10 } 11 ^ 12
静态成员只声明不定义,错误会推迟到链接阶段。 编译阶段每个源文件各自看自己的语法,声明已经足够让它通过;链接器需要把所有用到的符号凑齐,找不到 _scount 的定义就报未定义的引用,末尾再加一行 collect2 的失败信息。这类报错的定位思路与编译错误不同,要去看哪个文件里漏了定义。
1# 所属目录:/home/cocatrice/cpp05/demo 2/tmp/ccLaWHQC.o: In function `A::A()': 3err6.cpp:(.text._ZN1AC2Ev[_ZN1AC5Ev]+0xa): undefined reference to `A::_scount' 4err6.cpp:(.text._ZN1AC2Ev[_ZN1AC5Ev]+0x13): undefined reference to `A::_scount' 5/tmp/ccLaWHQC.o: In function `A::GetCount()': 6err6.cpp:(.text._ZN1A8GetCountEv[_ZN1A8GetCountEv]+0x6): undefined reference to `A::_scount' 7collect2: error: ld returned 1 exit status 8
访问私有成员时缺少友元声明。 这条报错在友元一节里已经贴过,两条信息的组合很典型:一条说这个成员是私有的,另一条说访问发生在当前的上下文里。看到 within this context 时,需要确认的是发起访问的是哪个函数。
1# 所属目录:/home/cocatrice/cpp05/demo 2err7.cpp: In function ‘void func(const A&)’: 3err7.cpp:13:6: error: ‘int A::_a1’ is private 4 int _a1; 5 ^ 6err7.cpp:18:13: error: within this context 7 cout << aa._a1 << endl; 8 ^ 9
构造函数加了 explicit 之后的隐式转换。 这条报错在类型转换一节里已经贴过,编译器说的是没法把 int 转成 A,思路是补上显式写法,或者去掉 explicit。
1# 所属目录:/home/cocatrice/cpp05/demo 2err8.cpp: In function ‘int main()’: 3err8.cpp:18:10: error: conversion from ‘int’ to non-scalar type ‘A’ requested 4 A aa1 = 1; 5 ^ 6
同一个成员在初始化列表里出现两次。 报错信息里的 multiple initializations 直接点出问题,初始化列表里每个成员只能出现一次,写重复了编译器不能判断以哪一次为准。
1# 所属目录:/home/cocatrice/cpp05/demo 2err9.cpp: In constructor ‘A::A(int)’: 3err9.cpp:8:2: error: multiple initializations given for ‘A::_a1’ 4 A(int a) 5 ^ 6
类外面访问私有位置的内部类。 私有位置的内部类只在外部类的内部可见,类外面写 A::Hidden 会被当成访问私有成员,报错形态与访问私有变量一致。想让外面用到它,需要把它挪到 public 区域。
1# 所属目录:/home/cocatrice/cpp05/demo 2err11.cpp: In function ‘int main()’: 3err11.cpp:8:8: error: ‘class A::Hidden’ is private 4 class Hidden 5 ^ 6err11.cpp:26:5: error: within this context 7 A::Hidden h; 8 ^ 9
写成 A aa1(); 实际声明了一个函数。 这行代码不会构造任何对象,编译器把它解析成返回类型为 A、名为 aa1、没有参数的函数声明,因此后面用 sizeof(aa1) 的时候报错说不能对函数类型求大小。这类解析规则被称为最令人烦恼的解析,去掉那对空括号或者换成 A aa1; 即可绕开。
1# 所属目录:/home/cocatrice/cpp05/demo 2err12.cpp: In function ‘int main()’: 3err12.cpp:17:20: error: ISO C++ forbids applying ‘sizeof’ to an expression of function type [-fpermissive] 4 cout << sizeof(aa1) << endl; 5 ^ 6
边界情况
标准档位决定了成员声明处缺省值是警告还是特性。 同一份代码在 -std=c++11 下正常编译并打印出预期结果,换成 -std=c++98 时编译器只给一条警告,说这个写法要 C++11 才支持,程序照样能跑,输出还是 1。警告与错误在这里的界限值得留意,语法上不认识的东西在 GCC 里可能先降级成警告。
1# 所属目录:/home/cocatrice/cpp05/demo 2err10.cpp:14:11: warning: non-static data member initializers only available with -std=c++11 or -std=gnu++11 [enabled by default] 3 int _a = 1; 4 ^ 5$ ./err10_98 61 7
g++ 4.8.5 只认两个标准档位。 更高的档位在这个版本上连选项都不存在,编译器在解析命令行参数的时候就停下了,源代码根本没有被读进去。这一点解释了两件事:本机上无法验证 C++14 与 C++17 的新特性;判断一份代码能不能用某个特性,先看编译器支不支持对应的档位。
1# 所属目录:/home/cocatrice/cpp05/demo 2g++: error: unrecognized command line option ‘-std=c++14’ 3g++: error: unrecognized command line option ‘-std=c++17’ 4
未初始化的内置类型成员读出来的值随优化档位变化。 声明顺序与初始化列表顺序不一致时,编译器只给警告,程序照常编译,读到的值却是内存里的残留内容。-O0 与 -O2 下的数字不同,说明这个值本来就没有定义,加上 -O2 之后编译器多给出了一条未初始化的提示。换一个写法把它写得确定,比研究它在某个档位下的具体数字更值得做。
1# 所属目录:/home/cocatrice/cpp05/demo 2edge.cpp: In constructor ‘Reorder::Reorder(int)’: 3edge.cpp:22:6: warning: ‘Reorder::_a1’ will be initialized after [-Wreorder] 4 int _a1; 5 ^ 6edge.cpp:21:6: warning: ‘int Reorder::_a2’ [-Wreorder] 7 int _a2; 8 ^ 9edge.cpp:10:2: warning: when initialized here [-Wreorder] 10 Reorder(int a) 11 ^ 12edge.cpp: In constructor ‘Reorder::Reorder(int)’: 13edge.cpp:22:6: warning: ‘Reorder::_a1’ will be initialized after [-Wreorder] 14 int _a1; 15 ^ 16edge.cpp:21:6: warning: ‘int Reorder::_a2’ [-Wreorder] 17 int _a2; 18 ^ 19edge.cpp:10:2: warning: when initialized here [-Wreorder] 20 Reorder(int a) 21 ^ 22edge.cpp: In function ‘int main()’: 23edge.cpp:12:12: warning: ‘r.Reorder::_a1’ is used uninitialized in this function [-Wuninitialized] 24 , _a2(_a1) 25 ^ 26edge.cpp:43:10: note: ‘r’ was declared here 27 Reorder r(1); 28 ^ 29$ ./edge_O0 30_a1 = 1,_a2 = 32765 31_a = 1431655765,_b = 1431655765 32这块内存事先被写成了 0x55,0x55555555 = 1431655765 33sizeof(arr) = 12,数组名不退化 34 35$ ./edge_O2 36_a1 = 1,_a2 = 0 37_a = 1431655765,_b = 1431655765 38这块内存事先被写成了 0x55,0x55555555 = 1431655765 39sizeof(arr) = 12,数组名不退化 40
把警告开到 -Wextra 也不会提醒未初始化的成员。 GCC 的两个警告档位都没有覆盖到这件事,因此不能指望编译器的提示来发现它,初始化列表要写满写全。
1# 所属目录:/home/cocatrice/cpp05/demo 2edge.cpp: In constructor ‘Reorder::Reorder(int)’: 3edge.cpp:22:6: warning: ‘Reorder::_a1’ will be initialized after [-Wreorder] 4 int _a1; 5 ^ 6edge.cpp:21:6: warning: ‘int Reorder::_a2’ [-Wreorder] 7 int _a2; 8 ^ 9edge.cpp:10:2: warning: when initialized here [-Wreorder] 10 Reorder(int a) 11 ^ 12edge.cpp: In function ‘int main()’: 13edge.cpp:12:12: warning: ‘r.Reorder::_a1’ is used uninitialized in this function [-Wuninitialized] 14 , _a2(_a1) 15 ^ 16edge.cpp:43:10: note: ‘r’ was declared here 17 Reorder r(1); 18 ^ 19(到这里没有输出就说明编译器没有提醒) 20
变长数组属于扩展,-Wall 与 -pedantic 给出的反应不同。 数组长度是运行时才确定的参数,标准里不允许,GCC 把它当扩展接受。只开 -Wall 时提示的是数组定义了没有使用,加上 -pedantic 才会看到标准层面的那条警告。
1# 所属目录:/home/cocatrice/cpp05/demo 2jz64.cpp: In member function ‘int Solution::Sum_Solution(int)’: 3jz64.cpp:21:7: warning: unused variable ‘arr’ [-Wunused-variable] 4 Sum arr[n]; 5 ^ 6$ ./jz64 7Sum_Solution(10) = 55 8Sum_Solution(100) = 6105 9 10jz64.cpp: In member function ‘int Solution::Sum_Solution(int)’: 11jz64.cpp:21:12: warning: ISO C++ forbids variable length array ‘arr’ [-Wvla] 12 Sum arr[n]; 13 ^ 14jz64.cpp:21:7: warning: unused variable ‘arr’ [-Wunused-variable] 15 Sum arr[n]; 16 ^ 17(上面是加 -pedantic 之后的输出) 18
实测数据
下面四张表是从上面的回显里整理出来的对照数据,运行环境是 CentOS 7.9.2009 与 g++ 4.8.5,编译选项均为 -std=c++11。
第一张表是拷贝省略的三档对照,四个数字依次是构造、拷贝构造、赋值与析构的次数。
| 用例 | -O0 与 -O2 | -O0 -fno-elide-constructors |
|---|---|---|
| 有名对象传值传参 | 1 / 1 / 0 / 1 | 1 / 1 / 0 / 1 |
| 隐式转换传值传参 | 1 / 0 / 0 / 1 | 1 / 1 / 0 / 2 |
| 匿名对象传值传参 | 1 / 0 / 0 / 1 | 1 / 1 / 0 / 2 |
| const 引用传参 | 1 / 0 / 0 / 0 | 1 / 0 / 0 / 0 |
| const 引用传匿名 | 1 / 0 / 0 / 1 | 1 / 0 / 0 / 1 |
| 返回值丢掉 | 1 / 0 / 0 / 1 | 1 / 1 / 0 / 2 |
| 返回值初始化新对象 | 1 / 0 / 0 / 0 | 1 / 2 / 0 / 2 |
| 返回值赋给已有对象 | 2 / 0 / 1 / 1 | 2 / 1 / 1 / 2 |
第二张表是对象与静态成员在内存里的对照,数据来自 static_member.cpp 与 inner_demo.cpp 的运行结果。
| 观察项 | 实测值 | 说明 |
|---|---|---|
| sizeof(A),类里有一个 int 成员与一份静态计数 | 4 | 静态成员不占对象空间 |
| 对象 aa1 的地址 | 0x7ffc770b5960 | 栈上的地址 |
| 静态成员 _scount 的地址 | 0x6021b4 | 数据段里的地址 |
| nm 里 _scount 的符号类型 | B | 未初始化数据段 |
| sizeof 静态成员函数指针 | 8 | 与普通函数指针相同 |
| sizeof 非静态成员函数指针 | 16 | 需要额外的信息来定位对象 |
| sizeof(A::B),内部类 | 4 | 内部类不占外部类对象的空间 |
第三张表是 gdb 在两个构造函数上下断点后的命中次数,程序是 stackdepth.cpp。
| 编译档位 | A::A(int) 命中 | A::A(const A&) 命中 | 多出来的调用来自哪里 |
|---|---|---|---|
| -O0 -g | 1 | 1 | 没有多余调用 |
| -O0 -g -fno-elide-constructors | 1 | 3 | Make 的返回处一次,main 里初始化 a1 处两次 |
第四张表是同一份代码在不同标准档位下的结果,代码是 err10.cpp。
| 编译选项 | 结果 |
|---|---|
| -std=c++98 | 编译通过,成员声明处的缺省值给出一条警告 |
| -std=c++11 | 编译通过,缺省值正常生效,输出 1 |
| -std=c++14 | g++ 报 unrecognized command line option,源代码没有被编译 |
| -std=c++17 | 与 -std=c++14 相同 |
实例
最后一个程序把本章的主要知识点串在一起:静态成员变量统计存活数量,静态成员函数读出这个数量,内部类读取外部类的私有静态成员,匿名对象在一行之内构造和析构,const 引用接住临时对象,排序时传入一个匿名对象当比较器。
1// 文件:/home/cocatrice/cpp05/demo/composite.cpp 2#include <iostream> 3#include <algorithm> 4#include <functional> 5using namespace std; 6 7class Tracked 8{ 9public: 10 Tracked(int id = 0) 11 : _id(id) 12 { 13 ++_alive; 14 cout << "构造 Tracked(" << _id << "),存活 " << _alive << " 个" << endl; 15 } 16 17 Tracked(const Tracked& t) 18 : _id(t._id) 19 { 20 ++_alive; 21 ++_copies; 22 cout << "拷贝构造 Tracked(" << _id << "),存活 " << _alive 23 << " 个,累计拷贝 " << _copies << " 次" << endl; 24 } 25 26 ~Tracked() 27 { 28 --_alive; 29 } 30 31 int GetId() const 32 { 33 return _id; 34 } 35 36 static int GetAlive() 37 { 38 return _alive; 39 } 40 41 static int GetCopies() 42 { 43 return _copies; 44 } 45 46 class Guard 47 { 48 public: 49 Guard() 50 { 51 cout << "Guard 记录下的存活数 " << _alive << endl; 52 } 53 54 int Alive() const 55 { 56 return _alive; 57 } 58 }; 59 60private: 61 int _id; 62 static int _alive; 63 static int _copies; 64}; 65 66int Tracked::_alive = 0; 67int Tracked::_copies = 0; 68 69int main() 70{ 71 Tracked t1(1); 72 cout << "---- 内部类 Guard 读外部类的私有静态成员 ----" << endl; 73 Tracked::Guard g; 74 cout << "Guard::Alive() = " << g.Alive() << endl; 75 76 cout << "---- 匿名对象调一次成员函数 ----" << endl; 77 cout << "匿名对象读到 " << Tracked(9).GetId() << endl; 78 cout << "调用之后存活 " << Tracked::GetAlive() << " 个" << endl; 79 80 cout << "---- const 引用接住一个匿名对象 ----" << endl; 81 const Tracked& r9 = Tracked(7); 82 cout << "r9.GetId() = " << r9.GetId() << endl; 83 84 cout << "---- 用匿名对象做比较器排序 ----" << endl; 85 int a[] = { 32, 71, 12, 45, 26, 80, 53, 33 }; 86 sort(a, a + 8, greater<int>()); 87 for (int i = 0; i < 8; ++i) 88 { 89 cout << a[i] << ' '; 90 } 91 cout << endl; 92 93 cout << "---- 传值传参与 const 引用传参 ----" << endl; 94 Tracked t2(2); 95 cout << "传值之前累计拷贝 " << Tracked::GetCopies() << " 次" << endl; 96 Tracked a1 = t2; 97 Tracked& r2 = t2; 98 cout << "传值之后累计拷贝 " << Tracked::GetCopies() << " 次" << endl; 99 cout << "r2.GetId() = " << r2.GetId() << ",a1.GetId() = " << a1.GetId() << endl; 100 cout << "程序结束时存活 " << Tracked::GetAlive() << " 个" << endl; 101 return 0; 102} 103
1# 所属目录:/home/cocatrice/cpp05/demo 2 3$ ./composite 4构造 Tracked(1),存活 1 个 5---- 内部类 Guard 读外部类的私有静态成员 ---- 6Guard 记录下的存活数 1 7Guard::Alive() = 1 8---- 匿名对象调一次成员函数 ---- 9构造 Tracked(9),存活 2 个 10匿名对象读到 9 11调用之后存活 1 个 12---- const 引用接住一个匿名对象 ---- 13构造 Tracked(7),存活 2 个 14r9.GetId() = 7 15---- 用匿名对象做比较器排序 ---- 1680 71 53 45 33 32 26 12 17---- 传值传参与 const 引用传参 ---- 18构造 Tracked(2),存活 3 个 19传值之前累计拷贝 0 次 20拷贝构造 Tracked(2),存活 4 个,累计拷贝 1 次 21传值之后累计拷贝 1 次 22r2.GetId() = 2,a1.GetId() = 2 23程序结束时存活 4 个 24
这段程序跑出来的输出可以分成下面五段来看。第一段是单个对象的构造,_alive 从 0 变成 1。第二段用了内部类 Guard,它在自己的构造函数里读到外部类的私有静态成员 _alive,读到的是 1,说明内部类确实拥有访问外部类私有成员的权限。第三段是匿名对象 Tracked(9).GetId(),这一行构造了一个临时对象、读到它的成员、随即析构,之后存活数回到 1,这正是匿名对象生命周期只在一行的体现。第四段把匿名对象交给 const 引用,const Tracked& r9 = Tracked(7); 之后 r9 仍然可用,读到 7。第五段先构造 t2,再用它初始化 a1,累计拷贝从 0 变成 1,而 r2 是引用,引用本身不产生拷贝,最后程序结束时存活 4 个对象,也就是 t1、r9 接住的临时对象、t2 与 a1。
踩坑点
- 初始化列表的书写顺序与成员的初始化顺序无关,实际顺序按类里的声明顺序走,顺序反了结果就反了。
- 引用成员、const 成员与没有默认构造函数的类类型成员必须写进初始化列表,放进构造函数体里已经来不及。
- 声明顺序与列表顺序不一致时
-Wall只给-Wreorder警告,程序照样编过,读到的值不确定。 - 内置类型成员漏在初始化列表外面时,
-O0与-O2读到的值不同,-Wall与-Wextra都不会提醒这件事。 - 成员声明处的缺省值属于 C++11 及以后的特性,用
-std=c++98编译时编译器只给一条警告,程序仍然照跑。 - 静态成员只在类内声明而忘了写类外定义时,错误推迟到链接阶段,报错末尾是
collect2: error: ld returned 1 exit status。 - 静态成员在类内声明处直接给初值会被拒绝,这个位置只负责声明。
- 静态成员函数没有
this指针,直接访问非静态成员会得到invalid use of member。 - 静态成员函数既可以用对象调用也可以用类名调用,两种写法的结果相同,类名调用更能说明它不属于某个对象。
- 静态成员的名字待在类域里,类外访问要带上
类名::限定,不能只写成员名。 - 友元关系是单向的,A 把 B 声明为友元只说明 B 能访问 A 的私有成员。
- 友元关系不能传递,A 是 B 的友元、B 是 C 的友元,A 与 C 之间没有任何权限关系。
- 友元函数不是类的成员函数,它没有
this指针,要访问的对象必须从参数传进来。 - 友元声明可以写在类里的任何位置,放在 private 区域与放在 public 区域效果相同。
- 内部类是独立的类,外部类的对象里不包含它的成员,用
sizeof可以直接验证这一点。 - 内部类默认能访问外部类的私有成员,但它没有外部类的
this,外部对象仍然要从参数传进来。 - 放在 private 区域的内部类,类外面既不能构造它的对象,也不能使用它的名字。
- 匿名对象的生命周期只到这一行结束,构造与析构发生在同一行里。
- 把临时对象绑定到 const 引用可以延长它的生命周期,非 const 引用绑不上临时对象。
- 拷贝省略在
-O0下同样发生,调低优化档位并不能阻止它。 - 拷贝省略省掉的是调用,不是检查,拷贝构造函数该可用还是得可用。
- 用打印或静态计数统计构造次数时,省略会让计数偏小,要观察真实次数得加
-fno-elide-constructors。 A aa1();会被解析成函数声明,这行代码不会构造任何对象,要写A aa1;。- 变长数组
Sum arr[n]是 GCC 的扩展,-Wall不提示,加上-pedantic才会看到标准层面的警告。 - 静态成员的状态不会随着函数返回而复位,第二次调用会接着上一次的结果继续累积。
本篇总结(模拟面试问题)
问:初始化列表的初始化顺序由什么决定?
核心要点:按成员在类里的声明顺序执行,与列表里的书写顺序无关;顺序不一致时编译器给出 -Wreorder 警告但不影响编译;建议把两者的顺序写成一致。
问:为什么引用成员与 const 成员必须放进初始化列表?
核心要点:这两类成员没有默认状态,引用要绑定到一个已经存在的对象,const 对象要在出生时就有值;构造函数体执行的时候它们已经必须存在,因此只能放在初始化列表里。
问:成员声明处的缺省值什么时候生效?
核心要点:C++11 起支持这个写法;它作用的对象是那些没有出现在初始化列表里的成员;在 -std=c++98 下编译器只给一条警告,程序仍然能编过并跑出结果。
问:静态成员变量存放在哪里,使用它要满足什么条件?
核心要点:所有对象共用一份,存放在静态存储区,对象的内存里没有它的位置;类内写声明,类外写定义与初始值;漏掉类外定义时错误在链接阶段出现。
问:静态成员函数与普通成员函数有什么区别?
核心要点:静态成员函数没有 this 指针,不能访问非静态成员,可以用类名加作用域限定直接调用;静态成员函数指针占 8 字节,非静态成员函数指针占 16 字节。
问:静态成员有哪些典型用途?
核心要点:统计存活对象个数、给对象发号、充当整个类共用的状态;静态局部对象只构造一次,适合做延迟初始化;代价是引入了全局状态,同步要自己保证。
问:友元关系有哪些限制?
核心要点:单向、不可传递;友元函数不是成员函数,没有 this 指针,对象要从参数传入;声明位置不受访问限定符影响;代价是耦合度上升。
问:内部类与外部类之间是什么关系?
核心要点:内部类是一个独立的类,不受外部类对象大小的影响;它默认是外部类的友元,可以访问外部类的私有成员;放在 private 区域之后,它就只归外部类使用。
问:匿名对象的生命周期有多长?
核心要点:没有名字,生命周期只到这一行结束,构造与析构在同一行完成;绑定到 const 引用之后生命周期延长到引用的作用域结束;排序时传入的 greater<int>() 就是匿名对象。
问:什么是拷贝省略,它在哪些场合发生?
核心要点:标准允许编译器跳过临时对象的拷贝构造与析构;常见于临时对象初始化同类型对象、按值返回临时对象、按值传参且实参是临时对象这三类场合;-O0 与 -O2 都会发生,-fno-elide-constructors 可以关掉。
问:为什么统计构造次数的实验会得到不同的数字?
核心要点:编译器合法地省掉了拷贝构造的调用;打印计数与 gdb 断点计数都会偏小;gdb 的调用栈可以直接看出多出来的拷贝挂在哪个函数上。
问:g++ 4.8.5 在标准支持上有什么限制?
核心要点:只认 -std=c++98 与 -std=c++11,-std=c++14 与 -std=c++17 会报选项不认识;C++17 起一部分拷贝省略从允许改成必须,本机没有办法给出实测对照。
参考
- 构造函数与初始化列表的完整规则:https://en.cppreference.com/w/cpp/language/constructor
- 静态成员与静态成员函数:https://en.cppreference.com/w/cpp/language/static
- 友元函数与友元类:https://en.cppreference.com/w/cpp/language/friend
- 嵌套类的定义与可见性:https://en.cppreference.com/w/cpp/language/nested\_types
- 对象的生命周期与临时对象:https://en.cppreference.com/w/cpp/language/lifetime
- explicit 说明符:https://en.cppreference.com/w/cpp/language/explicit
- 转换构造函数:https://en.cppreference.com/w/cpp/language/converting\_constructor
- 拷贝省略的规则与场合:https://en.cppreference.com/w/cpp/language/copy\_elision
- 拷贝构造函数:https://en.cppreference.com/w/cpp/language/copy\_constructor
- 析构函数:https://en.cppreference.com/w/cpp/language/destructor
- 默认构造函数:https://en.cppreference.com/w/cpp/language/default\_constructor
- 成员访问限定符:https://en.cppreference.com/w/cpp/language/access
- 非静态数据成员与初始化:https://en.cppreference.com/w/cpp/language/data\_members
- GCC 优化选项与 -O 档位:https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html
- GCC 的 C++ 方言选项与 -fno-elide-constructors:https://gcc.gnu.org/onlinedocs/gcc/C\_002b\_002b-Dialect-Options.html
- GCC 的警告选项与 -Wall、-Wextra、-pedantic:https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
- gdb 在函数上下断点:https://sourceware.org/gdb/current/onlinedocs/gdb/Breakpoints.html
- gdb 查看调用栈:https://sourceware.org/gdb/current/onlinedocs/gdb/Backtrace.html
- nm 查看符号表:https://sourceware.org/binutils/docs/binutils/nm.html
- g++ 手册页:https://man7.org/linux/man-pages/man1/g++.1.html
- 静态成员的相关说明:https://www.runoob.com/cplusplus/cpp-static-members.html
参考文档
- Primers 编程伙伴/C/标准库/memset
- Primers 编程伙伴/HTML/HTML 元素/b
- Primers 编程伙伴/Bash/帮助手册/sort
- Primers 编程伙伴/C/标准库/exit
《【C++】类与对象(末):static、友元与拷贝优化》 是转载文章,点击查看原文。
