开了一个新坑 Ready ~~~ Go! ( ^ @ ^ )

认识Go

一般Go文件都是由以下三部分组成

1. package子句
2. import语句
3. 代码片段

1
2
3
4
5
6
7

package main //表示文件所有的代码都属于main包

import "fmt" //包含了fmt包

func main() { //首先运行main函数
	fmt.Println("Hello, Go")
}

代码测试网站

调用函数

包名.函数名(参数)

字符串

和C区别不大诶

符文(rune)

就是单个字符，Go中用Unicode存储符文

布尔

true false

数字

字面意思

数学运算比较

和C差不多，比较结果返回bool

类型

Go也是静态类型，在运行之前类型就要确定,如果使用了错误类型Go会编译失败

reflect包中的TypeOf可以输出类型

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

package main

import (
	"fmt"
	"reflect"
)

func main() {
	fmt.Println(reflect.TypeOf(123))
	fmt.Println(reflect.TypeOf(123.456))
	fmt.Println(reflect.TypeOf("zeyu"))
	fmt.Println(reflect.TypeOf('z'))
	fmt.Println(reflect.TypeOf(false))

}

声明变量

var 变量名称 类型

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

package main

import (
	"fmt"
)

func main() {
	var test int //单个变量声明
	test = 4     //单个变量赋值

	var testa, testb string     //多个变量声明
	testa, testb = "hhh", "xxx" //多个变量赋值

	var testc, testd float64 = 1.1, 1.2 //声明同时赋值
	var teste, testf = 5, "www"         //声明同时赋值 省略类型

	fmt.Println(test)
	fmt.Println(testa)
	fmt.Println(testb)
	fmt.Println(testc)
	fmt.Println(testd)
	fmt.Println(teste)
	fmt.Println(testf)
}

零值

对于没有赋值的变量默认是零值
字符串变量的零值是空字符串，bool变量的零值是false,int,float64的零值是0

短变量声明

如果声明的时候就知道变量的初值，可以使用短变量声明，省略val和类型 赋值符号变为:=

1
2
3
4
5
6
7
8
9
10

package main

import (
	"fmt"
)

func main() {
	test := 5 //短变量声明
	fmt.Println(test)
}

变量声明规范

1. 一个变量只能声明一次
2. 不能给未声明的变量赋值
3. 只能给变量赋相同类型的值
4. 声明同时赋值要求变量数量和值一一对应
5. 所有声明的变量都必须在程序中使用,否则因该删除声明

命名规则

名称必须以字母开头，可以有任意数量的额外字母和数字
变量、函数、类型的名称如果以大写字母开头，则认为它是导出的,可以通过其他包访问，否则认为是未导出的，只能在当前包使用
名称一般用驼峰式

转换

使用不同类型的值直接比较会报错
赋值的类型和变量类型不匹配也会报错

解决办法是使用转换 类型(变量)

运行Go

1
2
3

go fmt hello.go //重新格式化 
go build hello.go //编译为二进制
./hello

go run hello.go //编译并运行，不保存可执行文件

描述

用户命名空间隔离了安全相关的标识和属性,尤其是uid和gid(credentials)、根目录、密钥(keyrings)、能力(capabilities)。一个进程的uid,gid在不同的用户命名空间可能是不同的。一个进程在在一个用户命名空间外可能是一个普通的非特权用户,同时在另一个用户命名空间内可能是uid = 0的root。换句话说,这个进程对一个用户命名空间内的操作具有完全的权限,但是对用户命名空间外的操作没有权限

嵌套用户命名空间

用户名称空间可以嵌套,也就是说除了初始根用户命名空间之外,每个用户命名空间都有一个父用户命名空间,并且可以具有零个或多个子用户命名空间,父用户命名空间通过unshare、clone,配合使用CLONE_NEWUSER标志创建子用户命名空间。内核（>3.11)限制用户命名空间最多嵌套32层,超出限制会报EUSERS

每一个进程都是一个用户命名空间的成员,一个进程通过fork或者clone但是不使用CLONE_NEWUSER就会和父进程一样作为同一个用户命名空间的成员。一个进程可以通过setns加入另一个用户命名空间,前提是这个进程在这个用户命名空间有CAP_SYS_ADMIN能力,切换后这个进程将在这个用户命名空间有全部能力

ioctl中的NS_GET_PARENT用于获取用户命名空间的父子关系(ioctl_ns)

用户命名空间能力

通过clone或者unshare创建一个新的用户命名空间,或者通过setns加入一个已经存在的用户命名空间都会使这个进程获得这个用户命名空间的全部能力集,并且这个进程在父用户命名空间或切换之前的用户命名空间没有任何能力,即使新的用户命名空间是由root创建或切换的

在用户命名空间中调用execve通常将以正常的方式重新计算新进程的能力,因此除非uid=0或者文件的inheritable capabilities mask不为空,能力都将被丢掉

clone,unshare,setns创建/切换用户命名空间都将导致securebits标志位变成默认值(全关),因为切换到新的用户命名空间的进程在原用户命名空间将失去所有能力,所以即使将securebits标志位恢复,也没有办法通过两次setns在两个用户命名空间中切换。

判断进程在用户命名空间能力规则如下

1. 如果进程是该用户命名空间的成员,并且effective set有能力,那么该进程在这个用户命名空间就有能力。通过执行set-user-ID或者有文件能力的可执行文件都可以让新进程获得能力,或者clone,unshare,setns创建新的用户命名空间
2. 如果进程在一个用户命名空间中有能力,那么它在所有子用户命名空间都有对应能力
3. 当进程创建用户命名空间时,内核将记录进程的euid作为该用户命名空间的拥有者,处于父用户命名空间并且euid与用户命名空间拥有者相匹配的进程将获得该用户命名空间以及将来子用户命名空间的全部能力,ioctl中NS_GET_OWNER_UID用于获取用户命名空间的拥有者的uid

用户命名空间内能力的影响

在一个用户命名空间拥有能力意味着该进程可以对该用户命名空间所持有的其他命名空间的资源执行特权操作

还有一些特权操作影响的资源不属于任何命名空间,例如：修改系统时间(CAP_SYS_TIME), 加载内核模块(CAP_SYS_MODULE),创建一个设备(CAP_MKNOD),只有初始用户命名空间的特权进程有能力执行上述操作

在拥有mount namespace的用户命名空间内拥有CAP_SYS_ADMIN的进程允许在创建绑定挂载或者挂载以下文件系统

• /proc (since Linux 3.8)
• /sys (since Linux 3.8)
• devpts (since Linux 3.9)
• tmpfs(5) (since Linux 3.9)
• ramfs (since Linux 3.9)
• mqueue (since Linux 3.9)
• bpf (since Linux 4.4)

在拥有cgroup namespace的用户命名空间内拥有CAP_SYS_ADMIN的进程允许挂载cgroup version 2 文件系统和cgroup version 1 named hierarchies (cgroup filesystems mounted with the “none,name=” option)

在拥有pid namespace的用户命名空间内拥有CAP_SYS_ADMIN的进程允许挂载/proc

但是要挂载基于块的文件系统只能是在初始用户命名空间拥有CAP_SYS_ADMIN的进程

用户命名空间和其他命名空间交互

从Linux3.8开始,非特权进程可以创建用户命名空间,其他类型的名称空间只需基于调用的用户命名空间中有CAP_SYS_ADMIN能力就可以创建

创建其他命名空间时,它由创建进程所对应的用户命名空间所有。对于其他命名空间的特权操作要求进程具有必要的用户命名空间中的能力

调用clone,unshare,如果CLONE_NEWUSER和其他CLONE_*一起声明,那么会保证首先创建用户命名空间,给其他命名空间的创建提供权限。这种参数的组合方式可以被非特权进程调用

当一个新的命名空间创建(用户命名空间除外),内核都会记录这个进程的用户命名空间作为新创建的命名空间的拥有者(这种关联不能被改变),当一个进程要特权操作一个命名空间隔离的资源时,内核就会检查这个进程在要操作的那个命名空间对应用户命名空间有没有相关能力。例如,一个进程想要修改主机名(sethostname),该资源由uts namespace管理,这是内核就会检查哪一个用户命名空间拥有当前要操作的uts namespace,并检查该进程在那个用户命名空间是否有对应的能力CAP_SYS_ADMIN

NS_GET_USERNS ioctl(2) 用于获取用户命名空间拥有哪些其他命名空间(ioctl_ns)

uid_map gid_map

当一个用户命名空间被创建时,一开始并没有将uid, gid映射到父命名空间,/proc/[pid]/uid_map,/proc/[pid]/gid_map用于将命名空间内的uid,gid映射。这些文件只能被写入一次

映射文件映射了pid的进程和打开map文件的进程的uid/gid,不同用户命名空间下的进程打开同一个map文件可能看到不同的结果

这个文件在用户命名空间创建之初是空的,映射文件中的每一行指定两个用户名称空间之间一系列连续用户ID的1:1映射,每行中的规范采用由空格分隔的三个数字的形式。前两个数字分别指定两个用户命名空间中的起始用户ID,第三个数字指定映射的长度

第一个字段描述了pid所在用户命名空间id映射的开始位置,如果这两个进程(pid和打开map的进程)位于不同的用户命名空间中,字段2是打开map进程对应的用户命名空间对应id范围的开始位置,如果这两个进程位于同一个用户命名空间,字段2是该用户命名空间的父命名空间对应id范围的开始位置,一般打开/proc/self/uid_map就是查看当前进程的用户命名空间和父用户命名空间的id映射关系

getuid,getgid,stat等用于身份认证的系统调用都将返回映射到调用用户命名空间的id

当进程访问文件时,其用户和组ID映射到初始用户命名空间中,以进行权限检查和在创建文件时分配ID,当进程调用stat获取文件的uid,gid时,这些ID又会以相反的方向映射回对应的命名空间

初始用户名称空间没有父名称空间,但为了一致性,内核为以下对象提供了虚拟用户和组ID映射文件：
cat /proc/$$/uid_map
0 0 4294967295
(2^32 - 1)为未映射,类似(uid_t) -1没有这个用户

定义uid_map gid_map

在创建用户命名空间后,可以将这个用户命名空间中的某个进程的map文件写入一次,去定义id的映射,尝试多次写入会导致EPERM

写入规则

• 三个字段必须都是有效值,而且最后一个字短必须大于0
• 每一行都以换行符终止
• 4.14内核限制写入5行,4.15之后限制写入340行,写入的字节数必须小于系统页面,写入必须在开头,不能用leesk,pwrite偏移写文件
• 3.8之前的内核要求映射的范围不能有重叠,连续行的字段1和字段2必须以升序数字顺序排列,3.9取消了这个限制
• 最少一行要被写入文件

违反上述规则的写入失败,错误为EINVAL

针对进程的写入条件

1. 写入的进行必须要有对应pid进程所在用户命名空间的CAP_SETUID,CAP_SETGID
2. 写入进程必须位于进程pid的用户命名空间中,或位于进程pid的父用户命名空间中
3. 映射的ID必须在父命名空间也有映射关系
4. 以下两条满足其一:
   1. 写入进程在父用户命名空间中都具有CAP_SETUID,CAP_SETGID功能, 没有其他限制:该进程可以映射到父用户命名空间中的任意uid(gid)
   2. 否则,以下所有限制均适用:
      • 写入的数据必须由单行组成,映射写入进程在父用户命名空间的euid和要映射的命名空间的uid
      • 写入进程必须与创建用户命名空间的进程有相同的euid
      • 在gid映射的情况下,必须首先通过向/proc/[pid]/setgroups写入deny来拒绝使用setgroups系统调用

违反上述规则的写入将失败,并返回错误EPERM

对修改uid gid系统调用的影响

如果map文件没有,那么修改uid,gid会失败,否则,只有映射的id可以被修改

user IDs 系统调用: setuid, setfsuid,setreuid,setresuid. group IDs 系统调用:setgid,setfsgid,setregid, setresgid,setgroups

在写/proc/[pid]/uid_map之前在/proc/[pid]/setgroups写入deny将永久禁用用户命名空间的setgroups,并且允许在父用户命名空间没有CAP_SETGID能力的进程写/proc/[pid]/gid_map

/proc/[pid]/setgroups

如果这个文件的值是allow,那么pid对应用户命名空间的进程有能力执行setgroups,如果文件的值是deny则相反。注意,如果没有写/proc/[pid]/gid_map那么无论/proc/[pid]/setgroups值是多少,进程有没有能力都无法执行setgroups

在写入/proc/[pid]/gid_map之前,pid对应用户命名空间的特权进程(CAP_SYS_ADMIN)有权限在这个文件写入allow或者deny

这个文件的默认值是allow

一旦/proc/[pid]/gid_map被写入,同时,setgroups的值是allow,那么就无法通过写入deny去关闭setgroups(EPERM)

一旦setgroups的值是deny,那么就无法通过写入allow去开启setgroups(EPERM)

限制的本质是/proc/[pid]/gid_map是否设置了(没设置就是deny),也就是说进程的setgroups权限不能从allow -> deny,只能从deny -> allow

子用户命名空间从其父命名空间继承/proc/[pid]/setgroups设置

/proc/[pid]/setgroups是3.19引入的内核,但是已经被移植到很多早期的版本中。因为它解决了涉及具有rwx---rwx等权限文件的访问权限问题,这些文件给所属组的权限比其他人要少,着就意味着一旦通过setgroups将进程的组都丢掉就可以让进程访问到它本来无法访问的文件。对于早期的用户命名空间来说这不是个问题,因为只有特权进程CAP_SETGID有能力调用setgroups,但是引入非特权用户创建用户命名空间后,就会导致本来没有特权的用户通过子命名空间获取到了能力,然后通过setgroups让进程访问到了本来没有权限访问的文件,/proc/[pid]/setgroups很好的通过拒绝任何非特权用户(CAP_SETGID)的路径使用setgroup

未映射的uid gid

在用户命名空间中有可以遇到未映射的id,比如在还没有写入uid_map之前调用getuid,这时会返回overflow user ID,默认值是65534(/proc/sys/kernel/overflowuid)

未映射的uid gid未转换为相应的溢出ID值。查看时uid/gid map,其中第二个字段没有映射,该字段显示为4294967295

影响的系统调用
The cases where unmapped IDs are mapped in this fashion include system calls that return user IDs (getuid(2), getgid(2), and similar), cre‐ dentials passed over a UNIX domain socket, credentials returned by stat(2), waitid(2), and the System V IPC "ctl" IPC_STAT operations, cre‐ dentials exposed by /proc/[pid]/status and the files in /proc/sysvipc/*, credentials returned via the si_uid field in the siginfo_t re‐ ceived with a signal (see sigaction(2)), credentials written to the process accounting file (see acct(5)), and credentials returned with POSIX message queue notifications (see mq_notify(3)).

文件访问

为了在非特权进程访问文件时确定权限,进程凭UID、GID和文件的mode属性都映射回根用户命名空间中,然后进行比较以确定进程对文件的权限,其他类似身份认证+权限掩码的权限判断方式也是如此,比如System V IPC

文件相关操作的能力

有些能力允许进程在对不属于自己的文件操作时通过内核的限制: CAP_CHOWN,CAP_DAC_OVERRIDE,CAP_DAC_READ_SEARCH,CAP_FOWNER,CAP_FSETID

在一个用户命名空间中要生效需要满足

• 进程的Effective set在用户命名空间中有上述对应能力
• 文件的uid,gid都在用户命名空间中被映射(CAP_FOWNER只需要映射uid)

Set-user-ID set-group-ID 程序

当在用户命名空间执行了一个set-user-id或者set-group-id的程序时,如果这个id在用户命名空间中没有被映射,那么新的程序被执行时就会忽略set-user-ID set-group-ID标志位,而使用原来的euid egid

其他

在用户命名空间中,不可能获得比的根用户更多的能力
内核选项:CONFIG_USER_NS

描述

为了执行权限检查，传统的UNIX实现区分了两类进程：特权进程(euid=0，称为超级用户或root)和非特权进程(euid!=0),特权进程绕过所有内核权限检查，而非特权进程则根据进程身份认证进行权限检查(通常为:euid,egid,group list)。从内核2.2开始，Linux将传统上与超级用户相关的权限划分为不同的单元——称为能力。能力可以单独启用和禁用,是每个线程的属性

能力的要求

1. 对于所有特权操作，内核必须检查对应线程effective set是否有该能力
2. 内核必须提供允许更改和检索线程能力集的系统调用
3. 文件系统必须支持将能力附加到可执行文件,以便进程在文件被执行时获得这些能力

针对内核开发者

当为内核开发新功能时，这个功能需要被能力管控

1. 能力目标是将超级用户的能力分成几部分，这样，如果一个程序具有一个或多个能力,它对系统造成破坏的能力将小于使用root权限运行的同一程序
2. 您可以选择为新功能创建新能力，或将该功能与现有能力关联,为了将能力集保持在一个可管理的规模，除非有令人信服的选择前者的原因。(还有一个技术限制：能力集的大小目前限制为64位)
3. 要确定哪个现有功能最适合与您的新功能相关联，请查看上面的功能列表，以便找到最适合您的新功能的能力。一种方法是确定是否有其他功能需要能力并且将始终与新功能一起使用的可能性。
4. 尽可能不要为新功能使用CAP_SYS_ADMIN能力,这个能力权限太高(被称为 the new root)
5. 如果您确定确实有必要为您的功能创建新能力，请不要将其命名为“一次性使用”,要让这个能力的名称可以适用于更多其他的功能

线程能力

每个线程都有以下能力集，其中包含零个或多个上述能力

• Permitted
  用于限制Effective set的超集,同时也可以限制想添加能力到Inheritable set但是 Effective set没有CAP_SETPCAP能力的情况
  如果一个线程从Permitted set丢掉一个能力，那么它就无法再获取这个能力(除非它execve一个suid=0程序或者一个程序的相关可执行文件有对应的能力)

• Inheritable
  这个集合声明execve继承的能力,当程序运行时，要执行的文件的file inheritable set和当前程序 Inheritable set相符合时，就会被添加到新的程序Permitted set

• Effective
  这是内核用来对线程执行权限检查的一组能力

• Bounding (2.6.25后变成线程级)
  可用于限制在执行execve时新进程获得的能力

• Ambient (4.3后内核)
  该能力主要针对非特权用户(prctl可直接修改能力),非特权程序A调用execv系列函数执行新的程序B时，程序A的ambient权限集就会被进程B所继承

  1. 如果Permitted或者Inheritable中的某个能力P被清空，在Ambient中该能力P也自动被清空
  2. 当程序调用setuid改变UID或者setgid改变GID时，Ambient中的所有能力会被清空
  3. 调用execve函数执行一个程序时，如果该文件曾经被设置了任何的文件capabilities，Ambient中的所有能力会被清空；
  4. 当调用execve函数执行一个程序时，如果该文件没有设置过任何的文件capabilities，Ambient中的所有能力就会被赋予给新程序的Permited和Effective能力集。

文件能力

可执行文件的能力会被存储在文件扩展属性中(security.capability),可以通过setcap, cap_set_file,cap_set_fd,设置文件的能力。对文件写入扩展属性这一过程需要CAP_SETFCAP能力。文件的能力将与线程的能力一起决定execve后新进程的能力

• Permitted
  无论线程的Inheritable能力集如何，文件Permitted的能力都会与线程的Bounding集合与运算，添加到新线程的Permitted

• Inheritable
  文件的Inheritable会和线程的Inheritable做与运算,添加到execv后新进程的Permitted

• Effective
  这不是一个集合，仅仅是一个标志位。如果设置开启，那么在执行完execve后，线程Permitted集合中的capabilities会自动添加到它的Effective集合中。对于一些旧的可执行文件，由于其不会调用 capabilities相关函数设置自身的Effective集合，所以可以将可执行文件的Effective bit开启，从而可以将Permitted集合中的 capabilities自动添加到Effective集合中

文件扩展属性

VFS_CAP_REVISION_3和命名空间有关，当线程处于一个子命名空间中，并且这个线程在该命名空间有CAP_SETFCAP能力，那么这个线程为文件添加能力时文件security.capability就是VFS_CAP_REVISION_3版本，与VFS_CAP_REVISION_2的区别体现在扩展属性会将当前命名空间的root user id一起编码加到扩展属性中

能力继承

fork

通过fork创建的子进程继承其父进程的全部能力集

execve

P’ : 新进程
P : 旧进程
F : 文件

• P’(ambient) = (file is privileged) ? 0 : P(ambient)
• P’(permitted) = (P(inheritable) & F(inheritable)) | (F(permitted) & P(bounding)) | P’(ambient)
• P’(effective) = F(effective) ? P’(permitted) : P’(ambient)
• P’(inheritable) = P(inheritable)
• P’(bounding) = P(bounding)

普通用户执行execve时permitted和effective都会被清空
root用户执行execve时ambient会被清空

old bin

对于老的二进制文件，没有使用libcap的api去获得能力，而是使用文件的能力，这就需要将文件的effective set开启，这样执行时会自动将文件的permitted添加到对应进程的effective

root

1. 如果进程的real uid或euid = 0,那么execve文件的inheritalbe和permitted就会被忽略(通常意味着新进程所有权限都有,有一种特殊情况：一个普通进程execve一个setuid root的可执行文件,并且这个文件添加了额外的能力,这时新进程只会获得旧进程的能力，不会获取来自文件的能力,通过这种方式我们可以实现让一个进程切换到euid=0但是却没能力的状态)
2. 如果进程euid=0,那么execve文件的effective bit就会默认为开启状态

所以当一个普通程序execve一个setuid root的可执行文件（这个文件没添加额外的能力），或者一个real uid | euid = root程序执行execve时：

• P’(permitted) = P(inheritable) | P(bounding)
• P’(effective) = P’(permitted)

bounding set

bounding set用于限制execve时新进程能力的一组能力集

• bounding set会和文件的permitted set做与运算后添加到新进程的permitted set
• 如果一个能力不在bounding set，那么也无法将这个能力添加到inheritable set,即使这个能力在permitted set

在计算execve新进程的permitted set时，bounding set只会和文件的permitted set与运算，不会与inheritalbe set与运算,如果一个能力在进程的inheritable set而不在bounding set时，只要文件的inheritable set有该能力，还是可以将这个能力添加到新进程permitted set；当一个进程在bounding set去除了一个能力，但是进程要exec的文件在ep有对应能力时,exec将无权限执行,除非将当前进程的inheritable set和文件inheritable set都设置上对应能力

2.6.25后的内核

bounding set不再是系统范围的能力集，而是作用到每个线程

bounding set本身在fork和execve都是直接继承的

线程可以通过使用prctl的PR_CAPBSET_DROP去除一个bounding set能力，能力一旦被去除就不能恢复,可以使用prctl的PR_CAPBSET_READ去读取能力是否在bounding set

从bounding set中删除一个能力不会让inheritable set对应的能力删除，但是却能阻止向inheritable set添加对应能力

EUID 改变时的能力

1. 如果real,effective或者saved set user IDs原先是0，通过setuid导致这些值变为非0，那么permitted,effective,和ambient集中所有能力都会被清除
2. 如果euid从0变为非0，那么effective set中所有能力都会清除
3. 如果euid从非0变为0，那么permitted set中所有能力都将拷贝到effective set
4. 如果fsuid从0变为非0，那么effective set中的CAP_CHOWN, CAP_DAC_OVERRIDE, CAP_DAC_READ_SEARCH, CAP_FOWNER, CAP_FSETID, CAP_LINUX_IMMUTABLE (since Linux 2.6.30), CAP_MAC_OVERRIDE, and CAP_MKNOD(since Linux 2.6.30)会被清除,相反如果fsuid从非0变为0，那么任何一个上述能力只要在permitted set中都会被添加到effective set

如果一个uid=0 euid=0的线程在setuid到普通用户时想要保存之前的能力，可以使用SECBIT_KEEP_CAPS标志位

以编程的方式调整能力集

一个线程可以使用capget,capset系统调用去改变permitted, effective,和inheritable能力集

但是更推荐使用cap_get_proc,cap_set_proc去完成上述功能

1. 如果一个线程没有CAP_SETPCAP能力,那么新的inheritable set一定是现有inheritable set ＋ permitted set的子集
2. 新的inheritable set一定是现有inheritable set + bounding set的子集
3. 新的permitted set一定是现有permitted set的子集
4. 新的effective set一定是新的permitted set的子集

安全参数

自2.6.26，内核启用文件能力,linux声明了一系列线程级的安全位参数去禁用一些uid=0的线程对应的能力

• SECBIT_KEEP_CAPS

  1. 设置了这个标志位可以在线程从UIDs=0 切换到非0时保存permitted set的能力，否则permitted set的能力都将清空
  2. 这个标志位本身在execve时会被清空
  3. 请注意，即使设置了SECBIT_KEEP_CAPS,effective set在从euid=0切换到非0时也会被清空,但是如果线程设置了这个标志位但是它的euid不等于0，那么他再切换到其他UIDs不等于0的线程就不会清空effective set
  4. 如果设置了SECBIT_NO_SETUID_FIXUP,那么SECBIT_KEEP_CAPS就会被屏蔽
  5. 这个标志位和旧版的prctlPR_SET_KEEPCAPS功能相同

• SECBIT_NO_SETUID_FIXUP
  这个设置将在线程的euid fsuid从0和非0切换时阻止内核调整线程的permitted,effective,ambient集

• SECBIT_NOROOT
  如果设置了这个标志位，那么suid的可执行文件被执行或者euid ruid = 0执行一个程序时新程序不会获得root对应的能力

• SECBIT_NO_CAP_AMBIENT_RAISE
  设置这个标志位将不允许提升ambient set的能力通过prctl PR_CAP_AMBIENT_RAISE 选项

每一个标志都有一个lock标志,任何lock标志都是不可逆的，一旦设置锁定标志位，原来的基础标志位就不可更改,锁定标志位包含：SECBIT_KEEP_CAPS_LOCKED, SECBIT_NO_SETUID_FIXUP_LOCKED,
SECBIT_NOROOT_LOCKED,SECBIT_NO_CAP_AMBIENT_RAISE_LOCKED.

安全参数可以通过prctl的PR_SET_SECUREBITS 和 PR_GET_SECUREBITS去获取和更改, CAP_SETPCAP能力具有修改安全参数的功能,注意：只有包含<linux/securebits.h>才可以使用SECBIT*相关内容

安全标志位除了SECBIT_KEEP_CAPS始终会被清除,其余都会被子进程继承

使用以下标志位可以锁定自身以及子进程的能力，除非对应执行的文件有能力

1
2
3
4
5
6
7
8
9
10

prctl(PR_SET_SECUREBITS,
            /* SECBIT_KEEP_CAPS off */
            SECBIT_KEEP_CAPS_LOCKED |
            SECBIT_NO_SETUID_FIXUP |
            SECBIT_NO_SETUID_FIXUP_LOCKED |
            SECBIT_NOROOT |
            SECBIT_NOROOT_LOCKED);
            /* Setting/locking SECBIT_NO_CAP_AMBIENT_RAISE
               is not required */

namespace

suid root

当一个suid程序的uid匹配上了一个创建新namespace的uid时，当这个程序在命名空间内被任意程序执行时,就会被授予进程的permitted和effective集的能力,这里执行suid程序新进程获得的能力与上文执行suid程序获取能力的策略一致，只不过这里root程序是创建namespace对应的那个uid

file cap

传统的文件能力只是与二进制文件的一系列能力集有关，并不关心namespace,后来引入VFS_CAP_REVISION_3,在传统文件能力后又添加了namespace的root uid,在命名空间执行一个程序时，只有当文件setuid的 uid与扩展属性的uid匹配上时才会授予相关权限

其他

内核选项CONFIG_SECURITY_CAPABILITIES去开启,关闭能力

/proc/[pid]/task/TID/status 去看线程的能力

/proc/[pid]/status 去看进程的能力

送给自己的小TIPS:

博客最重要的是什么？

是文章

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment

让自己习惯C++Accustoming Yourself to C++

条款01 视C++为一个语言联邦 (View C++as a federation of languages)

• 面向过程形式（procedural）
• 面向对象形式（object-oriented）
• 函数形式（functional）
• 泛型形式（generic）
• 元编程形式（metaprogramming)

条款02：尽量以const，enum，inline替换＃define (Prefer consts，enums，and inlines to＃defines)

• 对于单纯常量，最好以const对象或enums替换＃defines
• 对于形似函数的宏（macros），最好改用inline函数替换＃defines

条款03：尽可能使用const (Use const whenever possible)

• 将某些东西声明为const可帮助编译器侦测出错误用法。const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体
• 编译器强制实施bitwise constness，但你编写程序时应该使用“概念上的常量性”（conceptual constness）,意味着你不应该将一个返回数据成员非常量引用的成员函数声明为const。虽然这个函数本身没有修改对象（即符合 bitwise constness），但调用者可以拿到这个非常量引用来修改对象内部的数据
• 当const和non-const成员函数有着实质等价的实现时，令non-const版本调用const版本可避免代码重复

条款04: 确定对象被使用前已先被初始化 (Make sure that objects are initialized before they’re used)

• 为内置型对象进行手工初始化，因为C++不保证初始化它们
• 构造函数最好使用成员初值列（member initialization list），而不要在构造函数本体内使用赋值操作（assignment）。初值列列出的成员变量，其排列次序应该和它们在class中的声明次序相同
• 为免除“跨编译单元之初始化次序”问题，请以local static对象替换non-local static对象

构造/析构/赋值运算 Constructors，Destructors，and Assignment Operators

条款05：了解C++默默编写并调用哪些函数 (Know what functions C++silently writes and calls)

• 编译器可以暗自为class创建default构造函数、copy构造函数、copy assignment操作符，以及析构函数

条款06: 若不想使用编译器自动生成的函数，就该明确拒绝 (Explicitly disallow the use of compiler-generated functions you do not want)

• 为驳回编译器自动（暗自）提供的机能，可将相应的成员函数声明为private并且不予实现。使用像Uncopyable这样的base class也是一种做法

条款07: 为多态基类声明virtual析构函数 (Declare destructors virtual in polymorphic base classes)

• polymorphic（带多态性质的）base classes应该声明一个virtual析构函数。如果class带有任何virtual函数，它就应该拥有一个virtual析构函数
• Classes的设计目的如果不是作为base classes使用，或不是为了具备多态性（polymorphically），就不该声明virtual析构函数

条款08：别让异常逃离析构函数 (Prevent exceptions from leaving destructors)

• 析构函数绝对不要吐出异常。如果一个被析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们（不传播）或结束程序
• 如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数（而非在析构函数中）执行该操作

条款09：绝不在构造和析构过程中调用virtual函数 (Never call virtual functions during construction or destruction)

• 在base构造和析构期间不要调用virtual函数，因为这类调用从不下降至derived class（比起当前执行构造函数和析构函数的那层）

条款10：令operator=返回一个 reference tothis (Have assignment operators return a reference tothis)

• 令赋值（assignment）操作符返回一个reference to*this

条款11：在operator=中处理“自我赋值” (Handle assignment to self in operator=)

• 确保当对象自我赋值时operator=有良好行为。其中技术包括比较“来源对象”和“目标对象”的地址、精心周到的语句顺序、以及copy-and-swap
• 确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确

条款12：复制对象时勿忘其每一个成分 (Copy all parts of an object)

• Copying函数应该确保复制对象内的所有成员变量及所有base class成分
• 不要尝试以某个copying函数实现另一个copying函数。应该将共同机能放进第三个函数中，并由两个coping函数共同调用

资源管理 Resource Management

条款13：以对象管理资源 (Use objects to manage resources)

• 为防止资源泄漏，请使用RAII(Resource Acquisition Is Initialization)对象，它们在构造函数中获得资源并在析构函数中释放资源
• 两个常被使用的RAII classes分别是tr1：：shared_ptr和auto_ptr。前者通常是较佳选择，因为其copy行为比较直观。若选择auto_ptr，复制动作会使它（被复制物）指向null

条款14：在资源管理类中小心copying行为 (Think carefully about copying behavior in resource-managing classes)

• 复制RAII对象必须一并复制它所管理的资源，所以资源的copying行为决定RAII对象的copying行为
• 普遍而常见的RAII class copying行为是：抑制copying、施行引用计数法（reference counting）。不过其他行为也都可能被实现

条款15:资源管理类中提供对原始资源的访问 (Provide access to raw resources in resource-managing classes)

• APIs往往要求访问原始资源（raw resources），所以每一个RAII class应该提供一个“取得其所管理之资源”的办法
• 对原始资源的访问可能经由显式转换或隐式转换。一般而言显式转换比较安全，但隐式转换对客户比较方便

条款16：成对使用new和delete时要采取相同形式 (Use the same form in corresponding uses of new and delete)

• 如果你在new表达式中使用[]，必须在相应的delete表达式中也使用[]。如果你在new表达式中不使用[]，一定不要在相应的delete表达式中使用[]

条款17：以独立语句将newed对象置入智能指针 (Store newed objects in smart pointers in standalone statements)

• 以独立语句将newed对象存储于（置入）智能指针内。如果不这样做，一旦异常被抛出，有可能导致难以察觉的资源泄漏

设计与声明 Designs and Declarations

条款18：让接口容易被正确使用，不易被误用 (Make interfaces easy to use correctly and hard to use incorrectly)

• 好的接口很容易被正确使用，不容易被误用。你应该在你的所有接口中努力达成这些性质
• “促进正确使用”的办法包括接口的一致性，以及与内置类型的行为兼容
• “阻止误用”的办法包括建立新类型、限制类型上的操作，束缚对象值，以及消除客户的资源管理责任
• tr1::shared_ptr支持定制型删除器（custom deleter）。这可防范DLL问题，可被用来自动解除互斥锁（mutexes；见条款14）等等

条款19：设计class犹如设计type (Treat class design as type design)

• Class的设计就是type的设计。在定义一个新type之前，请确定你已经考虑过本条款覆盖的所有讨论主题

条款20：宁以pass-by-reference-to-const替换pass-by-value (Prefer pass-by-reference-to-const to pass-by-value)

• 尽量以pass-by-reference-to-const替换pass-by-value。前者通常比较高效，并可避免切割问题（slicing problem）
• 以上规则并不适用于内置类型，以及STL的迭代器和函数对象。对它们而言，pass-by-value往往比较适当

条款21：必须返回对象时，别妄想返回其reference (Don’t try to return a reference when you must return an object)

• 绝不要返回pointer或reference指向一个local stack对象，或返回reference指向一个heap-allocated对象，或返回pointer或reference指向一个local static对象而有可能同时需要多个这样的对象。条款4已经为“在单线程环境中合理返回reference指向一个local static对象”提供了一份设计实例(单例)

条款22：将成员变量声明为private (Declare data members private)

• 切记将成员变量声明为private。这可赋予客户访问数据的一致性、可细微划分访问控制、允诺约束条件获得保证，并提供class作者以充分的实现弹性
• protected并不比public更具封装性

条款23：宁以non-member、non-friend替换member函数 (Prefer non-member non-friend functions to member functions)

• 宁可拿non-member non-friend函数替换member函数。这样做可以增加封装性、包裹弹性（packaging flexibility）和机能扩充性

条款24：若所有参数皆需类型转换，请为此采用non-member函数 (Declare non-member functions when type conversions should apply to all parameters)

• 如果你需要为某个函数的所有参数（包括被 this指针所指的那个隐喻参数）进行类型转换，那么这个函数必须是个non-member

条款25：考虑写出一个不抛异常的swap函数 (Consider support for a non-throwing swap)

• 当std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常
• 如果你提供一个member swap，也该提供一个non-member swap用来调用前者。对于classes（而非templates），也请特化std::swap
• 调用swap时应针对std::swap使用using声明式，然后调用swap并且不带任何“命名空间资格修饰”
• 为“用户定义类型”进行std templates全特化是好的，但千万不要尝试在std内加入某些对std而言全新的东西

实现 Implementations

条款26：尽可能延后变量定义式的出现时间 (Postpone variable definitions as long as possible)

• 尽可能延后变量定义式的出现。这样做可增加程序的清晰度并改善程序效率

条款27：尽量少做转型动作 (Minimize casting)

• 如果可以，尽量避免转型，特别是在注重效率的代码中避免dynamic_casts如果有个设计需要转型动作，试着发展无需转型的替代设计
• 如果转型是必要的，试着将它隐藏于某个函数背后。客户随后可以调用该函数，而不需将转型放进他们自己的代码内
• 宁可使用C++-style（新式）转型，不要使用旧式转型。前者很容易辨识出来，而且也比较有着分门别类的职掌

条款28：避免返回handles指向对象内部成分 (Avoid returning”handles”to object internals)

• 避免返回handles（包括references、指针、迭代器）指向对象内部。遵守这个条款可增加封装性，帮助const成员函数的行为像个const，并将发生“虚吊号码牌”（dangling handles）的可能性降至最低(声明了cosnt成员函数返回一个成员变量的引用)

条款29：为“异常安全”而努力是值得的 (Strive for exception-safe code)

• 异常安全函数（Exception-safe functions）即使发生异常也不会泄漏资源或允许任何数据结构败坏。这样的函数区分为三种可能的保证：基本型、强烈型、不抛异常型
• “强烈保证”往往能够以copy-and-swap实现出来，但“强烈保证”并非对所有函数都可实现或具备现实意义
• 函数提供的“异常安全保证”通常最高只等于其所调用之各个函数的“异常安全保证”中的最弱者

条款30：透彻了解inlining的里里外外 (Understand the ins and outs of inlining)

• 将大多数inlining限制在小型、被频繁调用的函数身上。这可使日后的调试过程和二进制升级（binary upgradability）更容易，也可使潜在的代码膨胀问题最小化，使程序的速度提升机会最大化
• 不要只因为function templates出现在头文件，就将它们声明为inline

条款31：将文件间的编译依存关系降至最低 (Minimize compilation dependencies between files)

• 支持“编译依存性最小化”的一般构想是：相依于声明式，不要相依于定义式。基于此构想的两个手段是Handle classes和Interface classes
• 程序库头文件应该以“完全且仅有声明式”（full and declaration-only forms）的形式存在。这种做法不论是否涉及templates都适用

继承与面向对象设计 Inheritance and Object-Oriented Design

条款32：确定你的public继承塑模出is-a关系 (Make sure public inheritance models”is-a.”)

• public继承”意味is-a。适用于base classes身上的每一件事情一定也适用于derived classes身上，因为每一个derived class对象也都是一个base class对象

条款33：避免遮掩继承而来的名称 (Avoid hiding inherited names)

• derived classes内的名称会遮掩base classes内的名称。在public继承下从来没有人希望如此
• 为了让被遮掩的名称再见天日，可使用using声明式或转交函数（forwarding functions）

条款34：区分接口继承和实现继承 (Differentiate between inheritance of interface and inheritance of implementation)

• 接口继承和实现继承不同。在public继承之下，derived classes总是继承base class的接口
• pure virtual函数只具体指定接口继承
• 简朴的（非纯）impure virtual函数具体指定接口继承及缺省实现继承
• non-virtual函数具体指定接口继承以及强制性实现继承

条款35：考虑virtual函数以外的其他选择 (Consider alternatives to virtual functions)

• virtual函数的替代方案包括NVI(non-virtual interface)手法及Strategy设计模式的多种形式。NVI手法自身是一个特殊形式的Template Method设计模式
• 将机能从成员函数移到class外部函数，带来的一个缺点是，非成员函数无法访问class的non-public成员
• tr1：：function对象的行为就像一般函数指针。这样的对象可接纳与给定之目标签名式（target signature）兼容的所有可调用物（callable entities）

条款36：绝不重新定义继承而来的non-virtual函数 Never redefine an inherited non-virtual function

• 绝对不要重新定义继承而来的non-virtual函数

条款37：绝不重新定义继承而来的缺省参数值 (Never redefine a function’s inherited default parameter value)

• 绝对不要重新定义一个继承而来的缺省参数值，因为缺省参数值都是静态绑定，而virtual函数——你唯一应该覆写的东西——却是动态绑定

条款38：通过复合塑模出has-a或“根据某物实现出” (Model”has-a”or”is-implemented-in-terms-of”through composition)

• 复合（composition）的意义和public继承完全不同。
• 在应用域（application domain），复合意味has-a（有一个）。在实现域（implementation domain），复合意味is-implemented-in-terms-of（根据某物实现出)

条款39：明智而审慎地使用private继承 (Use private inheritance judiciously)

• Private继承意味is-implemented-in-terms of（根据某物实现出）。它通常比复合（composition）的级别低。但是当derived class需要访问protected base class的成员，或需要重新定义继承而来的virtual函数时，这么设计是合理的
• 和复合（composition）不同，private继承可以造成empty base最优化。这对致力于“对象尺寸最小化”的程序库开发者而言，可能很重要

条款40：明智而审慎地使用多重继承 (Use multiple inheritance judiciously)

• 多重继承比单一继承复杂。它可能导致新的歧义性，以及对virtual继承的需要
• virtual继承会增加大小、速度、初始化（及赋值）复杂度等等成本。如果virtual base classes不带任何数据，将是最具实用价值的情况
• 多重继承的确有正当用途。其中一个情节涉及public继承某个Interface class和private继承某个协助实现的class的两相组合

模板与泛型编程 Templates and Generic Programming

条款41：了解隐式接口和编译期多态 (Understand implicit interfaces and compile-time polymorphism)

• classes和templates都支持接口（interfaces）和多态（polymorphism）
• 对classes而言接口是显式的（explicit），以函数签名为中心。多态则是通过virtual函数发生于运行期
• 对template参数而言，接口是隐式的（implicit），奠基于有效表达式。多态则是通过template具现化和函数重载解析（function overloading resolution）发生于编译期

条款42：了解typename的双重意义 (Understand the two meanings of typename)

• 声明template参数时，前缀关键字class和typename可互换
• 请使用关键字typename标识嵌套从属类型名称；但不得在base class lists（基类列）或member initialization list（成员初值列）内以它作为base class修饰符

条款43：学习处理模板化基类内的名称 (Know how to access names in templatized base classes)

• 可在derived class templates内通过 “this->gt；” 指涉base class templates内的成员名称，或藉由一个明白写出的“base class资格修饰符”完成

条款44: 将与参数无关的代码抽离templates (Factor parameter-independent code out of templates)

• Templates生成多个classes和多个函数，所以任何template代码都不该与某个造成膨胀的template参数产生相依关系
• 因非类型模板参数（non-type template parameters）而造成的代码膨胀，往往可消除，做法是以函数参数或class成员变量替换template参数
• 因类型参数（type parameters）而造成的代码膨胀，往往可降低，做法是让带有完全相同二进制表述（binary representations）的具现类型（instantiation types）共享实现码

条款45: 运用成员函数模板接受所有兼容类型 (Use member function templates to accept”all compatible types.”)

• 请使用member function templates（成员函数模板）生成“可接受所有兼容类型”的函数
• 如果你声明member templates用于“泛化copy构造”或“泛化assignment操作”，你还是需要声明正常的copy构造函数和copy assignment操作符

条款46：需要类型转换时请为模板定义非成员函数 (Define non-member functions inside templates when type conversions are desired)

• 当我们编写一个class template，而它所提供之与此template相关的函数支持所有参数之隐式类型转换时，请将那些函数定义为class template 内部的friend函数

条款47：请使用traits classes表现类型信息 (Use traits classes for information about types)

• Traits classes使得“类型相关信息”在编译期可用。它们以templates和templates特化完成实现
• 整合重载技术（overloading）后,traits classes有可能在编译期对类型执行if...else测试

条款48：认识template元编程 (Be aware of template metaprogramming.)

• Template metaprogramming（TMP，模板元编程）可将工作由运行期移往编译期，因而得以实现早期错误侦测和更高的执行效率
• TMP可被用来生成基于政策选择组合(based on combinations of policy choices）的客户定制代码，也可用来避免生成对某些特殊类型并不适合的代码

定制new和delete Customizing new and delete

条款49：了解new-handler的行为 (Understand the behavior of the new-handler)

• set_new_handler允许客户指定一个函数，在内存分配无法获得满足时被调用
• Nothrow new是一个颇为局限的工具，因为它只适用于内存分配；后继的构造函数调用还是可能抛出异常

条款50：了解new和delete的合理替换时机 (Understand when it makes sense to replace new and delete)

• 有许多理由需要写个自定的new和delete，包括改善效能、对heap运用错误进行调试、收集heap使用信息

条款51：编写new和delete时需固守常规 (Adhere to convention when writing new and delete)

• operator new应该内含一个无穷循环，并在其中尝试分配内存，如果它无法满足内存需求，就该调用new-handler。它也应该有能力处理0 bytes申请。Class专属版本则还应该处理“比正确大小更大的（错误）申请”。
• operator delete应该在收到null指针时不做任何事。Class专属版本则还应该处理“比正确大小更大的（错误）申请”

条款52：写了placement new也要写placement delete (Write placement delete if you write placement new)

• 当你写一个placement operator new，请确定也写出了对应的placementoperator delete。如果没有这样做，你的程序可能会发生隐微而时断时续的内存泄漏
• 当你声明placement new和placement delete，请确定不要无意识（非故意）地遮掩了它们的正常版本

杂项讨论 Miscellany

条款53：不要轻忽编译器的警告 (Pay attention to compiler warnings)

• 严肃对待编译器发出的警告信息。努力在你的编译器的最高（最严苛）警告级别下争取“无任何警告”的荣誉
• 不要过度倚赖编译器的报警能力，因为不同的编译器对待事情的态度并不相同。一旦移植到另一个编译器上，你原本倚赖的警告信息有可能消失

条款54：让自己熟悉包括TR1在内的标准程序库 (Familiarize yourself with the standard library，including TR1)

条款55：让自己熟悉Boost (Familiarize yourself with Boost)

控制内存分配

重载new和delete

• new表达式的工作机理

1
2

string *sp = new string("a value"); //分配并初始化一个string对象
string *arr = new string[10];   // 分配10个默认初始化的string对象

• 上述代码实际执行了三步操作

  • new表达式调用一个名为operator new(或operator new [])的标准库函数，它分配一块足够大的、原始的、未命名的内存空间以便存储特定类型的对象(或对象的数组)
  • 编译器运行相应的构造函数以构造这些对象，并为其传入初始值
  • 对象被分配了空间并构造完成，返回一个指向该对象的指针

• delete表达式的工作机理

1
2

delete sp;  // 销毁*sp，然后释放sp指向的内存空间
delete [] arr;  // 销毁数组中的元素，然后释放对应的内存空间

• 上述代码实际执行了两步操作
  • 对sp所指向的对象或者arr所指的数组中的元素执行对应的析构函数
  • 编译器调用名为operator delete(或operator delete[])的标准库函数释放内存空间
• 当自定义了全局的operator new函数和operator delete函数后，我们就担负起了控制动态内存分配的职责。这两个函数必须是正确的。因为它们是程序整个处理过程中至关重要的一部分
• 标准库定义了operator new函数和operator delete函数的8个重载版本

1
2
3
4
5
6
7
8
9
10
11

// 这些版本可能抛出异常
void *operator new(size_t); // 分配一个对象
void *operator new[](size_t);   // 分配一个数组
void *operator delete(void*) noexcept;  // 释放一个对象
void *operator delete[](void*) noexcept;    // 释放一个数组

// 这些版本承诺不会抛出异常
void *operator new(size_t, nothrow_t&) noexcept;
void *operator new[](size_t, nothrow_t&) noexcept;
void *operator delete(void*, nothrow_t&) noexcept;
void *operator delete[](void*, nothrow_t&) noexcept;

• 应用程序可以自定义上面函数版本中的任意一个，前提是自定义的版本必须位于全局作用域或者类作用域中
• 注意： 提供新的operator new函数和operator delete函数的目的在于改变内存分配的方式，但是不管怎样，都不能改变new运算符和delete运算符的基本含义
• 使用从C语言继承的函数malloc和free函数能实现以某种方式执行分配内存和释放内存的操作

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

#include <cstdlib>

void *operator new(size_t size) {
    if(void *mem = malloc(size))
        return mme;
    else
        throw bad_alloc();
}

void operator delete(void *mem) noexcept {
    free(mem);
}

定位new表达式

• 使用new运算符后返回的是已知的用户指定的地址
• 应该使用new的定位new(placement new)形式传递一个地址，定位new的形式如下：

1
2
3
4
5

new (place_address) type
new (place_address) type (initializers)
new (place_address) type [size]
new (place_address) type [size] {braced initializer list}
// place_address必须是一个指针，同时在initializers中提供一个(可能为空的)以逗号分隔的初始值列表，该初始值列表将用于构造新分配的对象。

• 当只传入一个指针类型的实参时，定位new表达式构造对象但是不分配内存
• 调用析构函数会销毁对象，但是不会释放内存

1
2

string *sp = new string("a value"); // 分配并初始化一个string对象
sp->~string();

运行时类型识别

• 运行时类型识别(run-time type identification, RTTI)的功能由两个运算符实现
  • typeid运算符， 用于返回表达式的类型
  • dynamic_cast运算符，用于将基类的指针或引用安全地转换曾派生类的指针或引用
• 使用RTTI必须要加倍小心。在可能的情况下，最好定义虚函数而非直接接管类型管理的重任

dynamic_cast运算符

• dynamic_cast运算符的使用形式如下

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

dynamic_cast<type*>(e)  // e必须是一个有效的指针
dynamic_cast<type&>(e)  // e必须是一个左值
dynamic_cast<type&&>(e) // e不能是左值
// 以上，type类型必须时一个类类型，并且通常情况下该类型应该含有虚函数。
// e的类型必须符合三个条件中的任意一个，它们是：
// 1. e的类型是目标type的公有派生类；
// 2. e的类型是目标type的共有基类；
// 3. e的类型就是目标type的类型；

//失败时
//指针返回0

// 指针类型的dynamic_cast
// 假设Base类至少含有一个虚函数，Derived是Base的共有派生类。
if (Derived *dp = dynamic_cast<Derived*>(bp)) {
    // 使用dp指向的Derived对象
} else {
    // 使用bp指向的Base对象
}


//失败时
//引用抛出bad_cast异常

// 引用类型的dynamic_cast
void f(const Base &b) {
    try {
        const Derived &d = dynamic_cast<const Derived&>(b);
        // 使用b引用的Derived对象
    } catch (bad_cast) {
        // 处理类型转换失败的情况
    }
}

• 可以对一个空指针执行dynamic_cast，结果是所需类型的空指针

typeid运算符

• typeid运算符(typeid operator)，它允许程序向表达式提问：你的对象是什么类型？
• typeid表达式的形式是typeid(e)，其中e可以是任意表达式或类型的名字，它操作的结果是一个常量对象的引用(type_info)。它可以作用于任意类型的表达式
• 通常情况下，使用typeid比较两条表达式的类型是否相同，或者比较一条表达式的类型是否与指定类型相同

1
2
3
4
5
6
7
8
9
10

Derived *dp = new Derived;
Base *bp = dp;

if (typeid(*bp) == typeid(*dp)) {
    // bp和dp指向同一类型的对象
}

if (typeid(*bp) == typeid(Derived)) {
    // bp实际指向Derived对象
}

• 当typeid作用于指针时(而非指针所指向的对象)，返回的结果是该指针的静态编译时类型

1
2
3
4

// 下面的检查永远是失败的：bp的类型是指向Base的指针
if (typeid(bp) == typeid(Derived)) {
    // 永远不会执行
}

使用RTTI

• 用途：为具有继承关系的类实现相等运算符时。对于两个对象来说，如果它们的类型相同并且对应的数据成员取值相同，则说这两个对象是相等的

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

// 类的层次关系
class Base {
    friend bool operator==(const Base&, const Base&);
public:
    // Base的接口成员
protected:
    virtual bool equal(const Base&) const;
    // Base的数据成员和其他用于实现的成员
};

class Derived: public Base {
public:
    // Derived的其他接口成员
protected:
    bool equal(const Base&) const;
    // Derived的数据成员和其他用于实现的成员
};

// 类型敏感的相等运算符
bool operator==(const Base &lhs, const Base &rhs) {
    // 如果typeid不相同，返回false；否则虚调用equal
    return typeid(lhs) == typeid(rhs) && lhs.equal(rhs);
}

// 虚equal函数
bool Derived::equal(const Base &rhs) const {
    auto r = dynamic_cast<const Derived&>(rhs);
    // 执行比较两个Derived对象的操作并返回结果
}

// 基类equal函数
bool Base::equal(const Base &rhs) const {
    // 执行比较Base对象的操作
}

type_info类

枚举类型

• 枚举类型(enumeration)使我们可以将一组整型常量组织在一起。枚举属于字面值常量类型
• **限定作用域的枚举类型(scoped enumeration)**：首先是关键字enum class(或enum struct)，随后是枚举类型名字以及用花括号括起来的以逗号分隔的枚举成员列表，最后是一个分号

1

enum class open_modes {input, output, append};

• 不限定作用域的枚举类型(unscoped enumeration)：省略关键字class(或struct)，枚举类型的名字是可选的

1
2
3
4

enum color {red, yellow, green};

enum {floatPrec = 6, doublePrec = 10, double_doublePrec = 10};

类成员指针

成员指针：指可以指向类的非静态成员的指针

数据成员指针

• 和其他指针一样，在声明成员指针时也使用*来表示当前声明的名字是一个指针。与普通指针不同的时，成员指针还必须包含成员所属的类

1
2
3
4
5

// pdata可以指向一个常量(非常量)Screen对象的string成员
const string Screen::*pdata;

// C++11
auto pdata = &Screen::contents;

• 当我们初始化一个成员指针或为成员指针赋值时，该指针没有指向任何数据。成员指针指定了成员而非该成员所属的对象，只有当解引用成员指针时才提供对象的信息

1
2
3
4
5

Screen myScreen, *pScreen = &myScreen;

auto s = myScreen.*pdata;

s = pScreen->*pdata;

成员函数指针

• 因为函数调用运算符的优先级较高，所以在声明指向成员函数的指针并使用这些的指针进行函数调用时，括号必不可少：(C::*p)(parms)和(obj.*p)(args)

将成员函数用作可调用对象

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <iostream>
#include <string>
#include <functional>

class CDemo
{
public:
    CDemo() = default;
    void test(int i) {
        std::cout << "test" << i << std::endl;
    }     
    std::string value = "hhh";
    static void staticTest(int i) {
        std::cout << "static test" << i << std::endl;
    }
};

typedef void (CDemo::*PTest)(int);
typedef std::string CDemo::*PVal;

using UsingPTest = void (CDemo::*)(int); 
using UsingPVal = std::string CDemo::*;

using DecPTest = decltype(&CDemo::test);
using DecPVal = decltype(&CDemo::value);

using FuncTest = std::function<void(int)>;

typedef decltype(CDemo::staticTest) *StaticPTest; //decltype 不会保存将函数转换成函数指针

int main(int argc, char const *argv[])
{
    CDemo d;
 
    //方法1 typedef定义成员指针
    PTest pTest = &CDemo::test;  //成员指针必须绑定到对象上才能使用
    PVal pVal = &CDemo::value;

    (d.*pTest)(5); //前面必须加() 调用运算符的优先级要高于指针指向成员运算符的优先级,否则等价于 d.*(pTest())
    std::cout << d.*pVal << std::endl;


    //方法2 auto返回成员指针
    auto autoPTest = &CDemo::test;
    auto autoPVal = &CDemo::value;

    (d.*autoPTest)(5);
    std::cout << d.*autoPVal << std::endl;

    //方法3 using定义成员指针
    UsingPTest usingPtest = &CDemo::test;
    UsingPVal usingPVal = &CDemo::value;

    (d.*usingPtest)(5);
    std::cout << d.*usingPVal << std::endl;

    //方法4 通过decltype推导类型
    DecPTest decPTest = &CDemo::test;
    DecPVal decPVal = &CDemo::value;
    (d.*decPTest)(5);
    std::cout << d.*decPVal << std::endl;

    //方法5 将成员函数转换成function对象
    FuncTest fTest = std::bind(&CDemo::test, &d, std::placeholders::_1);
    fTest(15);

    //静态成员和普通函数一样
    StaticPTest staticPTest = CDemo::staticTest;
    staticPTest(20);
}

嵌套类

• 一个类可以定义在另一个类的内部，前者称为嵌套类(nested class)或嵌套类型(nested type)。嵌套类常用于定义作为实现部分的类
• 嵌套类是一个独立的类，与外层类基本没有什么关系。特别是，外层类的对象和嵌套类的对象是相互独立的
• 嵌套类的名字在外层类作用域中是可见的，在外层类作用域之外不可见

union：一种节省空间的类

• 联合(union)是一种特殊的类。一个union可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。它不能含有引用类型的成员和虚函数

1
2
3
4
5
6
7
8

// Token类型的对象只有一个成员，该成员的类型可能是下列类型中的任意一种
union Token {
    // 默认情况下成员是共有的
    char cval;
    int ival;
    double dval;
}；

• 匿名union(anonymous union)是一个未命名的union，并且在右花括号和分号之间没有任何声明

1
2
3
4
5
6
7
8
9

union {
    char cval;
    int ival;
    double dval;
};

// 可以直接访问它的成员
cal = 'c';
ival = 42;

• 注意： 匿名union不能包含受保护的成员或私有成员，也不能定义成员函数

局部类

• 局部类(local class)：可以定义在某个函数的内部的类。它的类型只在定义它的作用域内可见。和嵌套类不同，局部类的成员受到严格限制
• 局部类的所有成员(包括函数在内)都必须完整定义在类的内部。因此，局部类的作用与嵌套类相比相差很远
• 局部类不能使用函数作用域中的变量

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

int a, val;
void foo(int val) {
    static int si;
    enum Loc { a = 1024, b};

    // Bar是foo的局部类
    struct Bar {
        Loc locVal; // 正确：使用一个局部类型名
        int barVal;

        void fooBar(Loc l = a) {    // 正确：默认实参是Loc::a
            barVal = val;   // 错误：val是foo的局部变量
            barVal == ::val;    // 正确：使用一个全局对象
            barVal = si;    // 正确：使用一个静态局部对象
            locVal = b; // 正确：使用一个枚举成员
        }
    }；
}

固有的不可移植的特性

所谓不可移植的特性是指因机器而异的特性，当将含有不可移植特性的程序从一台机器转移到另一台机器上时，通常需要重新编写该程序

位域

• 类可以将其(非静态)数据成员定义成**位域(bit-field)**，在一个位域中含有一定数量的二进制位。当一个程序需要向其他程序或硬件设备传递二进制数据时，通常会用到位域
• 位域在内存中的布局是与机器相关的
• 位域的类型必须是整型或枚举类型。因为带符号位域的行为是由具体实现确定的，通常情况下我们使用无符号类型保存一个位域

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

typedef unsigned int Bit;
class File {
    Bit mode: 2;
    Bit modified: 1;
    Bit prot_owner: 3;
    Bit prot_group: 3;
    Bit prot_world: 3;
public:
    enum modes {READ = 01, WRITE = 02, EXECUTE = 03};
    File &open(modes);
    void close();
    void write();
    bool isRead() const;
    void setWrite();
}

// 使用位域
void File::write() {
    modified = 1;
    // ...
}

void File::close() {
    if( modified)
        // ...保存内容
}

File &File::open(File::modes m) {
    mode |= READ;   // 按默认方式设置READ
    // 其他处理
    if(m & WRITE)   // 如果打开了READ和WRITE
        // 按照读/写方式打开文件
    return *this;
}

volatile限定符

• 当对象的值可能在程序的控制或检测之外被改变时，应该将该对象声明为volatile。关键字volatile告诉编译器不应对这样的对象进行优化
• const和volatile的一个重要区别是不能使用合成的拷贝/移动构造函数及赋值运算符初始化volatile对象或者从volatile对象赋值

链接指示：extern “C”

• C++使用链接指示(linkage directive)指出任意非C++函数所用的语言
• 要想把C++代码和其他语言(包括C语言)编写的代码放在一起使用，要求我们必须有权访问该语言的编译器，并且这个编译器与当前的C++编译器是兼容的
• C++从C语言继承的标准库函数可以定义为C函数，但并非必须：决定使用C还是C++实现的C标准库，是每个C++实现的事情
• 有时需要在C和C++中编译同一个源文件，为了实现这一目的，在编译C++版本的程序时预处理器定义__cplusplus

1
2
3
4

#ifdef __cplusplus
extern "C"
#endif
int strcmp(const char*, const char*);

大规模应用程序的特殊要求包括

• 在独立开发的子系统之间协同处理错误的能力
• 使用各种库进行协同开发的能力
• 对比较复杂的应用概念建模的能力

异常处理

异常处理（exception handling）机制允许程序中独立开发的部分能够在运行时就出现的问题进行通信并作出相应的处理。

抛出异常

• 在C++语言中，我们通过抛出（throwing）一条表达式来引发（raised）一个异常。异常类型和当前的调用链决定了哪段处理代码（handler）将用来处理该异常
• 程序的控制权从throw转移到catch模块
• 栈展开：当throw出现在一个try语句块时，检查该try语句块相关的catch字句，若有匹配则处理；若无匹配，则继续检查外层的try匹配的catch
• 若一个异常没有被捕获，则它将终止当前的程序

对象销毁

• 块退出后，它的局部对象将被销毁
• 若异常发生在构造函数中，即使某个对象只构造了一部分，也要确保已构造的成员正确地被销毁
• 将资源释放放在类的析构函数中，以保证资源能被正确释放。析构函数本身不会引发异常

捕获异常

• 若无需访问抛出的异常对象，则可以忽略捕获形参的名字
• 通常，若catch接受的异常与某个继承体系有关，则最好将该catch的参数定义成引用类型
• 搜索catch未必是最佳匹配，而是第一个匹配，因此，越细化的catch越应该放在catch列表前段
• 重新抛出：catch代码执行一条throw;将异常传递给另一个catch语句
• 捕获所有异常：catch(...)

构造函数

处理构造函数初始值异常的唯一方法是将构造函数协程函数try语句块。

示例：

1
2
3
4
5

template <typename T>
Blob<T>::Blob(std::initializer_list<T> il) try: 
    data(std::make_shared<std::vector<T> >(il){
        /*函数体*/
    } catch(const std::bad_alloc &e){ handle_out_of_memory(e); }

noexcept异常说明

使用noexcept说明指定某个函数不会抛出异常

示例：

1
2

void recoup(int) noexcept; //C++11
coid recoup(int) throw(); //老版本

异常类层次

标准exception层次：

• exception
  • bad_cast
  • bad_alloc
  • runtime_error
    • overflow_error
    • underflow_error
    • range_error
  • logic_error
    • domain_error
    • invalid_argument
    • out_of_range
    • length_error

自定义异常类：

示例：

1
2
3
4

class out_of_stock: public std::runtime_error {
    explicit out_of_stock(const std::string &s):
    std::runtime_error(s){ }
};

命名空间

多个库将名字放置在全局命名空间中将引发命名空间污染（namespace pollution）。命名空间（namespace）分割了全局命名空间，其中每个命名空间是一个作用域。

命名空间定义

命名空间的定义包含两部分：1.关键字namespace；2.命名空间名称。后面是一系列由花括号括起来的声明和定义。命名空间作用域后面无需分号。

示例：

1
2
3

namespace cplusplus_primer{
    
}

每个命名空间都是一个作用域。定义在某个命名空间内的名字可以被该命名空间内的其他成员直接访问，也可以被这些成员内嵌套作用域中的任何单位访问。位于该命名空间之外的代码必须明确指出所用的名字是属于哪个命名空间的。

命名空间可以是不连续的。这点不同于其他作用域，意味着同一命名空间可以在多处出现。

内联命名空间（C++11）

无需使用该命名空间的前缀，通过外层命名空间就可以直接访问。

示例：

1
2
3
4
5
6
7
8

namespace cplusplus_primer{
    inline namespace FifthEd{
        // 表示本书第5版代码
        class Query_base {};
    }
}

cplusplus_primer::Query_base qb;

未命名的命名空间

指关键字namespace后面紧跟花括号的用法。未命名的命名空间中定义的变量拥有静态的声明周期：在第一次使用前创建，直到程序结束才销毁。不能跨越多个文件。

使用命名空间成员

像namespace_name::member_name这样使用命名空间的成员非常繁琐。

命名空间的别名

1

namespace primer = cplusplus_primer;

using声明（using declaration）

一条using声明语句一次只引入命名空间的一个成员。

1
2
3

using std::string;

string s = "hello";

using指示（using directive）

使得某个特定的命名空间中所有的名字都可见。

1
2
3

using namespace std;

string s = "hello";

类、命名空间与作用域

1
2
3
4
5
6
7
8

namespace A{
    class C1{
        public:
            int f3();
    }
}

A::C1::f3

重载与命名空间

using声明语句声明的是一个名字，而非特定的函数，也就是包括该函数的所有版本，都被引入到当前作用域中。

多重继承与虚继承

多重继承

类型转换与多个基类

多重继承下的类作用域

• 当一个类拥有多个基类时，有可能出现派生类从两个或更多基类中继承了同名成员的情况。此时，不加前缀限定符直接使用该名字将引发二义性。

虚继承

• 虚继承的目的是令某个类做出声明，承诺愿意共享它的基类。其中，共享的基类子对象成为虚基类。在这种机制下，不论虚基类在继承体系中出现了多少次，在派生类中都只包含唯一一个共享的虚基类子对象。
• 虚派生只影响从指定了虚基类的派生类中进一步派生出的类，它不会影响派生类本身。

构造函数与虚继承

• 含有虚基类的对象的构造顺序与一般的顺序稍有区别：首先使用提供给最底层派生类构造函数的初始值初始化该对象的虚基类子部分，接下来按照直接基类在派生列表中出现的次序对其进行初始化。
• 虚基类总是先于非虚基类构造，与它们在继承体系中的次序和位置无关。

tuple类型

• tuple是类似pair的模板，每个成员类型都可以不同，但tuple可以有任意数量的成员
• 但每个确定的tuple类型的成员数目是固定的
• 我们可以将tuple看做一个“快速而随意”的数据结构

tuple支持的操作

定义和初始化tuple

定义和初始化示例

• tuple<size_t, size_t, size_t> threeD;
• tuple<size_t, size_t, size_t> threeD{1,2,3};
• auto item = make_tuple("0-999-78345-X", 3, 2.00);

访问tuple成员

• auto book = get<0>(item);
• get<2>(item) *= 0.8;

使用tuple返回多个值

• tuple最常见的用途是从一个函数返回多个值

bitset类型

• 处理二进制位的有序集
• bitset也是类模板，但尖括号中输入的是bitset的长度而不是元素类型，因为元素类型是固定的，都是一个二进制位

初始化bitset的方法

初始化案例

• bitset<13> bitvec1(0xbeef);
• bitset<32> bitvec4("1100");

bitset操作

正则表达式

• 正则表达式（reqular expression）是一种描述字符序列的方法，是一种很强大的工具

正则表达式库组件

regex_match和regex_search的参数

• 这些操作会返回bool值，指出是否找到匹配

使用正则表达式库

• regex使用的正则表达式语言是ECMAScript，模式[[::alpha::]]匹配任意字母
• 由于反斜线是C++中的特殊字符，在模式中每次出现\的地方，必须用一个额外的反斜线\\告知C++我们需要一个反斜线字符
• 简单案例
  • string pattern("[^c]ei"); pattern = "[[:alpha:]]*" + pattern + "[[:alpha:]]*" 查找不在字符c之后的字符串ei
  • regex r(pattern); 构造一个用于查找模式的regex
  • smatch results; 定义一个对象保存搜索结果
  • string test_str = "receipt freind theif receive";
  • if (regex_search(test_str, results, r)) cout << results.str() << endl; 如有匹配子串，打印匹配的单词

regex（和wregex）选项

定义regex时指定的标志

• 可以将正则表达式本身看做是一种简单程序语言设计的程序。在运行时，当一个regex对象被初始化或被赋予新模式时，才被“编译”
• 如果编写的正则表达式存在错误，会在运行时抛出一个regex_error的异常
• 避免创建不必要的正则表达式。构建一个regex对象可能比较耗时

匹配与regex迭代器类型

sregex_iterator操作（用来获得所有匹配）

示例：

1
2
3
4

// 将字符串file中所有匹配模式r的子串输出
for (sregex_iterator it(file.begin(), file.end(), r), end_it; it != end_it; ++it){
    cout << it ->str() << endl;
}

smatch操作：

使用子表达式

• 正则表达式语法通常用括号表示子表达式
• 子表达式的索引从1开始
• 在fmt中用$后跟子表达式的索引号来标识一个特定的子表达式

示例

1
2

if (regex_search(filename, results, r))
    cout << results.str(1) << endl;  // .str(1)获取第一个子表达式匹配结果

ssub_match子匹配操作

使用regex_replace

正则表达式替换操作

示例

1
2
3
4
5

string phone = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ]?)(\\d{4})"
string fmt = "$2.$5.$7";  // 将号码格式改为ddd.ddd.dddd
regex r(phone);  // 用来寻找模式的regex对象
string number = "(908) 555-1800";
cout << regex_replace(number, r, fmt) << endl;

匹配标志

随机数

• 新标准之前，C和C++都依赖一个简单的C库函数rand来生成随机数，且只符合均匀分布
• 新标准：随机数引擎 + 随机数分布类， 定义在 random头文件中
• C++程序应该使用default_random_engine类和恰当的分布类对象

随机数引擎和分布

随机数引擎操作

示例

1
2
3
4
5
6

// 初始化分布类型
uniform_int_distribution<unsigned> u(0, 9);
// 初始化引擎
default_random_engine e;
// 随机生成0-9的无符号整数
cout << u(e) << endl;

设置随机数发生器种子

• 种子就是一个数值，引擎可以利用它从序列中一个新位置重新开始生成随机数
• 种子可以使用系统函数time(0)

其他随机数分布

分布类型的操作

IO库再探

格式化输入与输出

• 使用操纵符改变格式状态
• 控制布尔值的格式： cout << boolalpha << true << endl;
• 指定整型的进制：cout << dec << 20 << endl;

定义在iostream中的操纵符

其中*表示默认的流状态

未格式化的输入/输出操作

单字节低层IO操作

多字节低层IO操作

• 注意：一般情况下，主张使用标准库提供的高层抽象，低层函数容易出错

流随机访问

• 只适用于fstream和sstream
• 通过将标记seek到一个给定位置来重定位它
• tell告诉我们标记的当前位置

• 面向对象编程和泛型编程都能处理在编写程序时不知道类型的情况
  • OOP能处理类型在程序运行之前都未知的情况
  • 泛型编程中，在编译时就可以获知类型

定义模板

• 模板：模板是泛型编程的基础。一个模板就是一个创建类或函数的蓝图或者说公式

函数模板

• template <typename T> int compare(const T &v1, const T &v2){}
• 模板定义以关键字 template开始，后接模板形参表，模板形参表是用尖括号<>括住的一个或多个模板形参的列表，用逗号分隔，不能为空
• 使用模板时，我们显式或隐式地指定模板实参，将其绑定到模板参数上
• 模板类型参数：类型参数前必须使用关键字class或者typename，这两个关键字含义相同，可以互换使用。旧的程序只能使用class
• 非类型模板参数：表示一个值而非一个类型。实参必须是常量表达式。template <typename T, size_t N> void array_init(T (&parm)[N]){}
  • 整型（没有浮点型）
  • 函数指针
  • 指向具有静态性的对象的指针
  • 绑定到具有静态性的对象的左值引用
• 函数模板可以声明为inline或constexpr的，如同非模板函数一样。inline或constexpr说明符放在模板参数列表之后。template <typename T> inline T min(const T&, const T&);
• 模板程序应该尽量减少对实参类型的要求
• 函数模板和类模板成员函数的定义通常放在头文件中
• 模版实例化：当我们使用（而不是定义）模板时，编译器才生成代码

类模板

• 类模板用于生成类的蓝图
• 不同于函数模板，编译器不能推断模板参数类型
• 定义类模板
  • template <typename Type> class Queue {};
• 实例化类模板：提供显式模板实参列表，来实例化出特定的类
• 一个类模板中所有的实例都形成一个独立的类
• 模板形参作用域：模板形参的名字可以在声明为模板形参之后直到模板声明或定义的末尾处使用
• 类模板的成员函数
  • template <typename T> ret-type Blob<T>::member-name(parm-list)
• 类模板的名字不是一个类型名
• 在一个类模板的作用域内，我们可以直接使用模板名而不必指定模板实参
• 默认情况下，对于一个实例化了的类模板，其成员只有在使用时才被实例化
• 新标准允许模板将自己的类型参数成为友元。template <typename T> class Bar{friend T;};
• 模板类型别名：因为模板不是一个类型，因此无法定义一个typedef引用一个模板，但是新标准允许我们为类模板定义一个类型别名：template<typename T> using twin = pair<T, T>; twin<int> test;//等价pair<int, int>
• static：模版的每一个实例都有自己的static对象

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

#include <memory>
#include <vector>

template<typename T> class Blob
{
public:
	typedef T value_type;
	typedef typename std::vector<T>::size_type size_type; //使用作用域运算符时,typename告诉编译器std::vector<T>::size_type是一个类型而不是一个成员

	// constructors
	Blob();
	Blob(std::initializer_list<T> il);

	// number of elements in the Blob
	size_type size() const { return data->size(); }
	bool      empty() const { return data->empty(); }

	void push_back(const T& t) { data->push_back(t); }
	void push_back(T&& t) { data->push_back(std::move(t)); }
	void pop_back();

	// element access
	T& back();
	T& operator[](size_type i);

	const T& back() const;
	const T& operator [](size_type i) const;
    static int ref;

private:
	std::shared_ptr<std::vector<T>> data;
	// throw msg if data[i] isn't valid
	void check(size_type i, const std::string &msg) const;
};

template<typename T> int Blob<T>::ref = 0;

// constructors
template<typename T>
Blob<T>::Blob() : data(std::make_shared<std::vector<T>>())
{}

template<typename T>
Blob<T>::Blob(std::initializer_list<T> il) :
data(std::make_shared<std::vector<T>>(il))
{}

template<typename T>
void Blob<T>::check(size_type i, const std::string &msg) const
{
	if (i >= data->size())
		throw std::out_of_range(msg);
}

template<typename T>
T& Blob<T>::back()
{
	check(0, "back on empty Blob");
	return data->back();
}

template<typename T>
const T& Blob<T>::back() const
{
	check(0, "back on empty Blob");
	return data->back();
}


template<typename T>
T& Blob<T>::operator [](size_type i)
{
	// if i is too big, check function will throw, preventing access to a nonexistent element
	check(i, "subscript out of range");
	return (*data)[i];
}


template<typename T>
const T& Blob<T>::operator [](size_type i) const
{
	// if i is too big, check function will throw, preventing access to a nonexistent element
	check(i, "subscript out of range");
	return (*data)[i];
}

template<typename T>
void Blob<T>::pop_back()
{
	check(0, "pop_back on empty Blob");
	data->pop_back();
}

模板参数

• 模板参数与作用域：一个模板参数名的可用范围是在声明之后，至模板声明或定义结束前
• 一个特定文件所需要的所有模板的声明通常一起放置在文件开始位置
• 当我们希望通知编译器一个名字表示类型时，必须使用关键字typename
• 默认模板实参

  1 2 3 4 5 6 7

  template <typename T = int> class Numbers{}; Numbers<> nm; template<typename T, typename B = std::vector<std::string>> void test(const T &a, const B &vec = {"aa", "bb"}) { std::cout << vec.size() << std::endl; }

成员模板

• 成员模板（member template）：本身是模板的函数成员
  • 普通（非模板）类的成员模板
  • 类模板的成员模板

    1 2 3 4

    //在类模板外定义一个成员模板时 template<typename T> //类模版 template<typename It> //成员函数模版 Blob<T>::Blob(It begin, It end):data(std::make_shared<std::vector<T>>(begin, end)) {} //构造函数

控制实例化

• 动机：在多个文件中实例化相同模板的额外开销可能非常严重
• 显式实例化
  • extern template declaration; // 实例化声明
  • template declaration; // 实例化定义
• 一个类模板的实例化定义会实例化该模板的所有成员，包括内联的成员函数。当编译器遇到一个实例化定义时，它不了解程序使用哪些成员函数。因此，与处理类模板的普通实例化不同,编译器会实例化该类的所有成员,即使我们不使用某个成员，它也会被实例化。

模板实参推断

• 对函数模板，编译器利用调用中的函数实参来确定其模板参数，这个过程叫模板实参推断

类型转换与模板类型参数

• 和其他函数一样，实参顶层const会被忽略
• 能够自动转换类型的只有
  • 将一个非const对象的引用（或指针）传递给一个const的引用（或指针）形参
  • 数组实参或函数实参转换为指针

函数模板显式实参

• 某些情况下，编译器无法推断出模板实参的类型
• 定义：template <typename T1, typename T2, typename T3> T1 sum(T2, T3);
• 使用函数显式实参调用：auto val3 = sum<long long>(i, lng); // T1是显式指定，T2和T3都是从函数实参类型推断而来
• 注意：正常类型转换可以应用于显式指定的实参

尾置返回类型与类型转换

• 使用场景：并不清楚返回结果的准确类型，但知道所需类型是和参数相关的
• template <typename It> auto fcn(It beg, It end) -> decltype(*beg)
• 尾置返回允许我们在参数列表之后声明返回类型

标准库的类型转换模板

• 定义在头文件type_traits中

函数指针和实参推断

• 当使用一个函数模板初始化一个函数指针或为一个函数指针赋值时，编译器使用指针的类型来推断模板实参

  1 2 3 4

  template<typename T1> void test(const T1 &t) {} void (*fp)(const int &) = test;

模板实参推断和引用

• 从左值引用函数推断类型：若形如T&，则只能传递给它一个左值。但如果是const T&，则可以接受一个右值
• 从右值引用函数推断类型：若形如T&&，则只能传递给它一个右值
• 引用折叠和右值引用参数：
  • 规则1：当我们将一个左值传递给函数的右值引用参数，且右值引用指向模板类型参数时（如T&&），编译器会推断模板类型参数为实参的左值引用类型
  • 规则2：如果我们间接创造一个引用的引用，则这些引用形成了折叠。折叠引用只能应用在间接创造的引用的引用，如类型别名或模板参数。对于一个给定类型X
    • X& &、X& &&和X&& &都折叠成类型X&
    • 类型X&& &&折叠成X&&
  • 上面两个例外规则导致两个重要结果
    • 1.如果一个函数参数是一个指向模板类型参数的右值引用（如T&&），则它可以被绑定到一个左值上
    • 2.如果实参是一个左值，则推断出的模板实参类型将是一个左值引用，且函数参数将被实例化为一个左值引用参数（T&）

理解std::move

• 标准库move函数是使用右值引用的模板的一个很好的例子
• 从一个左值static_cast到一个右值引用是允许的

1
2
3
4
5

template <typename T>
typename remove_reference<T>::type&& move(T&& t)
{
  return static_cast<typename remove_reference<T>::type&&>(t);
}

• 一个左值static_cast到一个右值引用是允许的

转发

• 使用一个名为forward的新标准库设施来传递参数，它能够保持原始实参的类型
• 定义在头文件utility中
• 必须通过显式模板实参来调用
• forward返回显式实参类型的右值引用。即，forward<T>的返回类型是T&&, 如果T是左值引用,基于引用折叠forward返回左值引用
• 与std::move相同，对std::forward不使用using声明,防止和自定义的重名函数冲突

重载与模板

• 多个可行模板：当有多个重载模板对一个调用提供同样好的匹配时，会选择最特例化的版本
• 非模板和模板重载：对于一个调用，如果一个非函数模板与一个函数模板提供同样好的匹配，则选择非模板版本
• 如果使用了一个忘记声明的函数，代码将编译失败。但对于重载函数模板的函数而言,如果编译器可以从模板实例化出与调用匹配的版本，则缺少的声明就不重要了
• 在定义任何函数之前，记得声明所有重载的函数版本

可变参数模板

可变参数模板就是一个接受可变数目参数的模板函数或模板类

• 可变数目的参数被称为参数包
  • 模板参数包：标识另个或多个模板参数
  • 函数参数包：标识另个或者多个函数参数
• 用一个省略号来指出一个模板参数或函数参数，表示一个包
• template <typename T, typename... Args>，Args是一个模板参数包
• void foo(const T &t, const Args& ... rest);，rest是一个函数参数包
• sizeof...()运算符，返回参数的数目

编写可变参数函数模板

• 可变参数函数通常是递归的：第一步调用处理包中的第一个实参，然后用剩余实参调用自身

  1 2 3 4 5 6 7 8 9 10 11

  template<typename Printable> std::ostream& print(std::ostream& os, Printable const& printable) { return os << printable; } // recursion template<typename Printable, typename... Args> std::ostream& print(std::ostream& os, Printable const& printable, Args const&... rest) { return print(os << printable << ", ", rest...); }

包扩展

• 对于一个参数包，除了获取它的大小，唯一能做的事情就是扩展（expand）
• 扩展一个包时，还要提供用于每个扩展元素的模式（pattern）
• 在模式右边放一个省略号(…)来触发扩展操作

转发参数包

• 新标准下可以组合使用可变参数模板和forward机制，实现将实参不变地传递给其他函数

  1 2 3 4

  template<typename... Args> void fun(Args&&... args) { work(std::forward<Args>(args)...); //对args所有元素完美转发 }

模板特例化（Specializations）

通用的模版没法满足某些特殊类型的需求

• 定义函数模板特例化：关键字template后面跟一个空尖括号对（<>）
• 特例化的本质是实例化一个模板，而不是重载它。特例化不影响函数匹配
• 模板及其特例化版本应该声明在同一个头文件中。所有同名模板的声明应该放在前面，然后是特例化版本
• 我们可以部分特例化类模板(只对类模板部分模板参数提供实参)，但不能部分特例化函数模板

1
2
3
4
5
6
7
8
9

template<typename T>
void test(const T& t) {
    std::cout << t << std::endl;
}

template<>
void test(const char* const &t){
    std::cout << t << "special" << std::endl;
}