C++ 程序结构

• C++ 是面向对象和过程的范式的集合

Comment

注释：被编译器忽略的文本

• /**/：允许多行注释
• //：单行注释

Library

库：提前编写的能执行有用操作工具集合

库引入

• #include <>：头文件是C++标准中的系统库
• #include ".h"：其他库、自行编写的头文件

Namespace

命名空间：被切分为代码段的结构，为确保定义在大系统中各部分 程序的元素名称（如：变量名、函数名等）不会相互混淆

• std：C++标准库的命名空间

• 需要告诉编译器定义所属的命名空间才能引用头文件中的名称

函数

为方便理解，大多数程序被划分为几个较小的易于理解的函数

• Prototype：函数原型，函数定义的首行加上分号结尾组成
• 主程序：每个C++程序必须有main函数，指明程序计算 的开始点，main函数结束时，程序执行也随之结束

Variable

变量：一个命名的、能够存储特定类型值的一块内存区域

• 在变量生存期内，所有变量的名字、类型都是不改变的， 而变量的值一般会随着程序运行发生改变

• 可以将变量视为盒子

  • 变量名：作为和盒子的标签在盒子外
  • 变量值：在盒子里物品

• C++/C中变量的解释是由变量类型而不是值决定， 存储值一样，可能会有不同的处理方式

  • 引用、指针都存储地址，但是引用可以直接作为变量使用， 指针则需要解引用

• initializer：初始化，初始值作为声明的一部分
• 变量类型、修饰符参见cs_cppc/basics/mem_ctl

Scope

变量作用域

Local Variable

局部变量：声明在函数体内，作用域可以扩展到其 声明所在块

• 函数被调用时：为每个局部变量分配在整个函数调用时期 的存储空间
• 函数返回时：所有局部变量消亡

• 局部变量一般存储在函数栈中

Global Variable

全局变量：声明在函数定义外，作用域为其声明所在文件

• 生命期为程序运行的整个运行期，可用于存储函数调用的值
• 可以被程序中任意函数操作，难以避免函数间相互干扰

• 除声明全局常量外，不采用全局变量易于管理程序
• 全局变量一般存储在静态区中

Declare

声明：主要功能是将变量的名字和变量包含值类型相关联

• 在使用变量之前必须声明
• 变量声明在程序中的位置决定了变量的scope

• 事实上，函数、类等都可以提前声明，有些时候必须如此，以 使用forward reference（前向引用，定义之前声明指向其的 指针）

Identifier

标识符：变量、函数、类型、常量等名字的统称

• 必须以字母、_开始
• 所有字符必须是字母、数字、_，不允许空格或其他特殊字符
• 不能包含保留字

• 标识符中大小写字母是不同的
• 标识符可以取任意长度，但是C++编译器不会考虑任何超过31个 字符的两个名字是否相同

Shadowing

遮蔽：程序代码内层块中变量隐藏外层块中同名变量的行为

隐式类型转换

数值类型转换

• 提升型转换：通常不会造成数值差异

  • 小整数char、short转换到int
  • float转换到double

• 可能存在转换误差的转换

  • 负数转换为无符号类型：二进制位不变，即为负数对应补码 正数
  • 其他类型转换为bool类型
  • 浮点数转换为整数：截断，若出现数值溢出，则出现未定义 行为

指针类型转换

• 空指针void *、任意指针类型类型之间相互转换
• 衍生类指针转换为基类指针，同时不改变const、volatile 属性
• C风格数组隐式把数组转换为指向第一个元素的指针
  • 容易出现错误

    1 2 3

    char * s = "Help" + 3; # ”Help"被转换为指向数组指针，向后移3位 # `s`指向最后元素`p`

强制类型转换

• 上行转换：派生类指针、引用转换为基类表示
• 下行转换：基类指针、引用转化为派生类表示

const_cast

const_cast：去掉原有类型的const、volatile属性，将常量 指针、引用转换为非常量

• 常量指针转化为非常量指针，仍来指向原来对象
• 常量引用转换为非常量引用，仍然指向原来对象

• 一般用于修改指针，如const char *p
• 要求期望去常量目标非常量，否则为未定义行为

1
2
3
4
5
6
7
8
9
10
11

int ary[4] = {1, 2, 3, 4};
	// 去常量化目标非常量
const int * c_ptr = ary;
	// 常量化数组指针
	// 不能直接数组中值
int * ptr = const_cast<int*>(c_ptr);
	// 去`const`，强制转换为非常量化指针
	// 可以修过数组中值
for(int i = 0; i < 4; i++){
	ptr[i] += 1;
}

未定义行例

• 堆区常量

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  int con_cast(){ const int * c_val_ptr = new const int(1); // 常量值，非常量指针 int vec_before[*c_val_ptr]; // 常量声明数组 int & ptr_val = const_cast<int &>(*c_val_ptr); ptr_val += 1; // 可以正常给值加1 // 未定义行为？堆区不存在常量？ int vec_after[*c_val_ptr]; // 常量生命数组 cout << sizeof(vec_before) << endl << sizeof(vec_after) << after; // 二者长度均为`8`，即常量在`vec_before`创建前已处理 cout << *c_val_ptr << endl << ptr_val << endl << c_val_ptr << endl << &ptr_val; // 地址、值均相同 }

• 栈区常量

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  int con_cast(){ const int c_val= 1; // 常量值 int vec_before[c_val]; // 常量声明数组 int & ptr_val = const_cast<int &>(&c_val); ptr_val += 1; // 可以正常给值加1 int vec_after[c_val]; // 常量生命数组 cout << sizeof(vec_before) << endl << sizeof(vec_after) << after; // 二者长度均为`4`，即常量值已处理，但没有改变 cout << c_val << endl << ptr_val << endl << &c_val<< endl << &ptr_val; // 地址保持相同、但二者值不同 }

• 以上代码在g++4.8.5中测试

static_cast

static_cast：静态类型转换，无条件转换

• 类层次中基类、派生类之间指针、引用转换

  • 上行转换：派生类完全包含基类所有成员，安全
  • 下行转换：派生类包含独有成员，没有动态类型检查，对象 为派生类实例时转换不安全

  • 基类、派生类之间转换建议使用dynamic_cast

• 基本类型转换：安全性需要开发者维护

  • int、char、enum、float之间相互转换
  • 空指针转换为目标类型指针：不安全
  • 任何类型表达式转换为void类型

• 不能进行无关类型指针（无继承关系、float与int等）之间 转换，而C风格强转可以
• 不能转换掉原有类型的const、volatile、__unaligned 属性
• 静态是相对于动态而言，只在编译时检查，编译时已经确定转换 方式，没有运行时类型检查保证转换安全性

1
2
3
4
5
6
7
8
9
10
11
12

float f_pi = 3.141592f
int i_pi = static_cast<int>(f_pi)

Sub sub;
	// 衍生类
Base * base_ptr = static_cast<Base*>(&sub);
	// 上行转换，安全

Base base;
	// 基类
sub * sub_ptr = static_cast<Sub*>(&base);
	// 下行转换，不安全

• 和C风格强转效果基本一致（使用范围较小），同样没有运行时 类型检查保证转换安全性，有安全隐患
• C++中所有隐式转换都是使用static_cast实现

dynamic_cast

dynamic_cast：指针、引用动态类型转换，有条件转换

• 安全的基类、派生类之间转换

  • 转型对象为指针：转型失败返回NULL
  • 转型对象为引用：转型失败抛出异常

• 动用runtime type information进行类型安全检查，会有效率 损失

  • 依赖虚函数表将基类指针转换为子类指针？？？
  • 检查对象实例类型，保证转换是安全的，不会出现 子类指针指向父类对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

class Base{
public:
	void print(){
		cout << "i' base" << endl;
	}

	virtual void virtual_foo() {};
}

class Sub: public Base{
public:
	void print(){
		cout << "i'm sub" << endl;
	}
	virtual void virtual_foo();
}

int main(){
	cout << "Sub -> Base" << endl;
	Sub * sub = new Sub();
	sub -> print();
		// 打印：`i'm sub`
	Base * sub2base = dynamic_cast<Base*>(sub);
	if (sub2base != NULL)l{
		sub2base->print();
		// 打印：`i'm base`
	}
	cout << "sub2base val: " << sub2base << endl;

	cout << "Base -> Sub" << endl;
	Base * base = new Base();
	base->print();
		// 打印：`i'm base`
	Sub * base2sub = dynamic<Sub*>(base);
	if (base2sub != NULL){
		base2sub -> print();
		// 未打印
	}
	count << "base2sub val: " << base2sub << endl;

	delete sub;
	delete base;
	return 0;
}

• 涉及面向对象的多态性、程序运行时的状态，主要是用于虚类 类型上行转换
• 同编译器的属性设置有关，所以不能完全使用C语言的强制转换 替代，常用、不可缺少

reinterpret_cast

reinterpret_cast：仅仅是重新解释给出对象的比特模型 ，没有对值进行二进制转换

• 用于任意指针、引用之间的转换
• 指针、足够大的整数（无符号）之间的转换

1
2
3
4
5
6

int * ptr = new int(233);
uint32_t ptr_addr = reinterpret_cast<uint32_t>(ptr);
count << "ptr addr: " << hex << ptr << endl
	<< "ptr_add val: " << hex << ptr_addr << endl;
	// 二者输出值相同
delete ptr;

• 处理无关类型转换，通常为位运算提供较低层次重新解释
• 难以保证移植性

C风格

1
2
3
4
5
6
7
8
9
10

Typename b = (Typename) a;

float b = 1.0f;
int c_i = (int)b;
int & c_j = (int&)b;
	// C风格

int cpp_i = static_cast<int>(b);
int & j = reinterpret_cast<int&>(b);
	// 等价C++风格

• 没有运行时类型检查保证转换安全性，可能有安全隐患

Data Type

数据类型：从形式上看，数据类型有两个属性定义

• domain：值集，该类型值的集合
• set of operation：操作集，定义类型的行为

• C++每个数据值都有其相应数据类型
• Primitive Type：基本类型，类型系统整体的建筑块
  • 整型
  • 浮点型
  • 布尔型
  • 字符
  • 枚举类型

Integer

C++定义了3种整数类型：short、int、long

• 由值域大小相互区别

值域

• C++中没有指定3种类型确切值域，其取决于机器、编译器，但是 设计者可以更确切的定义各整形值域

  • short、int、long类型内存不减
  • int类型最大值至少$2^{15}-1$
  • long类型最大值至少$2^{31}-1$

• 一般的

  • short：2bytes
  • int：4bytes
  • long/long long：8bytes

• 若希望明确值域，尝试<cstdint>中自定义类型

unsigned

• 各整形均可以在其类型之前加上关键字unsigned，构建新的 非负整形

• 无符号整型可以提供有符号整型两倍正值域

• 16进制、8进制等都是无符号输出格式，有符号整形会被 隐式转换位无符号（若传入）

表示

• 整形常量一般写成十进制数字
• 数字以0开始：编译器将其视为八进制数字
• 数字以0x开始：编译器将其视为16进制数字
• 数字L结尾：显式指明整数常量的类型为long（表达式中）
• 数字U结尾：整形常数被认为时无符号整数（表达式中）

Float-Point

C++中定义了3种浮点类型：float、double、long double

值域

C++同样没由指定这些类型的确切表示

• float、double、long double占用内存不减、精度 不减

表示

• 通常使用带有小数点的十进制数字
• 支持科学计数法风格：浮点数乘以十的整数幂

Bool

布尔类型：具有合法常量值true、false的数据类型

Char

C++中表示字符的预定义基本类型：char

• C++标准库定义wchar_t类型表示宽字符以扩展ASCII编码范围

值域

出现在屏幕、键盘上的字母、数字、空格、标点、回车等字符集合

• 在机器内部，这些字符被表示成计算机赋给每个字符的数字代码
• 多数C++实现中，表示字符的代码系统为ASCII

表示

• ''：单引号括起的一个字符表示字符常量
• escape sequence：转移序列，以\开始的多个字符表示 特殊字符

对比整形

• 整形没有1byte大小类型，很多情况下使用char类型存储 整数值以节省空间

• 但C/C++某些[unsigned ]char、整形处理有区别

输入、输出

• 对[unsigned ]char类型总是输出字符，而不是数字串

  • 输出流：关于整形的流操纵符对[unsigned ]char无效， 即使是无符号类型
  • 格式化输出：指定输出格式得到数字串，包含隐式类型转换

String

字符串：字符序列

• C风格的字符串就是以\0结尾的字符数组

• \0：null character，空字符，对应ASCII码为0

表示

• ""：双引号括起的字符序列表示字符串常量
• 允许使用转移序列表示字符串中特殊字符
• 两个、两个以上字符串连续出现在程序中，编译器会自动将其 连接（即可以将字符串分行书写）

Enumerated

枚举类型：通过列举值域中元素定义的新的数据类型

1

enum typename { namelist };

值域

• 默认的，编译器按照常量名顺序，从0开始给每个常量赋值
• 允许给每个枚举类型常量显式的赋值
• 若只给部分常量名赋值，则编译器自动给未赋值常量赋最后一个 常量值后继整数值

复合类型

基于已存在的类型创建的新类型

表达式

C++中表达式由项、操作符构成

• term：项，代表单个数据的值，必须是常量、变量、函数调用
• operator：操作符，代表计算操作的字符（短字符序列）

  • binary operator：二元操作符，要求两个操作数
  • unary operator：一元操作符，要求一个操作数

• full expression：完整表达式，不是其他表达式子表达式 的表达式

表达式求值顺序

C++没有规定表达式求值顺序（表达式求值顺序是指CPU计算 表达式的顺序，不同于优先级、结合律）

• sequenced before：若A按顺序先于B，A中任何计算都 先于B中任何计算
• sequenced after：若A按顺序后于B，A中任何计算都晚于 B中任何计算
• unsequenced：若A与B无顺序，则A、B中计算发生顺序 不确定，并且可能交叉
• indeterminately sequenced：若A与B顺序不确定，则 A、B计算发生顺序不确定，但不能交叉
• 对无顺序、顺序不确定求值，不要求两次不同求值使用相同顺序

• 完整表达式的求值、副作用先于下个完整表达式的求值、 副作用

• 表达式中不同子表达式的求值无顺序

  • 除非特殊说明，运算符的不同操作数求值是无顺序的
  • 运算操作数值计算先于运算符结果值计算

• 对同一简单对象

  • 两个不同副作用无顺序，则为无定义行为
  • 副作用与需要此对象值的计算无顺序，则为无定义行为

  1 2 3

  int i = 0; i++ + i++; // 两`i++`对i`均副作用、无顺序，未定义行为 i + i++; // `i++`副作用、`+`计算无顺序，未定义行为

• 函数调用时：不仅限于显示函数调用，包括运算符重载、构造、 析构、类型转换函数

  • 实参求值、副作用先于函数体任何语句、表达式求值

  • 函数不同实参求值、副作用无顺序

    1 2 3

    int func(int, int); int i = 0; func(i++, i++); // 参数计算`i++`对`i`均有副作用，无定义行为

  • 主调函数中任何既不先于、也不后于被调函数的求值，其 与被调用函数都是顺序未指定，即主调函数中任何求值 与被掉函数不交叉

    1 2 3 4

    int foo(int); int i = 0, j = 0, k = 0; (i++ + k) + foo(j++); (i++ + k) + foo(i++);

  • 不同形参初始化是顺序未指定

• 自增、自减

  • 后缀形式：i++、i--
    • 值计算先于对变量的修改
    • 与其顺序未指定函数调用不能插入值计算、变量修改 之间
  • 前缀形式：++i、--i
    • 返回被更新之后的操作数（左值）
    • i非布尔值时，++i、--i等价于i+=1、i-=1

• new

  • 内存分配函数与初始化参数求值顺序未指定
  • 新建对象初始化先于new表达式计算

• 逻辑与&&、或||为短路求值

  • 左操作数计算先于右操作数计算
  • 左操作数为false、true时，右操作数不会被求值

• ?:中三个操作数只有两个会被求值

  • 第一个操作数求值先于后两个操作数求值
  • 第一个操作数值为true时，第二个操作数被求值，否则 第三个操作数被求值

• 赋值运算符=

  • 左、右操作数求值先于赋值操作
  • 赋值操作先于赋值表达式值计算
  • 赋值表达式返回其左操作数的左值，此时左操作数必然被 赋值

• 复合赋值运算符e1 op= e2：+=、-=等

  • 求值包括e1 op e2、结果赋给e1、返回e1
  • 任何函数调用不能插入以上步骤

• 逗号,运算符（注意区分逗号分隔符）

  • 左操作数值被丢弃
  • 左操作数值计算、副作用先于右操作数值计算、副作用
  • 被重载后的逗号运算符将生成函数调用，对操作数求值遵循 函数实参求值顺序

• 序列初始化：对{}存在的多个初始化参数求值

  • 初始化参数值计算、副作用先于被逗号分隔的后初始化值 计算、副作用
  • 即使初始化参数引起函数调用，列表每个值作为函数参数， 求值顺序仍然被保留

优先级、结合律

• precedence：优先级，默认情况下（无括号）操作符在运算中 结合的方法

• associativity：结合律，相同优先级的运算符运算顺序， 也即左右操作数的运算顺序

  • left-associative：左结合的，优先计算操作符左侧 表达式，大部分操作符时左结合的
  • right-assiciative：右结合的

• 操作符只是语言的语法，其行为只是人为赋予的规则，其行为 可能符合逻辑，也可能不符合逻辑

混合类型

对于具有不同操作数的操作符，编译器会将操作数转化为其中精度 最高的类型，计算结果也为精度最高的类型，保证计算结果尽可能 精确

整数除法、求余

• 两个整数除法运算：结果为整数，余数（小数）被舍去
• 含负数操作数的除法、求余：依赖硬件特征
  • 求余一般返回同余正值

Type Cast

（值/静态）类型转换：将一种类型明确的转换为另一种类型

1
2
3
4

type(expr)
	# C++风格转换
(type)expr
	# C风格类型转换

• 转换目标类型精度增加不丢失信息，否则可能会丢失信息

• 符号整形转换无符号整形：依赖硬件特征，一般

  • 符号位置于最高位
  • 数值位根据精度
    • 同精度：不变，即包括符号位在内无改变
    • 低精度向高精度：高位用符号位补齐
    • 高精度向低精度：截断、保留低位

• 无符号整形转符号整形

  • 同精度、高精度向低精度：截断、保留低位
  • 低精度向高精度：高位补0

• 即：有符号转为其他类型（有符号、无符号），优先保留符号位

赋值操作

C++中，对变量的赋值是一种内置的表达式结构

• 赋值操作符=要求其左操作数必须是可变的，通常是变量名

• 首先计算赋值操作符右边表达式值，再赋给左边的变量

  • 右操作数可能需要进行类型转换以使其与左操作数的类型 相匹配

• 赋值操作默认（未重载）是通过将源对象所有变量域（栈中 数据），复制到目标对象相应变量域实现的

返回值

C++赋值表达式返回右边表达式的值

• 可以被组合进更大表达式中（但会影响阅读）
• multiple assignment：多重赋值，可以方便给多个变量赋 相同值

Shorthand Assignment

将赋值操作符、二元操作符相结合产生形式

1
2
3

var op= expr;
var = var op expr;
	// 等价

自增、自减

对变量进行+1、-1的更高级别的缩写形式

1
2
3
4
5
6
7
8
9
10
11
12
13
14

x++;
	// 后缀形式
	// 自增前将其原始值返回给临近表达式
++x;
	// 前缀形式
	// 自增后将新值返回给临近表达式
x += 1;
x = x+1;
	// 等价
y--;
--y;
y -= 1;
y = y-1;
	// 等价

布尔运算

Relational Operator

关系操作符

• ==：等于，容易犯错
• !=：不等于
• >：大于
• <：小于
• >=：大于等于
• <=：小于等于

Logical Operator

逻辑操作符：采用布尔类型操作数，组合形成新的布尔值

• !：逻辑非
• &&：逻辑与
• ||：逻辑或

Short-Circuit Evaluation

短路求值：得到结果时就立刻结束计算表达式

• 依赖于：3种逻辑操作符优先级均不同，逻辑运算表达式总是 从左到右计算的

?:

三目操作符，需要3个操作数

1
2
3

(condition) ? expr_1 : expr_2
	// `()`不必须，只是用于强调边界
	// 首先计算`condition`，条件为`true`则返回`expr_1`

Bitwise Operator

位运算符：读取任意标量类型值，将其翻译成与底层硬件相应的 比特序列表示

• &、|、^：位逻辑与、或、异或
• ~：位逻辑非
• >>、<<：右、左移位
  • 无符号数：字尾被移动比特数消失，另一端补0
  • 有符号数：行为依赖于硬件特征，一般保证乘除特性
    • 右移：补1
    • 左移：补0

语句

• simple statement：简单语句，执行某些动作

  • 表达式加分号组成

• control statement：控制语句，控制程序流程

  • 控制语句典型地应用在一条单一语句中

Block

块：{}括起指明一组语句序列是连贯单元的一部分

• 编译器会将整个块当作一条语句对待，也被称为 compound statement
• 常用于使用特定控制语句控制一组语句

Conditional Execution

条件执行：根据检测条件控制程序后续执行

if

1
2

if (condition) statement
if (condition) statement else statement

• if中控制语句可以是一条简单语句，也可以是一个语句块

switch

1
2
3
4
5
6
7
8
9
10
11
12
13

switch (e){
	// `e`：*control expression*
	case c1:
		//`c1`必须是常量标量
		statements
		break;
	case c2:
		statements
		break;
	default:
		statements
		break;
}

• 程序计算控制表达式e的值，将结果同c1、c2相比较

  • case后的常量必须是标量类型，即底层采用整数表示 的类型，如：整形、字符、枚举类型

• 如果常量同控制表达式值相匹配，则跳转至相应case子句执行

  • 执行到子句中break时跳出switch语句
  • 若子句中无break，则接着执行之后case子句中语句， 直到遇到break/return跳出switch语句，这会带来很多 问题，除

    1 2 3 4

    case 1: case 2: statement break;

• default可选，执行没有和控制表达式匹配值的操作

  • 除非确定列举了所有可能情况，否则增加default子句是 好习惯

Iterative Statement

迭代语句：以循环的方式多次执行程序中的一部分

while

一般模式

1
2
3

while (condition-expression){
	statements
}

• 首先查看条件表达式值
• 若条件表达式值为true，整个循环体被执行，然后返回到循环 开始检查条件表达式值
• 若条件表达式值为false，则循环终止

• 每个循环周期，包括第一次循环，条件表达式都会被测试，且 仅在循环开始进行，循环中间条件表达式值改变不会被注意

Read-util-Sentinel Pattern

读直到信号量模式：使用break语句在循环中结束最内层循环

1
2
3
4
5

while(true){
	Prompt user and read in a value
	if (value == sentinel) { break; }
	Process the data value
}

for

以特定的循环次数重复执行某个操作

• 基于条件的循环

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  // 一般模式 for (init; test; step){ statements } init; while(test){ statements step; } // 二者等价 // 常用模式 for(int var=start; var <= finish; var++){ // `var`：*index variable* statement } // 循环`finish - start`次

• range-based for loop：基于范围的循环，C++11开始支持

  1 2 3 4 5 6 7 8 9 10 11 12 13

  for(type var: collection){ statements } // `foreach.h`接口中的定义宏，提供类似功能 foreach(type var in collection){ } // C++编译器通过迭代器，将基于范围的循环转换为传统循环 for(ctype::iterator it = collection.begin()); it != collection.end(); it++){ // `ctype`：集合类型 }

编译、汇编、执行

步骤

Preprocess

预处理：生成.i预处理文件

• 宏替换
• 注释的消除
• 寻找相关头文件/接口：除默认搜索路径，还可以通过环境变量
  设置
  • C_INCLUDE_PATH；C头文件搜索路径
  • CPLUS_INCLUDE_PATH：C++头文件搜索路径
  • CPATH：C/C++头文件搜索路径

1
2

$ g++ -E src.cpp > src.i
	// 激活预处理，输出重定向到文件中

Compile

编译：将预处理后的文件编译为汇编语言，生成汇编文件.s

• 编译单位为文件

1

$ g++ -S src.i -o src.s

Assemble

汇编：生成目标机器代码，二进制.o中间目标文件

• .o通常仅解析了文件内部变量、函数，对于引用变量函数 还未解析，需要将其他目标文件引入

1

$ g++ -C src.s -o src.o

• Windows下生成.obj文件

Link

链接：链接目标代码，生成可执行程序

• gcc通过调用ld进行链接
• 主要是链接函数、全局变量
• 链接器关注/链接二进制.o中间目标文件
• Library File：若源文件太多，编译生成的中间目标文件 过多，把中间目标文件打包得到.lib/.a文件

1

$ g++ src.o -o a.out

执行

序列点

• 对C/C++表达式，执行表达式有两个类型动作
  • 计算某个值
  • 产生副作用：访问volatile对象、原子同步、修改文件

内存布局

程序内存结构

• static area：静态区，存储程序指令（按位存储）、 全局变量

  • 位于地址编址号较小、接近地址空间开始处
  • 该区域中分配的内存大小在程序整个执行期间不发生改变

  • 正文段：CPU执行机器指令

    • 每个程序只有一个副本
    • 只读，避免程序因为意外事故而修改自身指令

  • 初始化数据段：程序中所有赋初值全局变量

  • 非初始化数据段（bss段）：程序中所有未初始化全局变量

    • 内核将此段初始化为0

• heap area：堆区，程序运行期间动态分配

  • 程序中未分配的可用内存池
  • 处于栈区、静态区之间
  • 缺乏组织
  • 需要寻址、操作速度慢
  • 可以用于存储编译时未知大小、可变数据

• stack area：栈区，存放函数栈帧

  • 最高地址区
  • 程序每调用函数、方法都会在此内存区域中创建新的栈帧， 函数返回所创建栈帧会被撤销，释放内存
  • 操作迅速，不需要寻址
  • 数据大小已知、固定

• 堆、栈以相反方向增长，方便任一区域都可以依照需要增长， 直到所有可用内存耗尽

内存分配

• static allocation：静态分配，声明全局变量、常量时， 编译器为其在静态区中分配在整个程序生命周期内持久的内存 空间
• automatic allocation：自动分配，调用函数时，编译器为 局部变量在栈帧分配存储空间，函数返回时空间自动释放
• dynamical allocation：程序允许时，动态获得内存空间

• stack frame：栈帧

  • 栈帧随机为函数中局部变量分配内存、地址
  • 栈帧中还包含额外信息，其结构取决于机器架构

• 变量：C++中声明变量时，编译器必须保证给声明变量分配足够 内存存储该类型变量值，分配内存大小取决于变量类型

Pointer

• C++设计原则：应该尽可能多的访问到有底层硬件提供的机制， 所以C++语言使得内存位置的地址对程序员可见

指针：值是内存中一个地址的数据项

• 指针允许以压缩方式引用大的数据结构
• 指针使得程序在运行时能够预订新的内存
• 指针可以用于记录数据项之间关系

Lvalue、Rvalue

• lvalue：左值，引用内存中能够存储数据的内存单元的表达式
• rvalue：右值，非左值表达式
• xvalue：返回右值引用的函数、表达式

• gvalue：lvalue、xvalue总称

• 具体参见cs_program/program_design/language_design

左值引用

左值引用：只能绑定左值，绑定有其他对象内存空间的变量

• 建立引用时是将内存空间绑定

  • 使用的是对象在内存中位置
  • 则被引用对象需要是左值
  • 则不能将右值绑定到左值引用上

• 常量左值引用保证不能通过引用改变对应内存空间值

  • 尝试绑定右值引用时，编译器会自动为右值分配空间
  • 则可以将右值绑定在常量（左值）引用上

1
2
3
4
5
6
7
8
9

int foo(42);
int& bar = foo;
	// OK：`foo`是左值，使用其在内存中位置
int& baz = 42;
	// Err：`42`是右值，不能将其绑定在左值引用上
const int& quz = 42;
	// OK：`42`是右值，但编译器可以为其开辟内存空间
int& garply = ++foo;
	// OK：前置自增运算符返回左值

右值引用

右值引用&&：只能且必须绑定右值

• 考虑右值只能是字面常量、或临时对象，则右值引用

  • 是临时的、即将销毁
  • 不会在其他地方使用

• 则接受、使用右值引用的代码，可以自由的接管所引用对象 的资源，无需担心对其他代码逻辑造成数据破坏

  • move sematics：与右值引用交换成员

1
2
3
4
5
6
7
8
9

int foo(42);
int&& baz = foo;
	// Err：`foo`是左值，不能绑定在右值引用上
int&& quz = 42;
	// OK：`42`是右值，可以绑定在右值引用上
int&& quux = foo * 1;
	// OK：`foo * 1`结果是右值，可以绑定在右值引用上
int&& waldo = foo--;
	// OK：后置自减运算符返回右值

Move Sematics

• 使用左值引用对类型X赋值操作流程如下

  1 2 3 4 5

  X& X::operator=(X const & rhs){ // make a clone of what rhs.m_pResource refers to // destruct the resource this.m_pResource refers to // attach the clone to this.m_pResource }

  • m_pResource为X拥有某种资源

• 考虑如下代码中最后一行赋值的执行

  1 2 3

  X foo(); X x; x = foo();

  • 克隆foo()返回的临时对象中资源
  • 析构x中资源，替换为foo()返回临时对象中资源副本
  • 析构foo()返回临时对象

• 以上赋值流程效率低、没有必要，考虑交换x和foo()返回 临时对象资源副本，即move语义

  1 2 3

  X& x::operator=(X&& rhs){ // swap this->m_pResource and rhs.m_pResource }

  • 执行同样x=foo()

    • 此赋值操作只有由编译器自动析构foo()返回的临时 对象
    • x.m_pResource被转移给临时对象，在临时对象析构 时被析构

  • 交换成员其实和右值引用没有必然联系

    • 在其他方法中同样可以交换成员对象
    • 但是只有在参为右值引用时，交换成员对象确保 不会对其他代码逻辑造成破坏

  • 右值引用参数函数是对左值引用参数函数的重载

    • 编译器优先为右值引用调用以右值引用为形参的函数
    • 区分右值引用、左值引用可以尽量节省资源

Perfect Forwarding

完美转发：

引用值类型

• 无论左值引用、右值引用

  • 引用作为变量被保留，则其为左值
  • 否则为右值

• 左值引用

  1 2 3 4 5 6 7 8 9

  int foo(42); int & bar = foo; // `bar`是对`foo`的左值引用 int & baz = bar; // `baz`是对`bar`的左值引用 // `bar`左值引用本身是左值 int qux = ++foo; // 前置自增运算符返回左值引用 // 此时左值引用作为右值

• 右值引用

  1 2 3 4 5 6 7

  class Type; void foo(Type&& bar){ Type baz(bar); // `bar`是左值 } Type&& qux(); quxx = qux();

引用叠加

• C++11中引用叠加规则如下

  • Type& & -> Type&
  • Type& && -> Type&
  • Type&& & -> Type&
  • Type&& && -> Type&&

• C++11之前不支持引用叠加，以下代码报错

  1 2	typedef int& intR; typedef intR& intRR;

指针使用

声明指针

1

int *p1, *p2;

• 编译器需要知道指针base type，才能正确的解释指针地址 中的数据

• *用于指明变量为指针变量

  • 语法上属于变量名：声明时需要给每个指针变量标记*
  • 但拥有基类型：是用于声明、定义的类型

• base type：基类型，指针所指对象的类型

指针使用

• &：取地址
• *：dereferencing，解析引用，取指针所指向对象的值
• ->：解析+选择操作符，取指针指向对象的成员

特殊指针

• this：指向当前对象

  • 解决二义性：引用当前对象的实例变量，即使其被形参、 局部变量覆盖
  • 有建议：总是使用this引用当前实例变量使代码更具有 可读性
  • 类方法调用都将this作为隐含参数，指向当前实例，即 主调函数中类实例

• NULL：null pointer，空指针，不指向任何实际内存地址

  • 在内部表示为0
  • 在<cstddef>中已定义
  • 使用*解释空指针不合法，但不总是能检测出来

引用调用

C++内部通过指针实现引用调用

• 参数通过引用传递时，栈帧会在调用时存储一个指针指向该值 的内存单元
  • 引用参数被声明为引用类型，编译器会自动解析其指针值
• 可以通过明确调用指针替代引用调用的效果

Pointer Arithmetic

指针运算：对指针进行加减的运算

1
2
3
4
5

p + k
	// **定义**为：`&array[k]`
*p++
	// 一元运算符右结合，等价于`*(p++)`
	// 检索数组当前元素，并将索引指向下个元素

• 只有+-运算有意义，且有约束

  • 可以+-整数
  • 不能指针相加
  • 可以指针相减，返回两个指针之间数组元素数量

• 建议使用数组索引而不是指针运算提高可靠性

Array

数组：较低级的多个数据值的集合

• 特性
  • 有序
  • 同质
• 约束
  • 数组分配内存大小固定
  • 数组大小不允许被获得
  • 不支持插入、删除元素
  • 不检查越界：重大安全隐患

• C++提供的内置数组类型，基于从C语言继承而来的语言模型
• 考虑到Vector集合类更加灵活方便，没有什么理由继续使用 数组

数组使用

1
2
3
4
5
6
7
8

type name[size];
	// 声明大小为`size`、类型为`type`的数组`name`
name[idx];
	// 选择数组`name`中`idx`处元素
type static_arr [] = {};
	// 数组静态初始化
const int ARR_LEN = sizeof static_arr / sizeof static_arr[0];
	// 获取数组长度

• 声明：多数情况下，应该使用符号常量而不是确定的整数值指定 数组大小，以便修改代码

• selection：通过数组名+[idx]选择元素

• 静态初始化：可以忽略数组容量，编译器自动从初始化的元素 数目推断

• 获取数组分配容量：基于数组同质性

数组容量

• allocated size：声明时指定的数组容量
• effective size：实际使用到的元素数目

• 声明比需求大的数组
  • 定义常量表示数组元素数目最大值，以此声明数组

指针&数组

数组名同时也用作一个指针值，表示数组中首个元素地址

• 如果编译器遇到数组变量名没带下标，则将其解释为指向数组 开始内存的指针变量

• C++将数组视为指针最重要的原因：数组形参和实参共享

  • 数组和指针作为形参声明函数完全相同
  • 数组作为实参传递时，其值（首个元素地址）类似指针被 复制，调用函数中对数组的改变持久
  • 应该使用能反映其用途的方式声明参数，打算用数组作为 参数就声明参数为数组

• C++中指针、数组最关键区别：变量声明时内存分配

  • 数组：连续的、可以存储数组元素的内存
  • 指针：存储机器地址的一个字的内存，不能直接存储数据

• 指针作为数组使用

  • 将已存在数组首地址赋给指针有严格限制
  • 真正优势是程序运行时动态分配内存创建数组

动态内存管理

分配内存

• 动态分配的内存在分配其的栈帧被释放后仍然保持
• 动态内存分配一定要手动及时释放

new

new：以某种类型，从堆中分配一块空间给所指定类型的变量

• new操作符返回堆中预留的、存储某类型值的地址

  1 2 3 4 5 6 7 8 9

  int *ip = new int; // 从堆中分配单个类型空间给指定指针变量 int *array = new double[4]; // 从堆上给数组分配空间给指定指针变量 // 动态数组 Point *p_1 = new Point; // 从堆上给对象、结构体分配空间，调用默认构造函数 Point *p_2 = new Point(2, 3); // 类型名后提供参数，则`new`会调用相应构造函数

• 一旦在堆中分配了空间，可以通过解析指针来引用

xlloc

释放内存

delete

delete：取new操作符事先分配内存的指针，释放该指针指向 的内存空间

1
2
3
4

delete ip;
	// 释放单个类型空间指针变量
delete[] array;
	// 释放动态数组

释放内存策略

• garbage collection：垃圾回收，自动查找不再使用的内存， 然后释放

拷贝

• shallow copying：浅拷贝，C++默认拷贝

  • 如果值是指针，不会拷贝指针所指的值
  • 可以通过重载赋值操作符、构造拷贝构造函数改变默认的 浅拷贝行为

• deep copying：深拷贝

  • 拷贝指针时，拷贝指针所指的值

关键字

Global Variable

const

const：常量，初始化之后不能改变

• 优势

  • 描述性常量名使得程序更易于阅读
  • 大大简化程序日常中代码维护问题

• const修饰经过依据优先级、其他关键字处理后的主体

  • 指针、值、参数：其他关键字处理得到目标语义主体处
  • 返回值：const置于函数签名头
  • 函数主体：函数体{}前、函数签名后

• C++中常量声明中字符应全部为大写
• 所以常量类成员必须在初始化列表中设置值

static

非成员静态变量

非成员静态变量：程序执行前既已在静态数据区分配内存

• 静态全局变量

  • 未经初始化时会被自动初始化为0
  • internal属性，仅在声明文件内部可见，文件外不可见， 较一般全局变量不容易冲突

  • 普通全局变量：默认external，可以通过extern关键字 被其他文件访问，随机值初始化

• 静态局部变量

  • 仅会在首次声明时被初始化，之后重复声明不会初始化
  • 具有static-storage duration/static extent，仅在 声明其的局部作用域中可见，但不会随函数栈退出而销毁， 适合函数重入需要保存局部状态场合

非成员静态函数

非成员静态函数：作用域仅限于声明文件

• 仅在声明其的文件中可见，不能被其他文件使用，较一般函数 不容易发生冲突

  • 函数定义、声明默认extern，可通过extern关键字在 其他文件中使用

静态成员变量

静态成员变量：程序执行前既已在静态数据区分配内存

• 静态成员变量属于类

  • 在内存中只有一份拷贝，所有类对象共享
  • 可以通过类名直接访问<cls>::<static_var>，若访问 权限允许

• 只能在类中声明，在类外初始化

  • 初始化：<var_type> <cls>::<static_var> = <value>

静态成员函数

静态成员函数

• 静态成员函数属于类

  • 没有this指针
  • 只能访问静态成员变量、静态成员函数
  • 可通过类名直接调用<cls>::<static_func>()，若访问 权限允许

• 类内声明静态成员函数需要static关键字，在类外定义时 无需static关键字

extern

extern：声明使用未定义（全局）变量、函数

• extern修饰的变量可在当前文件、或其他文件中定义

  • 当前文件extern声明处后定义：扩展（全局）变量作用 范围
  • 在其他文件中定义：引用在其他文件中定义的（全局）变量

• 函数声明中extern：仅表示函数可能在其他源文件中定义， 即extern总是可以省略

  • 因为函数声明默认无定义，而变量声明默认同时定义

• extern声明要严格对应定义格式

  • extern char *a不能用于声明char a[6]

• extern不能用于访问其他文件中静态全局变量
• 编译器遇到extern函数、变量时在其他模块中寻找定义

external全局变量

• 全局变量默认为external

  • 虽然作用域默认仅限于为当前文件，但是可以通过 external关键字在其他文件中声明访问
  • 可以通过static关键字使变量internal，在其他文件 中不可见

• 程序中不能有多个同名非静态全局变量

  • 编译时：C++以文件为单位进行编译，可以有多个文件定义 同名非静态全局变量
  • 链接时：链接器将无法确定链接目标报错

头文件全局变量

• 引入头文件相当于直接复制头文件内容，若在头文件中定义 全局变量

  • 头文件可以被多个源文件引入
  • 相当于在多个文件中定义同名全局变量报错

• 头文件中不应定义非静态全局变量

  • 定义静态全局变量：在多源文件中定义不共享、互相独立、 不可见全局变量
  • 在头文件中声明extern全局变量：在某个源文件中仅定义 一次该全局变量，包含该头文件源文件共享该全局变量

extern "C"

extern "C"：指定编译、链接规约，不影响语义

• extern "C"是为C++编译器指定的

  • 编译C++文件时：对extern "C"声明的函数按照C编译规约 翻译名称、编译
  • 链接时：对extern "C"声明的函数按照C链接规约链接

• "C"：是指编译、链接规约，不是指C语言

  • 其他符合类C语言编译、链接规约的语言，如：Fortran、 Assembler，均可以使用extern "C"声明

• C++支持重载，编译器会联合函数名、参数生成中间函数名， 在C++中使用C函数可能导致链接器无法到对应C函数

C++环境使用C函数

C++可以直接使用C函数接口，只是需要指明使用C函数

• 使用extern "C"逐个声明C函数

  1 2 3 4

  extern "C" void func(int a); extern "C"{ void func(int a); }

  • 适合需要声明函数数量较少、分散在不同文件中

• 在头文件中设置宏编译编译条件

  1 2 3 4 5 6 7 8 9 10 11 12 13

  #ifdef __cplusplus #if __cplusplus extern "C"{ #endif #endif /*...c code...*/ #ifdef __cplusplus #if __cplusplus } #endif #endif

  • 仅在C++源文件中有extern "C"声明，保证正常编译、 链接
  • 适合C函数声明集中在同一头文件中

C环境使用C++函数

C环境无法直接使用C++函数，必须转换为C函数接口才能使用

• 通过extern "C"将C++中函数声明为C函数

  1 2 3

  extern "C" void func(int a); void func(int a); void func(int a, int b);

  • 带有extern "C"、不带是两个中函数声明，可以共存
  • 虽然C++中不能对重载函数声明extern "C"，但C不支持 函数重载，也没有必要对重载函数声明extern "C"

• 通过extern "C"创建包装C函数

  • 可以类似C++翻译重载函数名，将重载函数包装为多个C函数

    1 2 3 4 5

    void f(int); void f(doubel); extern "C" void f_i(int i){ f(i); } extern "C" void f_d(double d){ f(d); }

  • 可以包装类成员方法

    1 2 3 4 5 6 7

    class C{ virtual doubel f(int); } extern "C" double call_C_f(C* p, int i){ return p->f(i); }

register

register：寄存器变量，将局部变量值放在运算器的寄存器中

• 存放在寄存器中的变量参与运算时，无需从内存中获取，节省 时间、提高效率

auto

auto：要求编译器对变量类型进行自动推导

• auto声明变量必须初始化，以使编译器能够推导变量类型

  • 从此意义上说，auto是类型声明占位符，编译器在编译时 将auto替换变量实际类型

• auto优势、用途

  • 声明有初始化表达式的复杂类型变量时简化代码
  • 避免声明变量类型时错误：编译器自动选择最合适类型
    • 函数返回值类型不确定，使用auto代替
  • 一定程度上支持泛型编程
    • 修改函数返回值类型时，无需修改代码
    • auto可以结合模板使用，加强泛型能力

• C++11前，auto指具有自动存储期的局部变量，而没有声明为 static变量总是具有自动存储期的变量，使用频率极低

  • 具有自动存储期变量在进入声明该变量的程序块时被建立
  • 存在于程序块存活时，退出程序块时被销毁

注意事项

• auto可以联合volatile、*、&、&&使用

• auto需要被推导为类型

  • 声明变量必须初始化
  • 不能和其他类型联合使用
  • 函数参数、模板参数不能被声明为auto

• auto只是占位符，不是独立类型，不能用于类型转换或其他 涉及具体类型操作，如：sizeof、typeid

• 定义在一个auto序列中变量必须推导为同一类型

• 但auto不会被自动推导为constant&volatile qualifiers， 除非被声明为引用类型

  1 2 3

  const int i = 99; auto j = i; // `j`为`int`类型，不是`const int` auto& k = i; // `i`为`const int&`类型

• auto会退化为指向数组的指针，除非被声明为引用

  1 2 3 4 5 6 7

  int a[9]; auto j = a; count << typeid(j).name() << endl; // 输出`int*` auto& k = a; count << typeid(k).name() << endl; // 输出`int[9]`

decltype

decltype：要求编译器在编译时进行类型推导

• 以普通表达式作为参数，返回表达式类型

  • decltype不会对表达式进行求值

• decltype用途、优势

  • 推导表达式类型
  • 与using/typedef联合使用，定义类型
  • 重用匿名类型
  • 结合auto，追踪函数返回值类型

推导规则

• 若e为无括号的标记符表达式、类成员访问表达式

  • 则decltype(e)为e所命名的实体类型
  • 若e为被重载函数、或实体不存在，将导致编译错误

• 设e类型为T

  • 若e为将亡值，则decltype(e)为T&&
  • 若e为左值，则decltype(e)为T&
  • 若e为纯右值，则decltype(e)为T

volatile

• volatile: a situation that is likely to change suddenly and unexpectedly

volatile：变量可能受到程序外因素影响，不应该对其做出 任何假设

• C/C++中对volatile对象访问，有编译器优化上的副作用， 降低性能

  • 对volatile对象访问必须与内存进行交互，不能直接 使用寄存器中已有值
  • volatile对象相关代码块不允许被优化消失
  • 多个volatile对象访问保序：编译器不可交换 对volatile对象访问的执行次序
    • 不能保证CPU乱序执行不交换执行次序
    • 因此volatile无法解决多线程同步问题

  • X86、AMD64等常用架构CPU只允许store-load乱序， 不允许store-store乱序，此时volatile用于线程同步 是安全的，但是这依赖于硬件规范，且会降低执行效率
  • 推荐使用原子操作、互斥量等实现

• 用途

  • 信号处理相关场合
  • 内存映射硬件相关场合
  • 非本地跳转相关场合

错误线程同步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

volatile bool flag = false;
thread1(){
	flag = false;
	volatile Type* value = new Type();
	thread2(value);

	while(true){
		if(flag == true){
		// 希望`thread2`更新完`value`后继续执行
		// `flag`为`volatile`保证此语句块不会被优化消失
			apply(value);
			break;
		}
	}
	thread.join();
	if(nullptr != value){
		delete value;
	}
	return;
}

thread2(volatile Type* value){
	value->update();
	flag = true;
	// `flag`、`value`均为`volatile`保证两语句不会交换执行次序
	return;
}

• 以上代码即使对相关变量都设为volatile，也依赖CPU执行 规范才能保证安全

__unaligned

• 以下类型为内部类型，由解释器内部使用、但被暴露给用户， 其定义可能随着未来解释器版本更新而变化

  • 代码对象
  • 帧对象
  • 回溯对象
  • 切片对象：参见cs_python/py3ref/dm_basics
  • 静态方法对象：参见cs_python/py3ref/#todo
  • 类方法对象：参见cs_python/py3ref/#todo

Module

模块：python代码的基本组织单元

• 导入系统创建
  • import语句
  • importlibd.import_module()、__import__()函数
• 模块对象具有由字典__dict__实现的命名空间
  • 属性引用：被转换为该字典中查找m.__dict__['x']
  • 属性赋值：更新模块命名字典空间
  • 不包含用于初始化模块的代码对象
  • 模块中定义函数__globals__属性引用其

元属性

• __name__：模块名称
• __doc__：模块文档字符串
• __annotaion__：包含变量标注的字典
  • 在模块体执行时获取
• __file__：模块对应的被加载文件的路径名
  • 若加载自一个文件，某些类型模块可能没有
    • C模块静态链接至解释器内部
  • 从共享库动态加载的扩展模块，该属性为共享库文件路径名
• __dict__：以字典对象表示的模块命名空间

• CPython：由于CPython清理模块字典的设定，模块离开作用域时 模块字典将被清理，即使字典还有活动引用，可以复制该字典、 保持模块状态以直接使用其字典

Code Object

代码对象：“伪编译”为字节的可执行python代码，也称bytecode

• 代码对象和函数对象区别

  • 代码对象不包含上下文；函数对象包含对函数全局对象 （函数所属模块）的显式引用
  • 默认参数值存放于函数对象而不是代码对象
  • 代码对象不可变，也不包含对可变对象的应用

• 代码对象由内置compile()函数返回

  • 可以通过函数对象__code__属性从中提取
  • 可以作为参数传给exec()、eval()函数执行

特殊属性

• co_name：函数名称
• co_argcount：位置参数数量
• co_nlocals：函数使用的本地变量数量（包括参数）
• co_varnames：包含本地变量名称的元组
• co_freevars：包含自由变量的元组
• co_code：表示字节码指令序列的字符串
• co_consts：包含字节码所使用的字面值元组
  • 若代码对象表示一个函数，第一项为函数文档字符，没有 则为None
• co_names：包含字节码所使用的名称的元组
• co_filenames：被编译代码所在文件名
• co_firstlineno：函数首行行号
• co_lnotab：以编码表示的字节码偏移量到行号映射的字符串
• co_stacksize：要求栈大小（包括本地变量）
• co_flags：以编码表示的多个解释器所用标志的整形数
  • 0x04位：函数使用*arguments接受任意数量位置参数
  • 0x08位：函数使用**keywords接受任意数量关键字参数
  • 0x20位：函数是生成器
  • 0x2000位：函数编译时使用启用未来除法特性
  • 其他位被保留为内部使用

Frame Objects

栈帧对象：执行帧

• 可能出现在回溯对象中，还会被传递给注册跟踪函数

特殊只读属性

• f_back：前一帧对象，指向主调函数
  • 最底层堆栈帧则为None
• f_code：此栈帧中所执行的代码对象
• f_locals：查找本地变量的字典
• f_globals：查找全局变量
• f_builtins：查找内置名称
• f_lasti：精确指令，代码对象字节码字符串的索引

特殊可写属性

• f_trace：None，或代码执行期间调用各类事件的函数
  • 通常每行新源码触发一个事件
• f_trace_lines：设置是否每行新源码触发一个事件
• f_trace_opcodes：设置是否允许按操作码请求事件
• f_lineno：帧当前行号
  • 可以通过写入f_lineno实现Jump命令

方法

• .clear()：清楚该帧持有的全部对本地变量的引用
  • 若该栈帧为属于生成器，生成器被完成
  • 有助于打破包含帧对象的循环引用
  • 若帧当前正在执行则会raise RuntimeError

Traceback Objects

回溯对象：表示异常的栈跟踪记录

• 异常被印发时会自动创建回溯对象，并将其关联到异常的可写 __traceback__属性

  • 查找异常句柄使得执行栈展开时，会在每个展开层级的当前 回溯之前插入回溯对象
  • 进入异常句柄时，栈跟踪将对程序启用
  • 获取：sys.exc_info()返回的元组第三项、异常的 __traceback__属性
  • 程序没有合适的处理句柄时，栈跟踪将写入标准错误

• 可通过types.TracebackType显式创建

  • 由回溯对象创建者决定如何链接tb_next属性构成完整 栈追踪

特殊只读属性

• tb_frame：执行当前层级的执行栈帧
• tb_lineno：给出发生异常所在行号
• tb_lasti：最后具体指令

• 若异常出现在没有匹配的except子句、没有finally子句 的try中，回溯对象中的行号、最后指令可能于相应帧对象中 行号不同

特殊可写属性

• tb_next：栈跟踪中下一层级（通往发生异常的帧），没有 下一层级则为None

I/O对象/文件对象

文件对象：表示打开的文件

• 创建文件对象

  • open()内置函数
  • os.popen()、os.fdopen()
  • socket.makefile()

• sys.stdin、sys.stdout、sys.stderr会初始化为对应于 解释器的标准输入、输出、错误流对象

  • 均以文本模式打开
  • 遵循io.TextIOBase抽象类所定义接口

综述

主要标准模块

• os：与Python所在底层操作系统相对应变量、函数

• sys：与Python解释器本身相关的组件

• 文件、目录

  • glob：文件名扩展
  • stat：文件信息

• 并行开发

  • threading、_thread、queue：运行、同步并发线程
  • subprocess、multiprocessing：启动、控制并行进程
  • socket：网络连接、进程间通信

• 系统

  • time、timeit：获取系统时间等相关细节
  • signal、select、shutil、tempfile：多种系统 相关任务

说明

• Python中大部分系统级接口都集中在模块sys、os中

• 以上模块之间具体实现不总是遵循规则

  • 标准输入、输出流位于sys中，但可以将视为与操作系统 模式相关

• 一些内建函数实际上也是系统接口

  • open

Sys模块

平台、版本

1
2
3
4
5
6
7
8
9
10
11
12

import sys
sys.platform
	# 操作系统名称
sys.maxsize
	# 当前计算机最大容纳“原生”整型
	# 一般就是字长
sys.version
	# python解释器版本号
sys.byteorder
	# 平台字节序
sys.hash_info
	# 数值类型hash信息

sys.xxxcheckinterval

1
2
3
4

sys.getcheckinterval()
	# 查看解释器检查线程切换、信号处理器等的频率
sys.setcheckinterval(N)
	# 设置解释器检查线程切换、信号处理器等的频率

• 参数

  • N：线程切换前执行指令的数量

• 对大多数程序无需更改此设置，但是可以用于调试线程性能

  • 较大值表示切换频率较低，切换线程开销降低，但是对事件 的应答能力变弱
  • 较小值表示切换频率较高，切换线程开销增加，对事件应答 能力提升

sys.hash_info

1
2

sys.hash_info.width
	# `hash()`函数截取hash值长度

模块搜索路径

1

sys.path

• 返回值：目录名称字符串组成的列表
  • 每个目录名称代表正在运行python解释器的运行时模块 搜索路径
  • 可以类似普通列表在运行时被修改、生效

sys.path初始化顺序

• 脚本主目录指示器：空字符串

  • 脚本主目录是指脚本所在目录，不是os.getcwd() 获取的当前工作目录

• PYTHONPATH环境变量

  1 2	# .bashrc export PYTHONPATH=$PYTHONPATH:/path/to/fold/contains/module

• 标准库目录

• .pth路径文件：在扫描以上目录过程中，遇到.pth文件会 将其中路径加入sys.path中

  1 2	# extras.pth /path/to/fold/contains/module

导入模块顺序

导入模块时，python解释器

1. 搜索内置模块，即内置模块优先级最高
2. 从左至右扫描sys.path列表，在列表目录下搜索模块文件

嵌入解释器的钩子

1
2
3
4
5
6

sys.modules
	# 已加载模块字典
sys.builtin_module_names
	# 可执行程序的内置模块
sys.getrefcount()
	# 查看对象引用次数

异常

1

sys.exc_info()

• 返回值：(type, value, trackback)
  • 最近异常的类型、值、追踪对象元组
  • 处理该异常的except执行之后，sys.exc_info被恢复 为原始值

• 追踪对象可以使用traceback模块处理

命令行参数

1

sys.argv

• 返回值：命令行参数列表
  • 首项始终为执行脚本名称，交互式python时为空字符串

• 参数可以自行解析，也可以使用以下标准库中模块

  • getopt：类似Unix/C同名工具
  • optparse：功能更加强大

标准流

1
2
3
4
5
6

sys.stdin
	# 标准输入流
sys.stdout
	# 标准输出流
sys.stderr
	# 标准错误流

• 标准流是预先打开的python文件对象

  • 在python启动时自动链接到程序上、绑定至终端
  • shell会将相应流链接到指定数据源：用户标准输入、文件

重定向

• 可以将sys.stdin、sys.stdout重置到文件类的对象，实现 python内部的、普遍的重定向方式

  • 外部：cmd输入输出重定向
  • 局部：指定print参数

• 任何方法上与文件类似的对象都可以充当标准流，与对象类型 无关，只取决于接口

  • 任何提供了类似文件read方法的对象可以指定给 sys.stdin，以从该对象read读取输入

  • 任何提供了类似文件write方法的对象可以指定给 sys.write，将所有标准输出发送至该对象方法上

• 标准库io提供可以用于重定向的类StringIO、ByteIO
• 重定向之后print、input方法将应用在重定向之后的流

stdin

1
2
3
4
5
6
7
8

stdin.read()
	# 从标准输入流引用对象读取数据
input("input a word")
sys.stdin.readlines()[-1]
	# 以上两行语句类似

stdin.isatty()
	# 判断stdin是否连接到终端（是否被重定向）

• 在stdin被重定向时，若需要接受用户终端输入，需要使用 特殊接口从键盘直接读取用户输入
  • win：msvcrt模块
  • linux：读取/dev/tty设备文件

退出

1

sys.exit(N)

• 用途：当前线程以状态N退出
  • 实际上只是抛出一个内建的SystemExit异常，可以被正常 捕获
  • 等价于显式raise SystemExit

• 进程退出参见os._exit()

sys.exitfuncs

1

sys.exitfuncs

编码

1
2
3
4
5

sys.getdefaulencoding()
	# 文件内容编码，平台默认值
	# 默认输入解码、输出编码方案
sys.getfilesystemencoding()
	# 文件名编码，平台默认体系

• win10中二者都是utf-8，win7中文件名编码是mbcs

os模块

• os模块提供了POSIX工具

  • 操作系统调用的跨平台移至标准
  • 不依赖平台的目录处理工具
    • os.path

• 包含在C程序、shell脚本中经常用到的所有操作系统调用，涉及 目录、进程、shell变量

• 实践中，os基本可以作为计算机系统调用的可移植接口 使用

  • 只要技术上可行，os模块都能跨平台
  • 但在某些平台，os提供专属该平台的工具

Shell变量

1
2
3
4
5

os.environ
	# 获取、设置shell环境变量，类似字典
os.putenv()
	# 修改进程对应shell环境变量
os.getenv()

os.environ

os.environ可以向普通字典一样键索引、赋值

• 默认继承系统所有环境变量、命令行临时环境变量

• 在最新的python中，对os.environ的键值修改将自动导出 到应用的其他部分

  • os.environ对象
  • 进程对应shell环境变量：通过后台调用os.putenv生效， 反之不会更新os.environ

• python进程、链入C模块、该进程派生子进程都可以获取新的 赋值

  • 子进程一般会继承父进程的环境变量设定
  • 可以作为传递信息的方式

os.putenv

• os.putenv同时会调用C库中的putenv（若在系统中可用） 导出设置到python链接的C库

  • 底层C库没有putenv则可将os.environ作为参数传递

管理工具

1
2
3
4
5
6

os.getpid()
	# 调用函数的进程id
os.getcwd()
	# 当前工作目录CWD
os.chdir(r"C:\Users")
	# 更改当前工作目录CWD

移植工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

os.sep
	# python底层运行平台采用的**目录组**分隔符号
	# linux: `/`、win：`\`、某些mac：`:`
os.pathsep
	# 目录列表（字符串形式）中分隔目录的字符
	# posix机：`:`、win：`;`
os.curdir
	# 当前目录代表
	# linux：`.`
os.pardir
	# 父目录代表
	# linux：`..`
os.linesep
	# 换行符
	# linux：`\n`

||Linux|Win|Unix| |———|——————|———|———| |sep|/|\|/（某些MAC:）| |pathsep|:|;|| |curdir|.||| |pardir|..||| |linesep|\n|\r\n||

• 借助这些变量可以系统相关字符串操作的跨平台

• win下目录组分隔符是\，大部分情况下看到\\是作为\ 转义字符，防止\和之后字符转义

  • 确认不会转义时，直接使用\也是可以的
  • 使用r''表示不转义也可以直接使用\

路径名工具

判断存在

1
2
3
4
5

os.path.isdir(r"C:\Users")
os.path.isfile(r"C:\Users")
	# 判断路径名是简单文件、目录
os.path.exists(r"C:\Users")
	# 判断路径名是否存在

• os.stat配合stat模块有更丰富的功能

路径操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

pfile = os.path.join(r"C:\temp", "output.txt")
	# 连接文件名、目录

os.path.split(pfile)
	# 分离文件名、目录

os.path.dirname(pfile)
	# 返回路径中目录
os.path.basename(pfile)
	# 返回路径中
os.path.splitext(pfile)
	# 返回文件扩展名

os.path.normpath(r"C:\temp/index.html")
	# 调整路径为当前平台标准，尤其是分隔符混用时
os.path.abspath("index.html")
	# 返回文件的**完整绝对路径名**
	# 扩展`.`、`..`等语法

• os.sep配合字符串.join、.split方法可以实现基本相同 效果

目录、文件操作

1
2
3
4
5
6
7
8
9
10
11
12

os.mkdir(dirname)
os.rename(ori_name, dest_name)
os.remove(filename)
os.unlink(filename)
	# unix下文件删除，同`os.remove`
os.chmod(filename, previlideges)
info = os.stat(filename)
	# 命名元组表示的文件底层信息
	# 可使用`stat`模块处理、解释信息
os.listdir(dirpath)
os.walk(rootdir, topdown=True/False)
	# 遍历根目录下的整个目录树

os.listdir

• 返回值：包含目录中所有条目名称的列表

  • 名称不带目录路径前缀

• 需要注意的是：文件名同样有编码

  • 若参数为字节串，返回文件名列表也是字节串
  • 参数为字符串，返回文件名列表也是字符串

  • open函数也可以类似使用字节串确定需要打开的文件
  • glob.glob，os.walk内部都是通过调用os.listdir 实现，行为相同

• glob模块也有遍历目录的能力

os.walk

• 返回值：返回迭代器

  • 每个元素为(dirname, subdirs, subfile)

• 参数

  • topdown：默认True，自顶向下返回

文件描述符、文件锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

descriptor = os.open(path, flags, mode)
	# 打开文件并返回底层描述符
os.read(descriptor, N)
	# 最多读取N个字节，返回一个字节串
os.write(descriptor, string)
	# 将字节串写入文件
os.lseek(descriptor, position, how)
	# 移动文件游标位置
descriptor.flush()
	# 强制刷出缓冲

new_fd = os.dup(fd)
	# 创建文件描述符副本
os.dup2(fd_src, fd_dest)
	# 将文件描述符`fd_src`复制至`fd_dest`

• os通过调用文件的描述符来处理文件

• 基于文件描述符的文件以字节流形式处理

  • 没有字符解码、编码、换行符转换
  • 除了缓冲等额外性能，基于描述符的文件和二进制文件模式 对象类似

• 文件流对象、工具仅仅是在基于描述符的文件的封装

  • 可以通过.fileno()获得文件流对象对应文件描述符， sys.stdin、sys.stdout、sys.stderr对应文件 描述符是：0、1、2

    1 2	os.write(1, b"hello world\n") sys.stdout.write("hello world\n")

  • 可以通过os.fdopen把文件描述符封装进文件流对象

    1 2 3

    fdfile = os.open("filename", (os.O_RDWR|os.O_BINARY)) filstream = os.fdopen(fdfile, "r", encoding="utf-8", closefd=False)

os.open

1
2
3
4
5

def os.open(path,
	flags,
	mode=511, *,
	dir_fd=None
)

• 参数

  • mode：需要模式标识符进行二进制操作以得到需要的模式

    • os.O_RDWR
    • os.O_RDONLY
    • os.O_WRONLY
    • os.O_BINARY
    • os.O_EXCL：唯一访问权，是python在并发、进程 同步情况下锁定文件最便捷的方法
    • os.O_NONBLOCK：非阻塞访问

    • 其他模式选项参见os模块

• 返回值：文件描述符

  • 整数代码、句柄，代表操作系统的中文件

退出进程

1
2

os._exit(0)
	# 调用进程立即退出，不输出流缓冲、不运行清理处理器

异常信息

trackback模块

1
2
3
4
5
6
7
8

import traceback, sys

try:
	...
except:
	exc_info = sys.exec_info()
	print(exec_info[0], exec_info[1])
	traceback.print_tb(exec_info[2])

参数处理

getopt模块

optparse模块

文件、目录

stat模块

• 包含os.stat信息相关常量、函数以便跨平台使用

1
2
3
4
5
6
7
8

import stat

info = os.stat(filename)
info[stat.ST_MODE]
	# `stat.ST_MODE`就是字符串
	# 只是这样封装易于跨平台
stat.S_ISDIR(info.st_mode)
	# 通过整数`info.st_mode`判断是否是目录

• os.path中包含常用部分相同功能函数

glob模块

glob.glob

1
2
3

import glob

def glob.glob(pathname,*,recursive=False)

• 参数

  • pathname：文件名模式
    • 接受shell常用文件名模式语法
      • ?：单个字符
      • *：任意字符
      • []：字符选集
    • .开头路径不被以上?、*匹配
  • recursive
    • False：默认
    • True：**将递归匹配所有子目录、文件

• 返回值：匹配文件名列表

  • 目录前缀层次同参数

• glob.glob是利用glob.fnmatch模块匹配名称模式

struct模块

struct模块：用于打包、解压二进制数据的调用

• 类似于C语言中struct声明，需要指定二进制中数据类型
• 可以使用任何一种字节序（大、小端）进行组合、分解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import struct
data = struct.pack(">i4shf", 2, "spam", 3, 1.234)
	# `>`：高位字节优先，大端
	# `i`：整形数据
	# `4s`：4字符字符串
	# `h`：半整数
	# `f`：浮点数
file = open("data.bin", "wb")
file.write(data)
	# 二进制写入字节串
file.close()

file = open("data.bin", "rb")
bytes = file.read()
values = struct.unpack(">i4shf", data)
	# 需要给出字节串存储格式

shutil模块

shutil模块：包含文件操作相关

todo

系统、信息

locale模块

1
2
3
4

import locale

locale.getpreferredencoding()
	# 获取平台默认编码方案

dis模块

1
2

def dis.dis(func)
	# 打印可拆解函数语句对应机器指令

atexit模块

atexit：主要用于在程序结束前执行代码

• 类似于析构，主要做资源清理工作

atexit.register

1
2
3
4
5

def register(
	func,
	*arg,
	**kwargs
)

• 用途：注册回调函数
  • 在程序退出之前，按照注册顺序反向调用已注册回调函数
  • 如果程序非正常crash、通过os._exit()退出，注册回调 函数不会被调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import atexit

df func1():
	print("atexit func 1, last out")

def func2(name, age):
	print("atexit func 2")

atexit.register(func1)
atexit.register(func2, "john", 20)

@atexit.register
def func3():
	print("atexit func 3, first out")

实现

atexit内部是通过sys.exitfunc实现的

• 将注册函数放到列表中，当程序退出时按照先进后出方式 调用注册的回调函数，

• 若回调函数执行过程中抛出异常，atexit捕获异常然后继续 执行之后回调函数，知道所有回调函数执行完毕再抛出异常

• 二者同时使用，通过atexit.register注册回调函数可能不会 被正常调用

signal模块

信号模块