团队协作时的访问权限模型

git

安装

Linux

如果你碰巧用Debian或Ubuntu Linux，通过一条sudo apt-get install git就可以直接完成Git的安装，非常简单。

如果是其他Linux版本，可以直接通过源码安装。先从Git官网下载源码，然后解压，依次输入：./config，make，sudo make install这几个命令安装就好了。

Windows

在Windows上使用Git，可以从Git官网直接下载安装程序

安装完成后，在开始菜单里找到“Git”->“Git Bash”

安装完成后，还需要最后一步设置，在命令行输入：

$ git config --global user.name "Your Name"
$ git config --global user.email "email@example.com"

使用

初始化一个Git仓库，使用git init命令。

添加文件到Git仓库，分两步：

使用命令git add <file>，注意，可反复多次使用，添加多个文件；
使用命令git commit -m <message>，完成。

要随时掌握工作区的状态，使用git status命令。

如果git status告诉你有文件被修改过，用git diff可以查看修改内容。

查看历史记录

git log
git log --pretty=oneline

在Git中，用HEAD表示当前版本，也就是最新的提交1094adb…（注意我的提交ID和你的肯定不一样），上一个版本就是HEAD^，上上一个版本就是HEAD^^，当然往上100个版本写100个^比较容易数不过来，所以写成HEAD~100。

退到某个版本
git reset –hard HEAD^
git reset –hard commit_id

Git提供了一个命令git reflog用来记录你的每一次命令

git diff HEAD -- readme.txt命令可以查看工作区和版本库里面最新版本的区别

git checkout -- file可以丢弃工作区的修改：

$ git checkout -- readme.txt

命令git checkout – readme.txt意思就是，把readme.txt文件在工作区的修改全部撤销，这里有两种情况：

一种是readme.txt自修改后还没有被放到暂存区，现在，撤销修改就回到和版本库一模一样的状态；

一种是readme.txt已经添加到暂存区后，又作了修改，现在，撤销修改就回到添加到暂存区后的状态。

总之，就是让这个文件回到最近一次git commit或git add时的状态。

git checkout – file命令中的–很重要，没有–，就变成了“切换到另一个分支”的命令

git reset HEAD <file>可以把暂存区的修改撤销掉（unstage），重新放回工作区

git reset命令既可以回退版本，也可以把暂存区的修改回退到工作区。当我们用HEAD时，表示最新的版本。

通常直接在文件管理器中把没用的文件删了，或者用rm命令删了

用命令git rm删掉，并且git commit

分支管理

查看分支：git branch

创建分支：git branch <name>

切换分支：git checkout <name>

创建+切换分支：git checkout -b <name>

合并某分支到当前分支：git merge <name>

删除分支：git branch -d <name>

用git log --graph命令可以看到分支合并图。

$ git log --graph --pretty=oneline --abbrev-commit

准备合并dev分支，请注意–no-ff参数，表示禁用Fast forward

$ git merge --no-ff -m "merge with no-ff" dev

因为本次合并要创建一个新的commit，所以加上-m参数，把commit描述写进去。

合并分支时，加上--no-ff参数就可以用普通模式合并，合并后的历史有分支，能看出来曾经做过合并，而fast forward合并就看不出来曾经做过合并。

当手头工作没有完成时，先把工作现场git stash一下，然后去修复bug，修复后，再git stash pop，回到工作现场。

用git stash list命令看看之前保存的工作现场

工作现场还在，Git把stash内容存在某个地方了，但是需要恢复一下，有两个办法：

一是用git stash apply恢复，但是恢复后，stash内容并不删除，你需要用git stash drop来删除；

另一种方式是用git stash pop，恢复的同时把stash内容也删了

开发一个新feature，最好新建一个分支；

如果要丢弃一个没有被合并过的分支，可以通过git branch -D 强行删除。

要查看远程库的信息，用git remote或者，用git remote -v显示更详细的信息

多人协作的工作模式通常是这样：

首先，可以试图用git push origin <branch-name>推送自己的修改；

如果推送失败，则因为远程分支比你的本地更新，需要先用git pull试图合并；

如果合并有冲突，则解决冲突，并在本地提交；

没有冲突或者解决掉冲突后，再用git push origin <branch-name>推送就能成功！

如果git pull提示no tracking information，则说明本地分支和远程分支的链接关系没有创建，用命令git branch --set-upstream-to <branch-name> origin/<branch-name>。

rebase操作可以把本地未push的分叉提交历史整理成直线；

rebase的目的是使得我们在查看历史提交的变化时更容易，因为分叉的提交需要三方对比。

标签管理

命令git tag <tagname>用于新建一个标签，默认为HEAD，也可以指定一个commit id；

命令git tag -a <tagname> -m "blablabla..."可以指定标签信息；

命令git tag可以查看所有标签。

命令git push origin 可以推送一个本地标签；

命令git push origin –tags可以推送全部未推送过的本地标签；

命令git tag -d 可以删除一个本地标签；

命令git push origin :refs/tags/可以删除一个远程标签。

GitHub

GitHub页面支持使用键盘快捷键，shift + / 键可打开一览表

在某仓库页面上按下键盘的t键再输入文件名，可快速查询需要的目录或文件名，不用手动找

emoji表情自动补全功能，评论中输入:后便会启动，emoji速查表在这里

Wiki也可以通过Git进行管理，Clone其URL即可

在GitHub上，可以任意Fork开源仓库；

自己拥有Fork后的仓库的读写权限；

可以推送pull request给官方仓库来贡献代码。

远程仓库

第1步：创建SSH Key。在用户主目录下，看看有没有.ssh目录，如果有，再看看这个目录下有没有id_rsa和id_rsa.pub这两个文件，如果已经有了，可直接跳到下一步。如果没有，打开Shell（Windows下打开Git Bash），创建SSH Key：

$ ssh-keygen -t rsa -C "youremail@example.com"

如果一切顺利的话，可以在用户主目录里找到.ssh目录，里面有id_rsa和id_rsa.pub两个文件，这两个就是SSH Key的秘钥对，id_rsa是私钥，不能泄露出去，id_rsa.pub是公钥，可以放心地告诉任何人。

第2步：登陆GitHub，打开“Account settings”，“SSH Keys”页面：

然后，点“Add SSH Key”，填上任意Title，在Key文本框里粘贴id_rsa.pub文件的内容

点“Add Key”，你就应该看到已经添加的Key

添加远程库

要关联一个远程库，使用命令git remote add origin git@server-name:path/repo-name.git；

关联后，使用命令git push -u origin master第一次推送master分支的所有内容；

由于远程库是空的，我们第一次推送master分支时，加上了-u参数，Git不但会把本地的master分支内容推送的远程新的master分支，还会把本地的master分支和远程的master分支关联起来，在以后的推送或者拉取时就可以简化命令.

此后，每次本地提交后，只要有必要，就可以使用命令git push origin master推送最新修改；

从远程库克隆

要克隆一个仓库，首先必须知道仓库的地址，然后使用git clone命令克隆。

Git支持多种协议，包括https，但通过ssh支持的原生git协议速度最快。

使用码云

一个本地库能不能既关联GitHub，又关联码云呢

用不同的名称来标识不同的远程库

git remote add github git@github.com:michaelliao/learngit.git
git remote add gitee git@gitee.com:liaoxuefeng/learngit.git

自定义Git

让Git显示颜色，会让命令输出看起来更醒目：

$ git config --global color.ui true

在Git工作区的根目录下创建一个特殊的.gitignore文件，然后把要忽略的文件名填进去，Git就会自动忽略这些文件。

配置Git的时候，加上–global是针对当前用户起作用的，如果不加，那只针对当前的仓库起作用。

每个仓库的Git配置文件都放在.git/config文件中

搭建Git服务器

$ sudo apt-get install git
$ sudo adduser git

创建证书登录：

收集所有需要登录的用户的公钥，就是他们自己的id_rsa.pub文件，把所有公钥导入到/home/git/.ssh/authorized_keys文件里，一行一个。

始化Git仓库
先选定一个目录作为Git仓库，假定是/srv/sample.git，在/srv目录下输入命令：

$ sudo git init --bare sample.git

Git就会创建一个裸仓库，裸仓库没有工作区，因为服务器上的Git仓库纯粹是为了共享，所以不让用户直接登录到服务器上去改工作区，并且服务器上的Git仓库通常都以.git结尾。然后，把owner改为git：

$ sudo chown -R git:git sample.git

禁用shell登录：

出于安全考虑，第二步创建的git用户不允许登录shell，这可以通过编辑/etc/passwd文件完成。找到类似下面的一行：

git:x:1001:1001:,,,:/home/git:/bin/bash

改为：

git:x:1001:1001:,,,:/home/git:/usr/bin/git-shell

这样，git用户可以正常通过ssh使用git，但无法登录shell，因为我们为git用户指定的git-shell每次一登录就自动退出。

克隆远程仓库：

现在，可以通过git clone命令克隆远程仓库了，在各自的电脑上运行：

$ git clone git@server:/srv/sample.git

可以用Gitosis来管理公钥

https://learngitbranching.js.org/?demo

Git Commit

创建一个新的提交记录

Git Branch

创建分支

git checkout

切换到某一分支上

git checkout -b

创建一个新的分支同时切换到新创建的分支

git merge

合并两个分支

git rebase

Rebase 实际上就是取出一系列的提交记录，“复制”它们，然后在另外一个地方逐个的放下去。Rebase 的优势就是可以创造更线性的提交历史，这听上去有些难以理解。如果只允许使用 Rebase 的话，代码库的提交历史将会变得异常清晰。

HEAD

在项目的提交树上前后移动。

HEAD 是一个对当前检出记录的符号引用 —— 也就是指向你正在其基础上进行工作的提交记录。

HEAD 总是指向当前分支上最近一次提交记录。大多数修改提交树的 Git 命令都是从改变 HEAD 的指向开始的。

如果想看 HEAD 指向，可以通过 cat .git/HEAD 查看， 如果 HEAD 指向的是一个引用，还可以用 git symbolic-ref HEAD 查看它的指向。

分离的 HEAD 就是让其指向了某个具体的提交记录而不是分支名。

通过哈希值指定提交记录。

相对引用非常给力，这里我介绍两个简单的用法：

使用 ^ 向上移动 1 个提交记录
使用 ~ 向上移动多个提交记录，如 ~3

git branch -f master HEAD~3

上面的命令会将 master 分支强制指向 HEAD 的第 3 级父提交。

强制修改分支位置

相对引用为我们提供了一种简洁的引用提交记录的方式， 而 -f 则容许我们将分支强制移动到那个位置。

git log

查查看提交记录的哈希值,只需要提供能够唯一标识提交记录的前几个字符即可。

git reset与 git revert

主要有两种方法用来撤销变更 —— 一是 git reset，还有就是 git revert。

git reset 通过把分支记录回退几个提交记录来实现撤销改动。你可以将这想象成“改写历史”。git reset 向上移动分支，原来指向的提交记录就跟从来没有提交过一样。

虽然在你的本地分支中使用 git reset 很方便，但是这种“改写历史”的方法对大家一起使用的远程分支是无效的哦！

为了撤销更改并分享给别人，我们需要使用 git revert。

git reset：本地分支
git revert：远程分支

git cherry-pick <提交号>…

整理提交记录

如果你想将一些提交复制到当前所在的位置（HEAD）下面的话， Cherry-pick 是最直接的方式了。

交互式的 rebase

当你你知道你所需要的提交记录（并且还知道这些提交记录的哈希值）时, 用 cherry-pick 再好不过了 —— 没有比这更简单的方式了。

但是如果你不清楚你想要的提交记录的哈希值呢? 幸好 Git 帮你想到了这一点, 我们可以利用交互式的 rebase —— 如果你想从一系列的提交记录中找到想要的记录, 这就是最好的方法了

交互式 rebase 指的是使用带参数 –interactive 的 rebase 命令, 简写为 -i

如果你在命令后增加了这个选项, Git 会打开一个 UI 界面并列出将要被复制到目标分支的备选提交记录，它还会显示每个提交记录的哈希值和提交说明，提交说明有助于你理解这个提交进行了哪些更改。

本地栈式提交

你可以选择通过 fast-forward 快速合并

实际我们只要让 Git 复制解决问题的那一个提交记录就可以了。跟之前我们在“整理提交记录”中学到的一样，我们可以使用

git rebase -i
git cherry-pick

提交的技巧

正如你在上一关所见到的，我们可以使用 rebase -i 对提交记录进行重新排序。只要把我们想要的提交记录挪到最前端，我们就可以很轻松的用 –amend 修改它，然后把它们重新排成我们想要的顺序。

Git Tags

可以（在某种程度上 —— 因为标签可以被删除后重新在另外一个位置创建同名的标签）永久地将某个特定的提交命名为里程碑，然后就可以像分支一样引用了。

更难得的是，它们并不会随着新的提交而移动。你也不能检出到某个标签上面进行修改提交，它就像是提交树上的一个锚点，标识了某个特定的位置。

Git Describe

由于标签在代码库中起着“锚点”的作用，Git 还为此专门设计了一个命令用来描述离你最近的锚点（也就是标签），它就是 git describe！

Git Describe 能帮你在提交历史中移动了多次以后找到方向；

git describe 的​​语法是：

git describe

可以是任何能被 Git 识别成提交记录的引用，如果你没有指定的话，Git 会以你目前所检出的位置（HEAD）。

它输出的结果是这样的：

__g

tag 表示的是离 ref 最近的标签， numCommits 是表示这个 ref 与 tag 相差有多少个提交记录， hash 表示的是你所给定的 ref 所表示的提交记录哈希值的前几位。

当 ref 提交记录上有某个标签时，则只输出标签名称

选择父提交记录

选择父提交记录
操作符 ^ 与 ~ 符一样，后面也可以跟一个数字。

但是该操作符后面的数字与 ~ 后面的不同，并不是用来指定向上返回几代，而是指定合并提交记录的某个父提交。还记得前面提到过的一个合并提交有两个父提交吧，所以遇到这样的节点时该选择哪条路径就不是很清晰了。

Git 默认选择合并提交的“第一个”父提交，在操作符 ^ 后跟一个数字可以改变这一默认行为。

GUI 客户端

https://git-scm.com/download/gui/windows

几款好用的Git GUI客户端工具

其他

gitignore文件

各种gitignore模板

https://github.com/github/gitignore

book

Pro Git

参考：

• http://www.ituring.com.cn/article/497347
• http://www.ituring.com.cn/article/264697
• https://git-scm.com/book/zh/
• https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000
• http://www.ituring.com.cn/article/469123
• https://learngitbranching.js.org/?demo

判断是否是2的幂

https://www.exploringbinary.com/ten-ways-to-check-if-an-integer-is-a-power-of-two-in-c/

https://blog.csdn.net/K346K346/article/details/53316953

Shift Right

int isPowerOfTwo (unsigned int x)
{
 while (((x & 1) == 0) && x > 1) /* While x is even and > 1 */
   x >>= 1;
 return (x == 1);
}

Decrement and Compare

int isPowerOfTwo (unsigned int x)
{
  return ((x != 0) && !(x & (x - 1)));
}

Complement and Compare

int isPowerOfTwo (unsigned int x)
{
  return ((x != 0) && ((x & (~x + 1)) == x));
}

常用排序算法总结

常用排序算法总结（1）

常用排序算法总结（2）

排序算法大体可分为两种：

一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。

另一种是非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。

排序算法稳定性的简单形式化定义为：如果Ai = Aj，排序前Ai在Aj之前，排序后Ai还在Aj之前，则称这种排序算法是稳定的。

算法图解

• 选择排序
• 递归
• 快速排序
• 散列表
• 广度优先搜索
• 狄克斯特拉算法
• 贪婪算法
• 动态规划
• K最近邻算法

常用算法的时间复杂度

二叉树遍历

前序遍历

利用了栈的先进后出的特性，首先遍历显示根节点，然后将右子树（注意是右子树不是左子树）压栈，最后将左子树压栈。由于最后时将左子树节点压栈，所以下一次首先出栈的应该是左子树的根节点，也就保证了先序遍历的规则。

中序遍历

首先将根节点所有的左子树节点压栈，然后一一出栈，每当出栈一个元素后，便将其右子树节点压栈。这样就可以实现首先出栈的永远是栈中的左子树节点，然后是根节点，最后时右子树节点，也就可以保证中序遍历的规则。

后序遍历

使用了两个栈来辅助，其中一个stackIn作为中间存储起到过渡作用，而另一个stackOut则作为最后的输出结果进行遍历显示。众所周知，栈的特性使LIFO（后进先出），那么stackIn在进行存储过渡时，先按照根节点->左孩子->右孩子的顺序依次压栈，那么其出栈顺序就是右孩子->左孩子->根节点。而每当循环一次就会从stackIn中出栈一个元素，并压入stackOut中，那么这时stackOut中的出栈顺序则变成了左孩子->右孩子->根节点的顺序，也就符合了后序遍历的规则。

层次遍历

使用了一个队列来辅助实现，队列是遵循FIFO（先进先出）的，与栈刚好相反，所以，我们这里只需要按照根节点->左孩子->右孩子的入队顺序依次入队，输出时就可以符合根节点->左孩子->右孩子的规则了。

图的遍历

广度与深度遍历

广度：队列
深度：栈

散列表

哈希（散列）技术既是一种存储方法，也是一种查找方法。

构造哈希函数的方法

构造哈希函数的目标在于使哈希地址尽可能均匀地分布在连续的内存单元地址上，以减少发生冲突的可能性，同时使计算尽可能简单以达到尽可能高的时间效率，这里主要看看两个构造哈希函数的方法。

　　（1）直接地址法

　　直接地址法取关键字的某个线性函数值为哈希地址，即h(key)=key 或 h(key)=a*key+b

　　其中，a、b均为常数，这样的散列函数优点就是简单、均匀，也不会产生冲突，但问题是这需要事先知道关键字的分布情况，适合查找表较小且连续的情况。由于这样的限制，在现实应用中，此方法虽然简单，但却并不常用。

　　（2）除留余数法

　　除留余数法采用取模运算（%）把关键字除以某个不大于哈希表表长的整数得到的余数作为哈希地址，它也是最常用的构造哈希函数的方法，其形式为：h(key)=key%p

解决哈希冲突的方法

（1）闭散列法

　　闭散列法时把所有的元素都存储在哈希表数组中，当发生冲突时，在冲突位置的附近寻找可存放记录的空单元。寻找“下一个”空位的过程则称为探测。

（2）开散列法

　　开散列法的常见形式是将所有关键字为同义词的记录存储在一个单链表中。我们称这种表为同义词子表，在散列表中只存储所有同义词子表的头指针。

伪随机数发生算法

梅森旋转算法

Python 的伪随机数（pseudorandom number）生成器用的是梅森旋转（Mersenne
Twister）算法（https://en.wikipedia.org/wiki/Mersenne_Twister），它产生的随机数很难
预测且呈均匀分布

加密算法

对称加密

Blowfish

Blowfish能保证很好的加密速度，并且目前为止没有发现有效地破解方法。目前为止AES比Blowfish有更广的知名度。

加密算法之BLOWFISH算法

AES

AES(Advanced Encryption Standard)，又称Rijndael加密法

其他

scrypt

scrypt不仅计算所需时间长，而且占用的内存也多，使得并行计算多个摘要异常困难，因此利用rainbow table进行暴力攻击更加困难。

book

• 算法图解
• 编程之法：面试和算法心得

Linux与Qt程序设计

陈爽主编

Citation (APA): 陈爽主编. (2011). Linux与Qt程序设计 [Kindle Android version]. Retrieved from Amazon.com

安装完毕后，MySQL会自动启动，也可以通过命令来启动和停止MySQL服务。

（1）启动MySQL服务 chenshuang@myHost:～$sudo start mysql mysql start/running,process 3209

（2）停止MySQL服务 chenshuang@myHost:～$sudo stop mysql mysql stop/waiting

（3）测试MySQL是否启动，返回MySQL服务的进程id。 chenshuang@myHost:～$pgrep mysqlid 3209

（4）通过命令行连接MySQL服务器，登录过程中，需要输入root密码。

chenshuang@myHost:～$mysql-uroot-p Enter password: Welcome to the MySQL monitor. Commands end with;or\g. 
Your MySQL connection id is 34 Server version:5.1.54-1ubuntu4(Ubuntu) Copyright(c)2000,2010,Oracle and/or its affiliates.All rights reserved.
 This software comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to modify and redistribute it under the GPL v2 license Type'help;
'or'\h'for help.Type'\c'to clear the current input statement.
 mysql>

sudo是允许系统管理员让普通用户执行一些或者全部的root命令的一个工具，

Qt是以工具开发包的形式提供给开发者的，这些工具开发包包括Qt图形设计器（Qt Designer），Makefile 制作工具（qmake），字体国际化工具（Qt Linguist），Qt的C++类库，等等。

Qt已经成为Linux上自由软件的主流GUI开发工具，是流行的KDE桌面环境的基础。如今在Internet上有很多关于Qt开发的可用资源，如：

Qt官方主页（英文）：http://Qt.nokia.com/； 
Qt中文网论坛（Qt中文网论坛）（简体中文）：http://www.Qtcn.org/；
匿名访问FTP：ftp://ftp.trolltech.com； 
Qt中心（论坛，新闻，Wiki）：http://www.Qtcentre.org； 
Qt的实验室（开发人员博客，研究项目）：http://labs.Qt.nokia.com/；
邮件列表：http://lists.Qt.nokia.com.

Qt为各种专业应用提供了丰富的类库，共计超过370个，主要包括：界面控件类，数据库类，日期时间类，拖曳操作类，事件类，通用容器类，图形图像类，打印类，系统帮助类，布局管理类，设备相关类，输入输出与网络类，窗口相关类等。这些类组成了Qt编程的基本模块—组件，Qt含有用来实现各种专业应用所需要的各种组件。

图形支持 Qt通过QPainter和QGraphicsViewAPI对高级2D图形提供了支持。此外，Qt通过其OpenGL模块支持3D图形。 QPainter提供了一个全面的2D绘图框架。除了渲染多边形、绘图路径等功能外，还支持平滑处理、渐变和alpha混合。 Qt Graphics View提供了2D场景图形API。它带有高级API，用于在场景中放置对象并在多个视图中显示场景。 Qt开发人员可以使用OpenGL在GUI应用程序中绘制3D图形。Qt提供了单独的Qt OpenGL模块，可将OpenGL图像与本地窗口系统集成在一起。

Qt SDK包括了Qt库、Qt Creator IDE和Qt工具，Qt SDK同样也支持Linux/X11，Windows，Mac三种主流桌面操作系统。主要开发工具如下。

（1）Qt Designer。一个功能强大的GUI布局与窗口构造器，能够在所有支持平台上，以本地化的视图外观与认知，快速开发高性能的用户界面。
（2）Qt Linguist。一套用来消除国际化工作流程中所带来的障碍的工具。使用Qt Linguist，开发小组可把应用程序的翻译转换外包给非技术性翻译人员，从而可增加精确度，大大加快本地化处理过程。
（3）Qt Assistant。一个完全可自定义、重新分配的帮助文件或文档浏览器。

由于GNOME和KDE都是以X Window系统为基础，所以GNOME和KDE上的应用程序也都是基于X Window系统的。为了屏蔽X协议层实现的细节，Xlib库被开发了出来。Xlib是一种X Window System协议的客户端，以C语言撰写。其功能是与X Server沟通，这样的功能可以让程序人员撰写程序时，无须了解其协议的细节。Xlib是底层库，在应用程序开发过程中很少有应用程序直接调用Xlib，而是使用在Xlib库上发展出的更高层的函数库，如：Xt SDK、Motif SDK和Qt SDK。

Qt SDK中主要包括：类库（class library）、开发工具（development tools）、平台相关支持（cross-platform support）、授权许可（Flexible license）等。其中类库包含了Qt的所有对外发布的功能组件，介绍如下。

（1）Core：Qt4的基本模块,定义了其他模块使用的Qt核心的非GUI类,所有其他的模块都依赖于该模块。
（2）GUI：定义了图形用户界面类。
（3）WebKit：提供了一个在Qt中使用Web Browser的渲染与解析引擎。
（4）Graphic View：提供的是一种 Qt Model-View的编程模式，既可以管理大数量的定制2D graphical items，又可与它们交互，有一个视图窗口可以把这些项绘制出来，并支持旋转与缩放。
（5）Scripting：提供了对脚本（如Java、Python、Perl、Ruby）的支持。
（6）OpenGL：提供了便于在Qt应用程序中使用OpenGL和OpenGL ES加入3D图形的类。
（7）XML：定义了处理XML（eXtensible Markup Language）语言的类。
（8）Multimedia：提供了播放媒体源的功能。
（9）Database：提供了与平台和数据库种类无关的SQL访问接口。
（10）Network：定义了Qt的网络编程类。
（11）Unit Tests：定义了对Qt应用程序和库进行单元测试的类。

开发工具集包含了Qt开发者所使用的集成开发环境，介绍如下。

（1）Qt Creator：是一个跨平台集成开发环境（Integrated Development Environment，IDE），开发人员能够利用这个Qt提供的轻量级开发环境快速、简单地完成开发任务；
（2）GUI Designer：是一个所见即所得的GUI构造器，利用Qt Designer，可以拖放各种Qt控件构造图形用户界面并可以在多种平台上使用。
（3）Build Tool：包括qmake、moc、uic等，构成了Qt完整的编译体系。
（4）Help System：Qt Assistant是可配置且可重新发布的文档阅读器，可轻易进行定制并与用户的Qt应用程序一起重新发布。

在平台相关支持，Qt支持下列操作系统：Microsoft Windows 95/98、Microsoft Windows NT、Linux、Solaris、SunOS、HP-UX、DigitalUNIX（OSF/1、Tru64）、Irix、Free BSD、BSD/OS、SCO、AIX、OS 390和QNX等。特别是在嵌入式环境中，Qt提供的Qt Embedded已经直接取代了X Server及X Library等角色，将所有的功能全部整合在一起。

首先要介绍的是扩展名为Pro的文件类型，此类型的文件在Qt中是物理级别最高的，称为工程文件。之所以称之为物理级别最高是因为在Qt中存在会话（session）的概念，在一个会话中可以包含多个Qt工程，Qt通过会话来管理多个工程之间协作开发。在Qt中，应用程序是以Project的形式存在的，Qt将程序的资源（头文件(.h)、源文件(.cpp)、ui文件、qrc文件）以工程的形式组织在一起，Project文件的扩展名是.pro。 Qt工程文件是以标签选项的结构进行组织的，其中常用的标签项有：TEMPLATE、SOURCES、HEADERS、FORMS、TARGET、DESTDIR、INCLUDEPATH、DEPENDPATH、CONFIG等，

对一些常用的标签进行详细介绍。

• 1.TEMPLATE 此标签的作用是用qmake表示Qt工程类型，以便qmake程序根据不同的工程类型配置编译过程。 TEMPLATE的主要类型如下。
  • app：建立一个应用程序的makefile。这是默认值，所以如果模板没有被指定，它将被使用。
  • lib：建立一个库的makefile。
  • subdirs：这是一个特殊的模板，它可以创建一个能够进入的特定目录并且为一个项目文件生成makefile并且为它调用make的makefile。
  • vcapp：建立一个应用程序的Visual Studio项目文件。
  • vclib：建立一个库的Visual Studio项目文件。
  • vcsubdirs：同subdirs。
• 2.TARGET 可执行应用程序的名称。默认值为项目文件的名称。（如果需要扩展名，会被自动加上。）
• 3.Qt Qt 变量被用来声明引用Qt提供的扩展模块，如：core，gui，network，opengl，sql，svg，xml，xmlpatterns，Qt3support。Qt的core模块和gui模块会被作为默认选项自动添加，如果想去掉默认选项，可以通过Qt-=gui实现。
• 4.CONFIG CONFIG 变量指定了编译器所要使用的选项和所需要被连接的库。配置变量中可以添加任何东西，但只有下面这些选项可以被qmake识别。
  • 下面这些选项控制着使用哪些编译器标志：
    • release：应用程序将以release模式连编。如果debug被指定，它将被忽略。
    • debug：应用程序将以debug模式连编。
    • warn_on：编译器会输出尽可能多的警告信息。如果warn_off被指定，它将被忽略。
    • warn_off：编译器会输出尽可能少的警告信息。
  • 下面这些选项定义了所要连编的库/应用程序的类型：
    • Qt：应用程序是一个Qt应用程序，并且Qt库将会被连接。
    • thread：应用程序是一个多线程应用程序。
    • x11：应用程序是一个X11应用程序或库。
    • windows：只用于app模板，应用程序是一个Windows下的窗口应用程序。
    • console：只用于app模板，应用程序是一个Windows下的控制台应用程序。
    • dll：只用于lib模板，库是一个共享库（dll）。
    • staticlib：只用于lib模板，库是一个静态库。
    • plugin：只用于lib模板，库是一个插件，这将会使dll选项生效。
• 5.HEADERS 应用程序中的所有头文件的列表。
• 6.SOURCES 应用程序中的所有源文件的列表。
• 7.FORMS 应用程序中的所有.ui文件（由Qt设计器生成）的列表。
• 8.LIBS 记录了程序中所用到的其他库文件列表（以-l开头）及库文件的搜索路径（以-L开头）。
• 9.TARGET 可执行应用程序的名称。默认值为项目文件的名称。（如果需要扩展名，会被自动加上。）
• 10.DESTDIR 放置可执行程序目标的目录。
• 11.DEFINES 应用程序所需的额外的预处理程序定义的列表。
• 12.INCLUDEPATH 应用程序所需的额外的包含路径的列表。
• 13.DEPENDPATH 应用程序所依赖的搜索路径。
• 14.DEF_FILE 只有Windows需要，应用程序所要连接的.def文件。
• 15.RC_FILE 只有Windows需要，应用程序的资源文件。
• 16.RES_FILE 只有Windows需要，应用程序所要连接的资源文件。

MOC（Meta-Object Compiler）是用来实现Qt对C++的扩展部分。MOC解析C++文件中的类定义，并生成元对象（Meta Object）的代码，包括所有signal和slot成员的名字和函数指针。Meta Object还包含诸如对象的类名称等静态信息，以此来检查该对象的继承派生关系。moc文件必须与目标类的实现代码一起被编译和链接。 MOC 读取 C++类文件。如果它发现其中该类包含Q_OBJECT 宏，它就会给含有Q_OBJECT宏的类生成另一个含有元对象代码的C++源文件。除了提供对象间通信的信号和槽机制之外，派生自QObject中的元对象代码实现其他特征。

（1）className()：函数在运行的时候以字符串返回类的名称，不需要C++编译器中的本地运行类型信息（RTTI）的支持。
（2）inherits()：函数返回这个对象是否是一个继承于QObject继承树中一个特定类的实例。
（3）tr()：用于国际化中的字符串翻译。
（4）setProperty()、property()：两个函数是用来通过名称动态设置和获得对象属性的。
（5）metaObject()：函数返回这个类所关联的元对象。

单继承方法是Qt4之后的默认实现方法。以上面所创建的MyMainWindow工程为例，它的主窗口名为MyMainWindow，它继承于QMainWindow，它有一个Ui:: MyMainWindow的私有成员，并在MyMainWindow的构造函数中，实例化这个私有的Ui::MyMainWindow，之后调用这个私有Ui::MyMainWindow的setupUi 方法，设置MyMainWindow的用户界面接口，即按UI文件中记录的界面信息初始化MyMainWindow的界面。至此，一个按照UI文件设计的界面的窗口就建立起来了。

在Linux操作系统中，采用了很多共享对象技术（Shared Object），虽然它和Windows里的动态库相对应，但它并不称为动态库。相应的共享对象文件以.so作为后缀，

所有从QObject或其子类(例如QWidget)派生的类都能够包含信号和槽。当对象改变其状态时，信号就由该对象发射(emit)出去，这就是对象所要做的全部事情，它不知道另一端是谁在接收这个信号。这就是真正的信息封装，它确保对象被当作一个真正的软件组件来使用。槽用于接收信号，但它们是普通的对象成员函数。一个槽并不知道是否有任何信号与自己相连接。而且，对象并不了解具体的通信机制。可以将很多信号与单个的槽进行连接，也可以将单个的信号与很多的槽进行连接，甚至于将一个信号与另外一个信号相连接也是可能的，这时无论第一个信号什么时候发射，系统都将立刻发射第二个信号。总之，信号与槽构造了一个强大的部件编程机制。

指定信号 signal时必须使用Qt的宏 SIGNAL()，当指定槽函数时必须使用宏 SLOT()。如果发射者与接收者属于同一个对象，那么在connect 调用中接收者参数可以省略。

在Windows 平台下，Qt程序的消息处理系统每收到一个操作系统底层传来的消息就会调用winEventFilter函数，原型 如下：

bool winEventFilter( MSG* msg, long* result);

窗口消息截获的主要功能实现是通过派生 QApplication类并重新实现函数winEventFilter。当程序接收到一个发自Windows的消息时会调用winEventFilter并将消息的内容通过参数msg进行传递，在重新实现的winEventFilter中，首先对消息的类型进行判断，当消息的类型是窗口消息时（在Windows中窗口消息的类型定义为WM_COPYDATA），就将消息的内容还原成一个字符串，并触发信号signalReceiveCopyData将内容传递出去。

当派生类QApplication4Win32Filter 触发信号后，槽会被调用，从而实现信息的传递。

与前节所述的Windows 消息截获相类似，Linux平台下消息的截获是通过派生应用类QApplication并重新实现函数x11EventFilter来实现的，不同之处在于Linux平台下x11EventFilter的参数是一个定义自XLib的结构体指针。Xlib是X Window提供的API集合，Qt建立在Xlib之上。

在Qt中引入了一个MVC的变体——Model/View结构。这个结构依然是分离数据存储与数据，它与MVC都基于同样的思想，但它更简单一些。在几个不同的View 上显示同一个数据成为可能，需重新实现新的View时,不必改变底层的数据结构。为了更灵活地对用户输入进行处理，引入了delegate的概念。它的好处是，数据项的渲染与编程可以进行定制。

在Qt Creator/Desinger中，常用的基础控件都被放在WidgetBox中，而且根据控件的类型进行了分类。

QButton类是按钮窗口控件的抽象基类，并且为用户提供了按钮共有的功能。其中包括isDown()、isOn()、isEnabled()、setAutoRepeat()、setToggleButton()这五种基本状态，以及pressed()、released()、clicked()、toggled(bool)、stateChanged(int)五种基本信号。

用户可以通过QPushButton类创建一个常用的按钮。

QButtonGroup类将多个QButton窗口控件组合在一起。它是一组按钮的父窗口控件，也就是说它是按钮构造函数中的parent参数。QRadionButton类则是单选按钮控件，一般与QButtonGroup类结合使用来控制组群的唯一性。

QlineEdit类是一个单行文本输入框，用户在文本框内可以输入文字或数字，也可以对输入的文本进行验证，还可以设置文本的显示方式。下面展示了几种不同类型的QlineEdit类，包括字符串输入、密码输入、只读和验证类型等，

与QlineEdit类的单行文本框不同，QtextEdit类提供了强大的单页面的多信息文本编辑器，它支持浏览HTML风格标记的多信息文本格式。QtextEdit类提供了三种文本操作模式，包括：一般文本编辑器、多信息文本编辑器和文本查看器。

通过调用QtextEdit类提供的setAcceptRichText()来设置该文本部件对象是否接受富文本形式。

QCalendarWidget类提供一个日历控件，它允许用户简单直观地选择日期。

QCombox类是一个下拉列表框控件，它为用户提供了一组可以选择的下拉列表。用户在使用QCombox类的过程中需引入头文件声明#include。

QLCDNumber类是一个LCD显示控件，该控件以LCD方式显示数字。用户在使用QLCDNumber类的过程中需引入头文件声明#include。

QProgressBar类是一个横的或者竖的进度条控件，该类常用来显示目前的工作进度，

QSpinBox类和QDoubleSpinBox类都是微调控件，QSpinBox类常用来手动设置整数和一些其他数据的集合，而QdoubleSpinBox类常用来设置浮点数。它们允许用户通过单击上下按钮来选择值，或者通过按键盘的Up或Down键来增大或减小当前显示值，也允许手工设置值。

QSlider类是一个横或者竖的滑动条控件,该类通过滑块来控制一个绑定变量的值。

QTreeWidget类是一种树形的部件，它以树的形式显示各个项，每一项用QtreeWidgetItem类来描述。

Qt提供了三种方式来管理窗口上子窗口部件的布局。

1. 绝对位置法这种布局方法是一种比较原始的布局窗口部件的方法。该布局方法通过调用基类QWidget提供的setGeometry()函数来设置子窗口部件在父窗口中显示的固定大小和位置。这种布局方式有很多种缺点，主要包括：
   1. 无法改变窗口的大小；
   2. 当应用程序的运行环境或者样式发生改变时，有可能会影响子窗口部件的显示效果和内容；
   3. 为了达到比较好的显示效果，必须通过人工反复计算子窗口部件的大小和位置，不易于开发和维护。
2. 人工位置法这种布局方式也是通过调用基类QWidget提供的setGeometry()函数来设置子窗口部件在父窗口中显示的位置和大小。但与绝对位置法不同的是，该方法通过重载void QWidget::resizeEvent(QResizeEvent*)函数使得子窗口部件大小和父窗口部件大小成比例。
3. 布局管理器方式这种布局方法是一种简单的布局窗口部件的方法。该布局方法为不同类型的窗口部件提供一系列合适的默认值，并且会根据窗口的大小策略和最大、最小尺寸，自动调整布局来响应样式、窗口大小的变化。

布局管理器：Qt布局管理器负责在父窗口部件区域内存放子窗口部件。布局管理器可以使其中的窗口部件自动定位并重新调整它们的位置和大小。QLayout类是布局管理器的基类，它的派生类主要有QBoxLayout、QFormLayout、QGridLayout和QStackedLayout，而QBoxLayout又有两类派生类QHBoxLayout和QVBoxLayout。

Qt中常用的五种布局管理器的特点如下。

（1）QHBoxLayout：水平布局管理器，按水平方向存放窗口部件。
（2）QVBoxLayout：垂直布局管理器，按垂直方向存放窗口部件。
（3）QGridLayout：网格布局管理器，按二维网格方式存放窗口部件。
（4）QFormLayout：表单布局管理器，按表单形式存放窗口部件。
（5）QStackedLayout：栈布局管理器，按类似栈方式存放窗口部件。

QFormLayout布局管理器将窗口部件按表单形式布局，

QStackedLayout布局管理器按照一种类似栈的方式排列窗口部件，

//Main.cpp
#include"mainwindow.h"
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QTextCodec::setCodecForTr(QTextCodec::codecForName("gb18030"));
    MainWindow w;
    w.show();
    return a.exec();
}

在上述代码中，MainWindow是派生自QMainWindow的主窗口应用程序类。Main文件完成两个功能：设置字符集支持汉字和创建并显示主窗口应用程序。

根据数据在容器中排列的特性，容器可以分为序列式（Sequence）和关联式（Associative）两种。

与标准模板库对应，Qt也提供了一组自己的通用容器模板类。与标准模板库相比，在Qt的开发环境中更加易于使用。Qt通用容器类都是隐含共享（Implicit Sharing）的，这使得容器类实例在传值操作中内存开销最优化。Qt提供了如QVector、QList等序列式容器模板类（它们的差别在于访问元素的方式，以及添加或删除元素相关操作的运行代价），也提供了如QMap、QHash等关联式容器模板类。

QFile类是一个操作文件的输入/输出设备，是用来读写二进制文件和文本文件的。用户可以单独使用QFile类，也可以和QDataStream或QTextStream一起使用。

QDir类提供了一种与平台无关的遍历目录结构并获得目录结构当中的内容，使用QDir类可以操作目录、存取目录或文件信息、操作底层文件系统和存取Qt资源文件。Qt使用“/”作为分隔符。用户通过QDir类提供的convertSeparators()静态函数，根据底层操作系统环境的不同，自动将程序中的目录分隔符转换成符合要求的符号（如Windows使用“\”，Linux使用“/”）。

QFileInfo类提供了一种与平台无关的文件信息，包括文件名称、路径、读取权限、大小、最后修改/读取时间及是否为目录或者符号链接等。要读取一个文件信息，可以在QFileInfo类的构造函数中设置文件名，也可以通过setFile()函数来设置。

exists()函数用来判断一个文件是否存在，size()函数用来返回文件的大小。文件类型可以通过isFile()、isDir()和isSymLink()来获取。symLinkTarget()函数用来返回符号链接所指向的文件名。为了提高运行效率，QFileInfo类将文件的一部分信息存入缓存当中，由于文件在使用过程中，很有可能被应用程序改变，所以QFileInfo类提供了refresh()函数来刷新文件信息。

Qt提供了QFileSystemWatcher类来监视目录或者文件的变化。addPath()、addPaths()函数用来监视指定的一个或者多个文件或者目录。如果需要移除不需要监视的文件或者目录，则可以调用removePath()或者removePaths()函数。当所监视的文件发生改变时，会产生一个fileChange()信号，当所监视的目录发生改变时，会产生一个directoryChange()信号。

Qt提供了QXML模块来支持对XML数据的处理。QXML模块提供了以下两种常见的XML文件操作方式。（1）DOM（Document Object Model，文档对象模型），其实现方式是将整个XML文档数据以树状结构的形式加载到内存。这种方式的优点是操作简单，缺点是将整个XML文件放入内存，不适合处理过大文件。（2）SAX（Simple API for XML，XML简单应用程序接口），其实现方式是基于事件的循序存取XML数据流。这种方式的优点是适合处理大的文件，但是操作比较复杂。

在Qt中，常见的操作XML的类有QXmlStreamReader、QDomDocument、QxmlDefault Handler等。

Qt提供了三种生成XML文档的方法：使用QXmlStreamWriter、DOM树保存和手动生成XML文档。利用QDomDocument类生成XML首先需要构造DOM树，然后调用save()方法将占据保存为XML文档。

用户可以配置Qt来支持多线程，并提供类来表示线程、互斥锁、信号灯、线程全局存储，另外还提供支持不同锁定机制的类。

Qt通过三种形式提供了对线程的支持。它们分别是:

（1）平台无关的线程类；
（2）线程安全的事件投递；
（3）跨线程的信号-槽连接。

Qt包含下面一些线程相关的类：

（1）QThread提供了开始一个新线程的方法；
（2）QThreadStorage提供逐线程数据存储；
（3）QMutex提供相互排斥的锁，或互斥量；
（4）QMutexLocker是一个互斥锁的，它可以自动对QMutex加锁与解；
（5）QReadWriterLock提供了一个可以同时读操作的锁；
（6）QReadLocker与QWriteLocker是便利类，它自动对QReadWriteLock加锁与解锁；
（7）QSemaphore提供了一个整型信号量，是互斥量的泛化；
（8）QWaitCondition提供了一种方法，使得线程可以在被其他线程唤醒它之前一直休眠。

Qt 4中实现线程同步的机制包括：互斥体（QMutex）、读写锁（QReadWriteLock）、信号量（QSemaphore）和条件变量（QWaitCondition）。

QSemaphore类是QMutex类的一般化，它可以保护一定数量的相同资源，与此相对，一个QMutex类只保护一个资源。

使用QSemaphore类来控制对环状缓冲的访问，此缓冲区被生产者线程和消费者线程共享。生产者不断向缓冲区写入数据直到缓冲末端，再从头开始。消费者从缓冲区不断读取数据。信号量比互斥量有更好的并发性，假如用互斥量来控制对缓冲区的访问，那么生产者、消费者不能同时访问缓冲区。然而，在同一时刻，不同线程访问缓冲区的不同部分并没有什么危害。

QWaitCondition类允许线程在某些情况发生时唤醒其他的线程。当一个或多个线程阻塞等待时，可用wakeOne()或wakeAll()执行唤醒操作。wakeOne()随机唤醒一个线程，wakeAll()唤醒所有线程。

每一个Qt的应用程序都有一个全局的QThreadPool对象，可以通过函数globalInstance()调用该线程池全局对象。

事实上，这里是使用QThreadPool类来运行一个QRunnable对象，它维护了一个线程池。通过调用QThreadPool::start(runnable)，把一个QRunnable放入QThreadPool的运行队列中；只要线程是可见的，QRunnable将会被拾起并且在那个线程里运行。尽管所有的Qt应用程序都有一个全局的线程池，且它是通过调用QThreadPool::globalInstance()可见的，但通常是显式地创建并管理一个私有的QThreadPool实例。

Qt支持的数据库类型

Qt的数据库模块主要通过QSqlDatabase类和QSqlQuery类来实现对数据库的绑定、连接和执行。可以通过QSqlDatabase类对象实现对数据库的绑定和连接，然后通过QSqlQuery类对象执行相关的SQL语句对数据库进行操作。

QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL");
db.setHostName("qpk");
db.setDatabaseName("bookmis.db");
db.setUserName("qpk");
db.setPassword("cugbupt");
bool ok = db.open();
QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName("bookmis.db");
if(!db.open())
{
    QMessageBox::critical(0, qApp->tr("Cannot open database"), qApp->tr("Unable to establish a database connection.\n"), QMessageBox::Cancel);
    return false;
}

在上述代码中，首先实例化QSqlDatabase对象并指定加载SQLite数据库，指定打开的数据库名称。由于SQLite为文件数据库，所以无须指定用户名密码等相关信息。

QSqlQuery提供了执行数据库语句的方法，在Qt中利用QSqlQuery类实现了执行SQL语句。它可以返回所有的执行结果。当建立好数据库连接后可以使用QSqlQuery::exec()，如同下面的语句： QSqlQuery query; query.exec("SELECT*FROM book"); 当创建一个QSqlQuery对象后，可以被指定的QSqlDatabase对象连接来使用。

在Qt中，QHostInfo类用来获取主机网络配置的相关信息。该类提供了两个常用的静态函数来获取主机信息，一个是使用lookupHost( const QString & name, QObject*receiver, const char *member)函数异步查询主机信息，并且在主机查询完毕后发出一个信号，另一个是使用QHostInfo fromName(const QString&name)函数阻塞查询主机信息，并且返回一个QHostInfo对象。

TCP是一种可靠的、面向数据量、面向连接的传输协议，在它的基础上构成了HTTP、FTP等高层网络协议。而UDP 则是一种不可靠的、面向数据报的、面向无连接的传输协议。在Qt中，QTcpSocket、QTcpServer类用来实现TCP客户端和服务器端的应用程序，QUdpSocket类可以用来发送和接收UDP数据报。

超文本传输协议 HTTP是一种应用级的网络文件传输协议，主要用于文件传输。Qt提供了QHttp、QNetworkAccessManager等类来构建 HTTP客户端，并且提供了许多常用的操作。

QHttp采用异步执行方式，如果某个操作不能立即执行完毕，函数也会马上返回。

Qt对2D和3D图形提供了强大的支持。Qt的2D图形类支持点阵图形和向量图形，可以加载并保存各种图形格式，并可将文本和图形导出为Portable Document Format(PDF)文件。Qt可以绘制转换后的Unicode文本和Scalable Vector Graphics(SVG)图纸，并可为需要交互的应用程序提供功能全面的Canvas。Qt实际上是与平台无关的OpenGL编程的一个标准GUI框架。

Qt的2D图形系统的基础是类QPainter。QPainter类提供了一个与平台无关的API，以便在控件和其他绘图设备中进行绘图。Qt的所有内建的控件均可使用QPainter来绘制其本身。QPainter能够绘制各种几何图形（点、线、矩形、椭圆、圆弧、弦、扇形、多段线、贝赛尔曲线），还能绘制位图、图像和文字。此外QPainter还提供了很多高级功能：如平滑（平滑文字和几何图形的边界），透明度，渐变色和矢量路径。QPainter还支持矩阵变换，使绘制2D图形和分辨率无关。

Qt一共提供了四个继承自QPainterDevice类，分别是QPixmap、QBitmap、QImage和QPicture。

Qt中使用QPainterPath显示任意路径曲线的绘制。通过连接基本图形元素，如直线、椭圆、多段线、圆弧、二次和三次贝塞尔曲线等，QPainterPath类能确定任何矢量图形。因此，绘图路径（Painter Paths）是最基本的绘制元素，任何图形和图形的组合都可以用路径（Path）表示。一个路径能够确定一个轮廓，由这个轮廓确定的区域可以由刷子来填充。

绘图设备是指继承QPainterDevice的子类。Qt一共提供了四个这样的类，分别是QPixmap、QBitmap、QImage和QPicture。其中，QPixmap专门为图像在屏幕上的显示做了优化，而QBitmap是QPixmap的一个子类，它的色深限定为1，可以使用QPixmap的isQBitmap()函数来确定这个QPixmap是不是一个QBitmap。QImage专门为图像的像素级访问做了优化。QPicture 则可以记录和重现QPainter的各条命令。

坐标系变换是利用变换矩阵来进行的，可以利用QTransform类来设置变换矩阵。

Windows计时函数

time()
GetTickCount()
GetTickCount64()
timeGetTime(
clock()
GetSystemTimeAsFileTime( ) 
GetSystemTimePreciseAsFileTime()
QueryPerformanceCounter()

创建 stopwatch 类

stopwatch 类

template <typename T> class basic_stopwatch : T
{
    typedef typename T BaseTimer;
public:
    // 创建一个秒表，开始计时一项程序活动（可选）
    explicit basic_stopwatch(bool start);
    explicit basic_stopwatch(char const *activity = "Stopwatch",
                             bool start = true);
    basic_stopwatch(std::ostream &log,
                    char const *activity = "Stopwatch",
                    bool start = true);
    // 停止并销毁秒表
    ~basic_stopwatch();
    // 得到上一次计时时间（上一次停止时的时间）
    unsigned LapGet() const;
    // 判断：如果秒表正在运行，则返回true
    bool IsStarted() const;
    // 显示累计时间，一直运行，设置/返回上次计时时间
    unsigned Show(char const *event = "show");
    // 启动（重启）秒表， 设置/返回上次计时时间
    unsigned Start(char const *event_namee = "start");
    // 停止正在计时的秒表， 设置/返回上次计时时间
    unsigned Stop(char const *event_name = "stop");
private: // 成员变量
    char const *m_activity; // "activity"字符串
    unsigned m_lap; // 上次计时时间（上一次停止时的时间）
    std::ostream &m_log; // 用于记录事件的流
};

使用了 的 TimerBase 类

# include <chrono>
using namespace std::chrono;
class TimerBase
{
public:
    // 清除计时器
    TimerBase() : m_start(system_clock::time_point::min()) { }
    // 清除计时器
    void Clear()
    {
        m_start = system_clock::time_point::min();
    }
    // 如果计时器正在计时，则返回true
    bool IsStarted() const
    {
        return (m_start.time_since_epoch() != system_clock::duration(0));
    }
    // 启动计时器
    void Start()
    {
        m_start = system_clock::now();
    }
    // 得到自计时开始后的毫秒值
    unsigned long GetMs()
    {
        if (IsStarted())
        {
            system_clock::duration diff;
            diff = system_clock::now() - m_start;
            return (unsigned)(duration_cast<milliseconds>(diff).count());
        }
        return 0;
    }
private:
    system_clock::time_point m_start;
};

TimerBase 类与这个类的功能相同，不过其中使用的是在 Windows 上和
Linux 上都可以使用的 clock() 函数。

使用了 clock() 的 TimerBase 类

class TimerBaseClock
{
public:

    // 清除计时器
    TimerBaseClock()
    {
        m_start = -1;
    }
    // 清除计时器
    void Clear()
    {
        m_start = -1;
    }
    // 如果计时器正在计时，则返回true
    bool IsStarted() const
    {
        return (m_start != -1);
    }
    // 启动计时器
    void Start()
    {
        m_start = clock();
    }
    // 得到自计时开始后的毫秒值
    unsigned long GetMs()
    {
        clock_t now;
        if (IsStarted())
        {
            now = clock();
            clock_t dt = (now - m_start);
            return (unsigned long)(dt * 1000 / CLOCKS_PER_SEC);
        }
        return 0;
    }
private:
    clock_t m_start;
};

这种实现方式的优点是在不同 C++ 版本和不同操作系统之间具有可移植性，缺点是在
Linux 上和 Windows 上， clock() 函数的测量结果略有不同。

使用了 gettimeofday() 的 TimerBase

# include <chrono>
using namespace std::chrono;
class TimerBaseChrono
{
public:
    // 清除计时器
    TimerBaseChrono() :
        m_start(system_clock::time_point::min())
    {
    }
    // 清除计时器
    void Clear()
    {
        m_start = system_clock::time_point::min();
    }
    // 如果计时器正在计时，则返回true
    bool IsStarted() const
    {
        return (m_start != system_clock::time_point::min());
    }
    // 启动计时器
    void Start()
    {
        m_start = std::chrono::system_clock::now();
    }
    // 得到自计时开始后的毫秒值
    unsigned long GetMs()
    {
        if (IsStarted())
        {
            system_clock::duration diff;
            diff = system_clock::now() - m_start;
            return (unsigned)
                   (duration_cast<milliseconds>(diff).count());
        }
        return 0;
    }
private:
    std::chrono::system_clock::time_point m_start;
};

TimerBase 类可以工作于旧版本的 Windows 上和 Linux 上。如果是在
Windows 上，那么还必须显式地提供 gettimeofday() 函数，因为它既不属于 Windows
API，也不属于 C 标准库。

这种实现方式在不同的 C++ 版本和不同操作系统之间具有可移植性。但当运行于 Windows
上时，需要实现 gettimeofday() 函数。

使用

Stopwatch sw("activity");

Boost

timer（V1）库包含三个小组件，分别是：计时器timer、progress_timer和进度指示器progress_display，

timer类可以测量时间的流逝，是一个小型的计时器，提供毫秒级别的计时精度和操作函数，供程序员手工控制使用，就像是个方便的秒表。

progress_timer也是一个计时器，它继承自timer，会在析构时自动输出时间，省去了timer手动调用elapsed（）的工作，是一个用于自动计时相当方便的小工具。

progress_display可以在控制台上显示程序的执行进度，如果程序执行很耗费时间，那么它能够提供一个友好的用户界面，不至于让用户在等待中失去耐心。

timer和progress_timer是两个用于计时的小工具，实现原理很简单，使用了C标准中的std：：clock（），精度不高但足够用。特别是progress_timer，它利用了C++中析构函数会被自动调用的特点，能够自动显示时间，用起来更方便。但如果我们需要更高精度的计时，那么应该使用timer库的另一个组件：cpu_timer

cpu_timer使用了chrono库的高精度时钟high_resolution_clock，不仅能够度量进程使用的实际时间，还能够度量CPU时间，它支持最高到微秒精度的计时，而且使用起来同样非常方便，是旧版本timer的很好替代品。

auto_cpu_timer是一个类似于progress_timer的自动计时器，它继承自cpu_timer

采用更丰富的 std::string 库

Boost 字符串库（http://www.boost.org/doc/libs/?view=category_String）

Boost 字符串库提供了按标记将字符串分段、格式化字符串和其他操作 std::string 的
函数。这为那些喜爱标准库中的 头文件的开发人员提供了很大的帮助。

C++ 字符串工具包 （http://www.partow.net/programming/strtk/index.html）

另一个选择是 C++ 字符串工具包（StrTk）。StrTk 在解析字符串和按标记将字符串分段
方面格外优秀，而且它兼容 std::string 。

std::stringstream

C++引入了ostringstream、istringstream、stringstream这三个类，要使用他们创建对象就必须包含sstream.h头文件。

istringstream类用于执行C++风格的串流的输入操作。 
ostringstream类用于执行C风格的串流的输出操作。 
strstream类同时可以支持C风格的串流的输入输出操作。

C++ 中还有另外一种字符串。 std::stringstream 之于字符串，就如同 std::ostream 之于
输出文件。 std::stringstream 类以一种不同的方式封装了一块动态大小的缓冲区（事实
上，通常就是一个 std::string ），数据可以被添加至这个实体
中。 std::stringstream 是一个很好的例子，它展示了如何在类似的实现的顶层使用不同的
API 来提高代码性能。

std::string_view

string_view 可以解决 std::string 的某些问题。它包含一个指向字符串数据的无主指
针和一个表示字符串长度的值，所以它可以表示为 std::string 或字面字符串的子字
符串。与 std::string 的返回值的成员函数相比，它的 substring 和 trim 等操作更高
效。 std::string. string_view 可能会被加入到 C++14 中。有些编译器现在已经实现了
std::experimental::string_view 。 string_view 与 std::string 的接口几乎相同。
std::string 的问题在于指针是无主的。程序员必须确保每个 string_view 的生命周期
都不会比它所指向的 std::string 的生命周期长。

boost.string_ref

string_ref提供了一个“只读视图”，可以避免字符串的拷贝代价，是更好的const std：：string&

boost.string_ref就是这样一种轻量级的字符串，顾名思义，它只持有字符串的引用，没有内存拷贝成本，所以运行效率很高，是更好的const std：：string&。

string_ref是轻量级的字符串表示，功能与std：：string一样，但操作它只需要很小的成本，完全可以代替const std：：string&来提高字符串处理的效率，非常有价值。string_ref即将在C++17标准里出现，但可能采用新名字string_view。

folly::fbstring （https://github.com/facebook/folly/blob/master/folly/docs/FBString.md）

folly是一个完整的代码库，它被 Facebook 用在了他们自己的服务器上。它包含了高度
优化过的、可以直接替代 std::string 的 fbstring 。在 fbstring 的实现方式中，对于短
的字符串是不用分配缓冲区的。 fbstring 的设计人员声称他们测量到性能得到了改善。
由于这种特性，Folly 很可能非常健壮和完整。目前，只有 Linux 支持 Folly。

字符串类的工具包（http://johnpanzer.com/tsc_cuj/ToolboxOfStrings.html）

这篇发表于 2000 年的文章和代码描述了一个模板化的字符串类型，其接口与 SGI 5 的
std::string 相同。它提供了一个固定最大长度的字符串类型和一个可变长度的字符串
类型。这是模板元编程（template metaprogramming）魔法的一个代表作，但可能会让
一些人费解。对于那些致力于设计更好的字符串类的开发人员来说，这是一个切实可行
的候选类库。

C++03 表达式模板（http://craighenderson.co.uk/papers/exptempl/）

这是在 2005 年的一篇论文中展示的用于解决特定字符串连接问题的模板代码。表达
式模板重写了 + 运算符， 这样可以创建一个表示两个字符串的连接或是一个字符串和
一个字符串表达式的连接的中间类型。当表达式模板被赋值给一个字符串时，表达式
模板将内存分配和复制推迟至表达式结束，只会执行一次内存分配。表达式模版兼容
std::string 。当既存的代码中有一个连接一长串子字符串的表达式时，使用表达式模
板可以显著地提升性能。这个概念可以扩展至整个字符串库。

Better String 库（http://bstring.sourceforge.net/）

这个代码归档文件中包含了一个通用的字符串实现。它与 std::string 的实现方式不
同，但是包含一些强大的特征。如果许多字符串是从其他字符串中的一部分构建出来
的， bstring 允许通过相对一个字符串的偏移量和长度来组成一个新的字符串。我用过
以这种思想设计实现的有专利权的字符串，它们确实非常高效。在 C++ 中有一个称为
CBString 的 bstring 库的包装类。

rope （https://www.sgi.com/tech/stl/Rope.html）

这是一个非常适合在长字符串中进行插入和删除操作的字符串库。它不兼容 std::string 。

Boost 字符串算法（http://www.boost.org/doc/libs/1_60_0/doc/html/string_algo.html）

这是一个字符串算法库，它是对 std::string 的成员函数的补充。这个库是基于“查找
和替换”的概念构建起来的。

优化算法

时间开销

概括介绍了一些常用算法的时间开销以及相对于程序运行时开销的倍数。

O(1)，即常量时间

最快的算法的时间开销是常量时间；也就是说，它们的开销是固定的，完全不取决于输
入数据的规模。常量时间算法就像是“圣杯”一样，如果你找到它，它就具有难以置信
的价值，但是你也可能穷极一生都找不到它，因此要当心那些向你兜售常量时间算法的
陌生人。常量的比例可能非常高；也就是说，开销可能只是一次操作，但这次操作的时
间可能非常长。实际上，它可能是 O(n) 伪装而成的，甚至可能更糟。

O(log 2^n)

时间开销比线性更小。例如，一种可以在每一步都将输入数据分为两半的查找算法，其
时间开销是 O(log 2^ n)。时间开销比线性更小，表示这类算法的时间开销的增长速度比输
入数据规模的增长速度缓慢。因此，它们通常足够高效，以至于许多情况下（但并非所
有情况下）都无需再去寻找更快的算法。算法的实现代码也不会出现在分析器列出的昂
贵函数列表中。我们可以在程序中大量地调用 O(log 2^ n) 时间开销的算法，而不用担心这
会明显地降低程序性能。二分查找算法是一种常用的具有 O(log 2^ n) 时间开销的算法。

O(n)，即线性时间

如果一个算法的时间开销是 O(n)，那么算法需要花费的时间与输入数据的规模成正比。
这种算法称为线性时间算法。时间开销是 O(n) 的算法通常是那些从输入数据的一端向
另一端扫描，直至找到最小值或最大值的算法。线性时间算法的时间开销的增长速度与
其输入数据规模的增长速度相同。这种算法也并不昂贵，即使不断地扩大程序的输入数
据的规模，也不必担心会占用巨大的计算资源。不过，当多种线性时间算法合并在一起
时，可能会导致它们的时间开销变为 O(n ^2 ) 或者更差。因此，当一个程序对大型输入数
据集的处理时间很长时，很可能就是这个原因。

O(n log 2 ^n)

算法可能具有超线性时间开销。例如，许多排序算法会在每一步都成对地比较输入数
据，并将待排序的数据分成两部分。这些算法的时间开销是 O(nlog 2 ^n) 。虽然随着 n 的
增加，时间开销是 O(n log 2^ n) 的算法时间开销相对更大，但其增长速率是如此之慢，以
至于通常情况下即使 n 很大，使用这类算法也没有问题。当然，还是要避免在程序中无
谓地调用这类算法。

O(n^ 2 )、O(n ^3 ) 等

有些算法，包括一些比较低效的排序算法，必须将每个输入数据都与其他所有输入数据
进行比较。这类算法的时间开销是 O(n^ 2 )。这类算法的时间开销的增长速度非常快，以
至于让人不免有些担心它在 n 很大的数据集上的效率。对于有些问题，简单解决方案的
时间开销是 O(n ^2 ) 或 O(n ^3 )，而微妙一点的解决方案的速度会更快。

O(2^ n )

O(2 ^n ) 算法的时间开销增长得太快了，它们应当只被应用于 n 很小的情况下。有时，这
是没问题的。那些需要检查规模为 n 的输入数据集中的所有数据组合的算法的时间复
杂度是 O(2 ^n )。调度问题和行程规划问题，如著名的旅行商问题（Traveling Salesman
Problem）的时间开销是 O(2 ^n )。如果解决基本问题时使用的算法的时间开销是 O(2 ^n
)，
那么开发人员将面临几个难以抉择的选项：使用一种无法确保最优解决方案的启发式算
法，将解决方案限制在 n 很小的输入数据集上；或是找到其他方法加上与解决问题完全
无关的值。

查找算法的时间开销

• 线性查找算法的时间开销为 O(n)，它的开销虽然大，却极其常用。它可以用于无序表。
  即使无法对表中的关键字进行排序，只要能够比较关键字是否相等，即可使用它。对于有序表，线性查找算法可以在查找完表中的所有元素之前结束。虽然它的时间开销仍然
  是 O(n)，但是平均速度的确比原来快了一倍。
  如果允许改变表，一种将每次查找结果都移动至表头的线性查找算法在某些情况下可
  能会有更高的性能。例如， 每次在表达式中用到标识符时，都会去查找编译器中的符号
  表。如果程序中有很多形如 i = i + 1; 的表达式，这项优化就可以使线性算法有用武
  之地了。

• 二分查找算法的时间开销是 O(log 2 n)，效率更高，但它并不是可能的最好的查找算法。
  二分查找算法要求表已经按照查找关键字排序完成，不仅需要可以比较查找关键字是否
  相等，还需要可以比较它们之间的大小关系。
  在查找和排序世界中，二分查找是最常用的算法。它是一种分治法算法，通过将待排序
  元素的关键字与位于表中间的元素的关键字进行比较，来决定该元素究竟是排在中间元
  素之前还是之后，不断地将表一分为二。

• 插补查找（interpolation search）与二分查找类似，也是将有序表分为两部分，不过它用
  到了查找关键字的一些其他特性来改善分块性能。当查找关键字均匀分布时，插补查找
  的性能可以达到非常高效的 O(log log n) 。如果表很大或是测试表项的成本很高（例如
  当在一个旋转盘上时），这种改善效果是非常显著的。不过，插补查找仍然不是可能的
  最快的查找算法。

• 通过散列法，即将查找关键字转换为散列表中的数组索引，是可以以平均 O(1) 的时间
  找出一条记录的。 散列法无法工作于键值对的链表上，它需要一种特殊结构的表。它
  只需要比较散列表项是否相等即可。散列法在最差情况下的性能是 O(n)，而且它所需
  要的散列表项的数量可能比要查找的记录的数量多。不过，当表的内容是固定时（例如
  月份的名字或是编程语言的关键字），就不会发生最差情况了。

高效排序算法

排序算法	最好情况	平均情况	最差情况	空间需求	最好/最差情况的注意点
插入排序	n	n^ 2	n^ 2	1	最好情况出现在当数据集已经排序完成或是几乎排序完成时
快速排序	nlog 2^ n	n log 2^ n	n^ 2	log 2^ n	最差情况出现在数据集已经排序完成或是支点元素的原生选择（第一个 / 最后一个）
归并排序	nlog 2^ n	nlog 2^ n	nlog 2^ n	1
树形排序	nlog 2^ n	nlog 2^ n	nlog 2^ n	n
堆排序	nlog 2^ n	nlog 2^ n	nlog 2^ n	1
Timsort^ 1	n	nlog 2^ n	nlog 2^ n	n	最好情况出现在当数据集已经排序完成时
内省排序	nlog 2^ n	nlog 2^ n	nlog 2^ n	1

利用输入数据集的已知特性

如果你知道输入数据集已经排序完成或是几乎排序完成，通常情况下性能差得让人无法接
受的插入排序算法反而在这些数据上的性能很棒，达到了 O(n)。
Timsort 是一种相对较新的混合型排序算法，它在输入数据集已经排序完成或是几乎排序
完成时，性能也能达到 O(n)；而对于其他情况，最优性能则是 O(n log 2 n)。Timsort 现在已
经成为 Python 语言的标准排序算法了。
最近还出现了一种称为内省排序（introsort）的算法，它是快速排序和堆排序的混合形式。
内省排序首先以快速排序算法开始进行排序，但是当输入数据集导致快速排序的递归深度
太深时，会切换为堆排序。内省排序可以确保在最差情况下的时间开销是 O(n log 2 n) 的同
时，利用了快速排序算法的高效实现来减少平均情况下的运行时间。自 C++11 开始，内省
排序已经成为了 std::sort() 的优先实现。
另外一种最近非常流行的算法是 Flash Sort。对于抽取自某种概率分布的数据，它的性能非
常棒，达到了 O(n)。Flash Sort 是与基数排序类似，都是基于概率分布的百分位将数据排
序至桶中。Flash Sort 的一个简单的适用场景是当数据元素均匀分布时。

优化动态分配内存的变量

减少动态变量的使用

• 静态地创建类的成员变量
• 使用静态数据结构
  • 用 std::array 替代 std::vector
  • 在栈上创建大块缓冲区
  • 静态地创建链式数据结构，可以使用静态初始化的方式构建具有链式数据结构的数据
  • 在数组中创建二叉树，在数组中构建二叉树，然后不在节点中保存子节点的链接，而是利用节点的数组索引来计算子节点的数组索引。如果节点的索引是 i，那么它的两个子节点的索引分别是 2i 和 2i+1。这种方法带来的另外一个好处是，能够很快地知道父节点的索引是 i/2。对于平衡二叉树而言，数组形式的树可能会比链式树低效。
  • 用环形缓冲区替代双端队列
• 使用 std::make_shared 替代 new 表达式
• 不要无谓地共享所有权

减少动态变量的重新分配

• 预分配动态变量以防止重新分配
• 在循环外创建动态变量

移除无谓的复制

• 在类定义中禁止不希望发生的复制，将复制构造函数和赋值运算符的可见性声明为 private 可以防止它们被
  外部调用。在 C++11 中，我们可以在复制构造函数和赋值运算符后面加上 delete 关键字来达到这个目的。

• 移除函数调用上的复制，引用参数

• 移除函数返回上的复制，返回引用。
  • 为复制省略（copy elision）或是返回值优化（return value optimization，RVO）。
  • 函数内更新引用参数。

    实现移动语义

• std::swap() ：“穷人”的移动语义
  • 交换操作的强大之处在于它可以递归地应用于类的成员变量上。交换并不会复制指针所指
    向的对象，而是交换指针自身。对于那些指向大的、动态分配内存的数据结构，交换比复
    制更加高效。

• 共享所有权的实体
  • 实体无法复制。不过，一个指向实体的共享指针却可以复制。因此，虽然在移动语义出现之前无法创建 std::vector 等，但是我们可以定义一个 std::vector<std::shared_ptr> 。

• 移动语义的移动部分
  • C++ 的类型系统被扩展了，它能够从函数调用上的左值中识别出右值。如果 T 是一个类
    型，那么声明 T&& 就是指向 T 的右值引用——也就是说，一个指向类型 T 的右值的引用。函数重载的解析规则也被扩展了，这样当右值是一个实参时，优先右值引用重载；而当左值是实参时，则需要左值引用重载。特殊成员函数的列表被扩展了，现在它包含了移动构造函数和一个移动赋值运算符。这些函数是复制构造函数和赋值运算符的重载，它们接收右值引用作为参数。如果一个类实现了移动构造函数和移动赋值运算符，那么在进行初始化或是赋值实例时就可以使用高效的移动语义。std::move。

优化热点语句

• 从循环中移除代码
  • 缓存循环结束条件值
  • 使用更高效的循环语句，将一个 for 循环简化为 do 循环通常可以提高循环处理的速度。在 Visual Studio 2010 上耗时 482 毫秒，性能提高了12%；不过在 Visual Studio 2015 上却耗时 674 毫秒，性能降低了 25%。
  • 用递减替代递增
  • 从循环中移除不变性代码
  • 从循环中移除无谓的函数调用
  • 从循环中移除隐含的函数调用
    • 声明一个类实例（调用构造函数）
    • 初始化一个类实例（调用构造函数）
    • 赋值给一个类实例（调用赋值运算符）
    • 涉及类实例的计算表达式（调用运算符成员函数）
    • 退出作用域（调用在作用域中声明的类实例的析构函数）
    • 函数参数（每个参数表达式都会被复制构造到它的形参中）
    • 函数返回一个类的实例 （调用复制构造函数，可能是两次）
    • 向标准库容器中插入元素（元素会被移动构造或复制构造）
    • 向矢量中插入元素（如果矢量重新分配了内存，那么所有的元素都需要被移动构造或是复制构造）
  • 从循环中移除昂贵的、缓慢改变的调用
  • 将循环放入函数以减少调用开销
  • 不要频繁地进行操作,不要频繁地检测事件
• 从函数中移除代码
  • 简短地声明内联函数,内联是一种通过在编译时进行计算来移除多余计算的改善性能的手段。函数内联可能是最强力的代码优化武器。事实上，Visual Studio 中“调试”版本与“正式”版本（或是在 GCC 的 -d 选项与 -O 选项）的性能区别，主要源于“调试”版本关闭了函数内联。
  • 在使用之前定义函数,在第一次调用函数之前定义函数（提供函数体）给了编译器优化函数调用的机会。当编译器编译对某个函数的调用时发现该函数已经被定义了，那么编译器能够自主选择内联这次函数调用。如果编译器能够同时找到函数体，以及实例化那些发生虚函数调用的类变量、指针或是引用的代码，那么这也同样适用于虚函数。
  • 移除未使用的多态性
  • 放弃不使用的接口
  • 用模板在编译时选择实现,模板参数可以是任意类型——具有自己的一组成员函数的类类型或是具有内建运算符的基本类型。因此，存在两种接口：模板类的 public 成员，以及由在模板参数上被调用的运算符和函数所定义的接口。抽象基类中定义的接口是非常严格的，继承类必须实现在抽象基类中定义的所有函数。而通过模板定义的接口就没有这么严格了。只有参数中那些实际会被模板的某种特化所调用的函数才需要被定义。
  • 避免使用PIMPL惯用法,采用将BigClass 分解，使接口功能更加集中的方法，可能与 PIMPL 同样有效。
  • 移除对DDL的调用,一种改善函数调用性能的方式是不使用 DLL，而是使用对象代码库并将其链接到可执行程序上。
  • 使用静态成员函数取代成员函数,每次对成员函数的调用都有一个额外的隐式参数：指向成员函数被调用的类实例的 this 指针。通过对 this 指针加上偏移量可以获取类成员数据。虚成员函数必须解引 this 指针来获得虚函数表指针。有时，一个成员函数中的处理仅仅使用了它的参数，而不用访问成员数据，也不用调用其他的虚成员函数。在这种情况下， this 指针没有任何作用。
  • 将虚析构函数移至基类中
• 优化表达式
  • 简化表达式，y = axxx + bxx + cx + d优化为y = (((ax + b)x) + c)*x + d;
  • 将常量组合在一起，seconds = 24 60 60 days;或是seconds = days (24 60 60);编译器会计算表达式中的常量部分，产生类似下面的表达式：seconds = 86400 days;但是，如果程序员这样写：seconds = 24 days 60 60;编译器只能在运行时进行乘法计算了。
  • 使用更高效的运算符，位移运算和加法运算替代乘法。例如，整数表达式 x9 可以被重写为x8+x*1 ，进而可以重写为 (x<<3)+x 。
  • 使用整数计算替代浮点型计算
  • 双精度类型可能会比浮点型更快
  • 用闭形式替代迭代计算
• 优化控制流程惯用法
  • 用 switch 替代 if-else　if-else
  • 用虚函数替代 switch 或 if
  • 使用无开销的异常处理
    • 在 C++11 中引入了一种新的异常规范，称为 noexcept 。声明一个函数为 noexcept 会告诉编译器这个函数不可能抛出任何异常。如果这个函数抛出了异常，那么如同在 throw() 规范中一样， terminate() 将会被调用。

判断一个整数是否是 2 的幂的闭形式

inline bool is_power_2_closed(unsigned n) {
    return ((n != 0) && !(n & (n - 1)));
}

int isPowerOfTwo (unsigned int x)
{
  return ((x != 0) && ((x & (~x + 1)) == x));
}

Rick Regan 在他的网页（http://www.exploringbinary.com/ten-ways-
to-check-if-an-integer-is-a-power-of-two-in-c/）上记录了 10 种方法

Hacker’s Delight ：http://hackersdelight.org/

优化查找和排序

lower_bound
返回指向第一个不小于给定值的元素的迭代器

upper_bound
返回指向第一个大于给定值的元素的迭代器

binary_search
判断一个元素是否在区间内

equal_range
返回匹配特定键值的元素区间

以 C 风格的 char* 作为键、lambda 表达式作为比较函数的 map

auto comp = [](char const* p1, char const* p2) {
    return strcmp(p1,p2)<0;
};
std::map<char const*,
    unsigned,
    decltype(comp)> table(comp);    

这段示例代码中使用了 C++11 中的 decltype 关键字。 map 的第三个参数是一个类
型。名字 comp 是一个变量，而 decltype(comp) 则是变量的类型。lambda 表达式的类型没
有名字，每个 lambda 表达式的类型都是唯一的，因此 decltype 是获得 lambda 表达式的类
型的唯一方法。

std::find()： 功能如其名，O(n)时间开销

kv* result=std::find(std::begin(names), std::end(names), key);

find() 函数的一种变化形式是 find_if() ，它接收比较函数作为第四个参数。这里开发人
员不用在 find() 的作用域中定义 operator==() ，而是可以编写一个 lambda 表达式作为比
较函数。lambda 表达式只接收一个参数——要进行比较的表元素。因此，lambda 表达式必
须从环境中捕捉键值。

std::binary_search()： 不返回值

标准库算法 binarysearch() 返回一个 bool 值，表示键是否存在于有序表中。非常奇
怪的是，标准库却没有提供配套的返回匹配的表元素的函数。因此， find() 和 binary
search() 虽然从名字上看都像是我们要找的解决方法，但其实不然。
如果程序只是想知道一个元素是否存在于表中，而不是找到它的值，那么我们可以使用
binary_search() 。

使用 std::equal_range() 的二分查找

auto res = std::equal_range(std::begin(names),
                            std::end(names),
                            key);
kv *result = (res.first == res.second)
             ? std::end(names)
             : res.first;

使用 std::lower_bound() 的二分查找

kv *result = std::lower_bound(std::begin(names),
                              std::end(names),
                              key);
if (result != std::end(names) && key < *result.key)
    result = std::end(names);

自己编写二分查找法

kv *find_binary_lessthan(kv *start, kv *end, char const *key)
{
    kv *stop = end;
    while (start < stop)
    {
        auto mid = start + (stop - start) / 2;
        if (*mid < key)  // 查找右半部分[mid+1,stop)
        {
            start = mid + 1;
        }
        else   // 查找左半部分[start,mid)
        {
            stop = mid;
        }
    }
    return (start == end || key < *start) ? end : start;
}

使用 strcmp() 自己编写二分查找法

kv *find_binary_3(kv *start, kv *end, char const *key)
{
    auto stop = end;
    while (start < stop)
    {
        auto mid = start + (stop - start) / 2;
        auto rc = strcmp(mid->key, key);
        if (rc > 0)
        {
            stop = mid;
        }
        else if (rc < 0)
        {
            start = mid + 1;
        }
        else
        {
            return mid;
        }
    }
    return end;
}

优化键值对散列表中的查找

C++ 定义了一个称为 std::hash 的标准散列函数对象。 std::hash 是一个模板，为整数、浮
点数据、指针和 std::string 都提供了特化实现。同样适用于指针的未特化的 std::hash
的定义会将散列类型转换为 size_t ，然后随机设置它的各个位的值。

使用 std::unordered_map 进行散列

std::unordered_map 使用的默认散列函数是模板函数对象 std::hash 。由于该模板为
std::string 提供了特化实现，因此我们无需显式地提供散列函数。

auto it = table.find(key);

GNU 计划（还有其他项
目）构建了一个称为 gperf（http://www.gnu.org/software/gperf/）的命令行工具，它所生成
的完美散列函数通常也是最小散列函数。

使用C++标准库优化排序

C++ 标准库提供了两种能够高效地对序列容器进行排序的标准算法—— std::sort() 和 std::stable_sort() 。

优化数据结构

理解标准库容器

序列容器

序列容器 std::string 、 std::vector 、 std::deque 、 std::list 和 std::forward_list 中元素的顺序与它们被插入的顺序相同。因此，每个容器都有一头一尾。所有的序列容器都能够插入元素。除了 std::forward_list 外，所有的序列容器都有一个具有常量时间性能开销的成员函数能够将元素推入至序列容器的末尾。不过，只有 std::deque 、 std::list 和std::forward_list 能够高效地将元素推入至序列容器的头部。

关联容器

有 四 种 有 序 关 联 容 器： std::map 、 std::multimap 、 std::set 和
std::multiset 。有序关联容器要求必须对键（ std::map ）或是元素自身（ std::set ）定义能够对它们进行排序的 operator<() 等。有序关联容器的实现是平衡二叉树，因此我们无
需对有序关联容器进行排序。遍历它们时会按照排序关系的顺序访问它们中的元素。插入或是移除元素的分摊开销是 O(log 2 n)，其中 n 是容器中元素的数量。

C++11 又给我们带来了四种无序关联容器： std::unordered_map 、 std::unordered_multimap 、std::unordered_set 和 std::unordered_multiset 。无序关联容器只要求对键（ std::unordered_map ）或是元素（ std::unordered_set ）定义了相等关系即可。无序关联容器的实现方式是散列表。

std::vector 与 std::string

要想确保在所有版本的 C++ 中都能释放 vector 的内存，可以使用以下技巧：

std::vector<Foo> x;
...
vector<Foo>().swap(x);

这段语句会构造一个临时的空的矢量，将它的内容与矢量 x 交换，接着删除这个临时矢量，这样内存管理器会回收所有之前属于 x 的内存。

std::vector 中的插入与删除

如果数据是在另外一个容器中，使用 std::vector::insert() 可以将它复制到 vector 中：

std::vector<kvstruct> test_container, random_vector;
...
test_container.insert(
    test_container.end(),
    random_vector.begin(),
    random_vector.end());

或

std::vector<kvstruct> test_container, random_vector;
...
test_container.reserve(nelts);
for (auto it = random_vector.begin(); it != random_vector.end(); ++it)
    test_container.push_back(*it);

遍历 std::vector

std::vector<kvstruct> test_container;
...
unsigned sum = 0;
for (auto it = test_container.begin(); it != test_container.end(); ++it)
    sum += it->value;
std::vector<kvstruct> test_container;
...
unsigned sum = 0;
for (unsigned i = 0; i < nelts; ++i)
    sum += test_container.at(i).value;
std::vector<kvstruct> test_container;
...
unsigned sum = 0;
for (unsigned i = 0; i < nelts; ++i)
    sum += test_container[i].value;

下标版本更加高效

std::deque

std::deque 是一种专门用于创建“先进先出”（FIFO）队列的容器。在队列两端插入和删除元素的开销都是常量时间。下标操作也是常量时间。它的迭代器与 std::vector 一样，都是随机访问迭代器，因此对 std::deque 进行排序的时间开销是 O(n log 2^n)。

以下是三种使用 push_back() 将元素从 vector 复制到 deque 中的方法：

std::deque<kvstruct> test_container;
std::vector<kvstruct> random_vector;
...
for (auto it = random_vector.begin(); it != random_vector.end(); ++it)
    test_container.push_back(*it);
for (unsigned i = 0; i < nelts; ++i)
    test_container.push_back(random_vector.at(i));
for (unsigned i = 0; i < nelts; ++i)
    test_container.push_back(random_vector[i]);

迭代器版本最快

遍历 std::deque

有意思的是，对于 deque ，基于迭代器的遍历更快，而对于 vector ，基于下标的遍历则更快。但是遍历 deque 的最快方法的性能开销是遍历 vector 的最快方法的两倍，与之前的趋势相同。

std::list

最快的查找 list 的方法是使用 std::find() ，它的时间开销是 O(n)。

插入删除与遍历使用迭代器比较快

对 std::list 排序

std::list 上的迭代器是双向迭代器，不如 std::vector 的随机访问迭代器功能强大。这些
迭代器的一个很特别的特性是，找到两个双向迭代器之间的距离或是元素个数的性能开销是 O(n)。因此，使用 std::sort() 对 std::list 排序的时间开销是 O(n ^2 )。编译器的编译结果仍然是对 list 调用一次 std::sort() ，但性能可能远比开发人员所期待的差。幸运的是， std::list 有一种内置的更高效的排序方法，其时间开销是 O(n log 2^ n)。使用std::list 内置的 sort() 函数对 list 排序耗时 23.2 毫秒，只比排序相同的 vector 慢了25%。

std::forward_list

单向链表，其他方面跟list差不多

std::map 与 std::multimap

所有的提示都比无提示更快，也都比不带提示版本的 insert() 和未排序的输入数据集快。

优化“检查并更新”惯用法

一种常用的编程惯用法是在程序中先检查某个键是否存在于 map 中，然后根据结果进行相应的处理。当这些处理涉及插入或是更新键所对应的值时，那么就可能进行性能优化。理解性能优化的关键在于，由于需要先检查键是否存在于 map 中，然后再找到插入位置，因此 map::find() 和 map::insert() 的时间开销都是 O(log 2 n)。这两种操作都会遍历 map 的二叉树数据结构中的相同的节点：

iterator it = table.find(key); // O(log n)
if (it != table.end()) {
    // 找到key的分支
    it->second = value;
}
else {
    // 没有找到key的分支
    it = table.insert(key, value); // O(log n)
}

如果程序程序能够得到第一次查找的结果，那么就能够将其作为对 insert() 的提示，将插入操作的时间开销提高到 O(1)。取决于程序的需求，有两种方法能够实现这个惯用法。如果只要知道是否找到了键即可，那么可以使用返回 pair 的版本的 insert() 。在被返回的pair 中保存的是一个指向找到或是插入的元素的迭代器以及一个布尔型变量，当这个布尔型变量为 true 时表示该元素被找到了，而当这个布尔型变量为 false 时表示该元素是被插入的。当程序在检查元素是否存在于 map 之前知道如何初始化元素，或是更新值的性能开销并不大时，这种方法非常有效：

std::pair<value_t, bool> result = table.insert(key, value);
if (result.second) {
    // k找到key的分支
}
else {
    // 没有找到key的分支
}

第二种方法是通过调用 lower_bound() 或是 upper_bound() 找到键或是插入位置作为 C++98风格或是 C++11 风格的提示。 lower_bound() 会返回一个指向 map 中那些键比带查找的键小的所有元素中最小的元素或是指向 end 的迭代器。当要插入键时，这个迭代器就是插入位置提示；而当要更新已经存在的元素时，它指向的就是该元素的键。这种方法对于待插入的元素没有任何要求：

iterator it = table.lower_bound(key);
if (it == table.end() || key < it->first) {
    // 找到key的分支
table.insert(it, key, value);
}
else {
    // 没有找到key的分支
    it->second = value;
}

std::set 与 std::multiset

std::set 和 std::multiset 使用了与 std::map 相同的数据结构

std::unordered_map 与 std::unordered_multimap

unordered_map 的构造是昂贵的。它包含了为表中所有元素动态分配的节点，另外还有一个会随着表的增长定期重新分配的动态可变大小的桶数组。因此，要想改善它的查找性能，需要消耗相当多的内存。每次桶数组重新分配时，迭代器都会失效。不过，只有在删除元素时，指向元素节点的引用才会失效。

unordered_map 中元素的数量就是它的大小。计算出的 size / buckets 比例称为负载系数（load factor）。负载系数大于 1.0 表示有些桶有一条多个元素链接而成的元素链，降低了查询这些键的性能（换言之，非完美散列）。在实际的散列表中，即使负载系数小于1.0，键之间的冲突也会导致形成元素链。负载系数小于 1.0 表示存在着未被使用，但却在unordered_map 的骨干数组中占用了存储空间的桶（换言之，非最小散列）。当负载系数小于 1.0 时，(1 – 负载系数 ) 的值是空桶数量的下界，但是由于散列函数可能非完美，因此未使用的存储空间通常更多。

使用迭代器遍历 unordered_map 相对比较高效.

其他数据结构

boost::circular_buffer （http://www.boost.org/doc/libs/1_60_0/doc/html/circular_buffer.html）
在许多方面都与 std::deque 类似，但更加高效。

Boost.Container （http://www.boost.org/doc/libs/1_60_0/doc/html/container.html）
标准库容器的各种变种，包括一种稳定的 vector （一种发生重新分配也不会造成迭代器失效的 vector ）；一组作为 std::vector 的容器适配器实现的 map/multimap/set/multiset；
一个长度可变但最大长度固定的静态 vector ，以及一个当只有几个元素时具有最优行为的 vector 。

dynamic_bitset （http://www.boost.org/doc/libs/1_60_0/libs/dynamic_bitset/dynamic_bitset.html）
看起来像是位组成的 vector 。

Fusion（http://www.boost.org/doc/libs/1_60_0/libs/fusion/doc/html/）
元组上的容器和迭代器。

Boost 图形库（BGL，http://www.boost.org/doc/libs/1_60_0/libs/graph/doc/index.html）
适用于遍历图形的算法和数据结构。

boost.heap （http://bit.ly/b-heap/）
比简单 std::priority_queue 容器适配器具有更好性能和更微妙行为的优先队列。

Boost.Intrusive（http://www.boost.org/doc/libs/1_60_0/doc/html/intrusive.html）
提供了侵入式容器（依赖于显式地包含链接的节点类型的容器）。侵入容器的重点是提高热点代码的性能。这个库包含单向和双向链表、关联容器、无序关联容器和各种显式平衡树实现。在大多数容器中都加入了 make_shared 、移动语义和 emplace() 成员函数，减少了对侵入式容器的需求。

boost.lockfree （http://www.boost.org/doc/libs/1_60_0/doc/html/lockfree.html）
无锁（lock-free）和无等待（wait-free）的队列和栈。

Boost.MultiIndex（http://www.boost.org/doc/libs/1_60_0/libs/multi_index/doc/index.html）
有多个具有不同行为的索引的容器。

毫无疑问，Boost 中还有其他容器类。

对标准库容器类的另一个巨大贡献来自于游戏公司艺电（Electronic Arts，EA），他们开源了名为“EASTL”（http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2271.html）的标准库容器类。艺电对标注库容器类的贡献包括：

• 一个更简单和更合理的 Allocator 的定义
• 对容器提供了更有力的保证，包括保证容器不会调用内存管理器，除非程序将元素放到容器中具有更多的可编程性的 std::deque
• 一组与 Boost 所提供的容器类似的容器

创建一个由无重复的 kvstruct 实例组成的 vector

# include <random>
// 创建一个由count个无重复的kvstruct实例组成的vector
void build_rnd_vector(std::vector<kvstruct> &v, unsigned count)
{
    std::default_random_engine e;
    std::uniform_int_distribution<unsigned> d(count, 10 * count - 1);
    auto randomizer = std::bind(d, e);
    std::set<unsigned> unique;
    v.clear();
    while (v.size() < count)
    {
        unsigned rv = randomizer();
        if (unique.insert(rv).second == true)   // 插入元素
        {
            kvstruct keyvalue(rv);
            v.push_back(keyvalue);
        }
    }
}

sort和stable_sort的不同之处

这两个函数的原理都是快速排序，时间复杂度在所有排序中最低，为O(nlog2n) ;

stable_sort 和 sort的区别在于 前者作排序可以使原来的”相同”的值在序列中的相对位置不变，这个应用在数组里面不受影响，当函数参数传入的是结构体时，会发现两者之间的明显区别；

优化I/O

读取文件至字符串中

bool stream_read_sgetn(std::istream &f, std::string &result)
{
    std::streamoff len = stream_size(f);
    if (len == -1)
        return false;
    result.resize (static_cast<std::string::size_type>(len));
    f.rdbuf()->sgetn(&result[0], len);
    return true;
}

bool stream_read_string(std::istream &f, std::string &result)
{
    std::streamoff len = stream_size(f);
    if (len == -1)
        return false;
    result.resize (static_cast<std::string::size_type>(len));
    f.read(&result[0], result.length());
    return true;
}

bool stream_read_array(std::istream &f, std::string &result)
{
    std::streamoff len = stream_size(f);
    if (len == -1)
        return false;
    std::unique_ptr<char> data(new char[static_cast<size_t>(len)]);
    f.read(data.get(), static_cast<std::streamsize>(len));
    result.assign(data.get(), static_cast<std::string::size_type>(len));
    return true;
}

写文件stream_write_line_noflush() 更快

void stream_write_line_noflush(std::ostream &f,
                               std::string const &line)
{
    f << line << "\n";
}

要么以 f.flush() 结束 stream_write_line_noflush() ，要么关闭流，这样最后一个写满数据的缓冲区中的信息才会被输出。

从 std::cin 读取和向 std::cout 中写入

当从标准输入中读取数据时， std::cin 是与 std::cout 紧密联系在一起的。

关于 std::cin 和 std::cout 的另外一件需要知道的事情的是，C++ 流在概念上是与 C 的
FILE* 对象的 stdin 和 stdout 连接在一起的。这让程序能够同时使用 C++ 和 C 的 I/O 语句，并使得输入或输出的交叉在某种程度上有了意义。 std::cout 与 stdout 的连接是实现定义（implementation-defined）的。多数标准库实现默认都会直接将 std::cout 发送至stdout 。 stdout 默认是按行缓存的，在 C++ 的输入输出流中没有这种方式。每当 stdout
遇到新的一行，它都会刷新缓冲区。切断连接有助于改善性能。调用静态成员函数 td::ios_base::sync_with_stdio(false) 可以打破这种连接，改善性能，但代价是如果程序同时使用了 C 和 C++ I/O 函数，那么交叉行为将变得不可预测。

优化并发

最著名的几种并发形式如下:

时间分割（time slicing）

这是操作系统中的一个调度函数。在时间分割中，操作系统会维护一份当前正在执行的
程序和系统任务的列表，并为每个程序都分配时间块。任何时候，当一个程序等待事件
或是资源时，操作系统会将程序从可运行程序列表中移除，并将它所使用的处理器资源
共享给其他程序。
操作系统是依赖于处理器和硬件的。它会使用计时器和周期性的中断来调整处理器的调
度。C++ 程序并不知道它被时间分割了。

虚拟化（Virtualization）

一种常见的虚拟化技术是让一个称为“hypervisor”的轻量级操作系统将处理器的时
间块分配给客户虚拟机。客户虚拟机（VM）包含一个文件系统镜像和一个内存镜
像，通常这都是一个正在运行一个或多个程序的操作系统。当 hypervisor 运行客户虚
拟机后，某些处理器指令和对内存区域的某些访问会产生 Trap（陷入），并将它下传给
hypervisor，这将允许 hypervisor 竞争 I/O 设备和其他硬件资源。另外一种虚拟化技术是
使用传统操作系统作为客户虚拟机的主机。如果主机和客户虚拟机上运行的操作系统相
同，那么就能够使用操作系统的 I/O 工具更加高效地竞争 I/O 资源。
虚拟化技术的优点如下。

• 客户虚拟机是在运行时被打包为磁盘文件的，因此我们能够对客户虚拟机设置检查点（checkpoint），保存客户虚拟机，加载和继续执行客户虚拟机，以及在多台主机上运行客户虚拟机。
• 只要资源允许，我们能够并发地运行多台客户虚拟机。hypervisor 会与计算机虚拟内存保护硬件共同协作，隔离这些客户虚拟机。这使得硬件能够被当作商品租借出去并计时收费。
• 我们能够配置客户虚拟机使用主机的一部分资源（物理内存、处理器核心）。计算资源能够根据每台客户虚拟机上正在运行的程序的需求“量体裁衣”，确保并发地在同一硬件上运行的多台虚拟机保持性能稳定，并防止它们之间意外地发生交互。

与传统的时间分割一样，C++ 程序同样不知道它运行于 hypervisor 下的一台客户虚拟机中。
C++ 程序也许会间接地注意到它们所使用的资源受到了限制。虚拟化技术与 C++ 程序设计
是有关的，因为它既能够限制程序所消耗的计算资源，也需要让程序知道哪些资源才是真
正可用的。

容器化（containerization）

容器化与虚拟化的相似之处在于，容器中也有一个包含了程序在检查点的状态的文件系
统镜像和内存镜像；不同之处在于容器主机是一个操作系统，这样能够直接地提供 I/O
和系统资源，而不必通过 hypervisor 去较低效地竞争资源。
容器化具有与虚拟化相同的优点（打包、配置和隔离性），同时它在某种程度上更
加高效。对于运行于容器中的 C++ 程序，容器化是不可见的。容器化与 C++ 程序相关的原因与
虚拟化相同。

对称式多处理（symmetric multiprocessing）

对称式多处理器（symmetric multiprocessor）是一种包含若干执行相同机器代码并访问
相同物理内存的执行单元的计算机。现代多核处理器都是对称式多处理器。当前正在执
行的程序和系统任务能够运行于任何可用的执行单元上，尽管选择执行单元可能会给性
能带来影响。
对称式多处理器使用真正的硬件并发执行多线程控制。如果对称式多处理器有 n 个执行
单元，那么一个计算密集型程序的执行时间最多可以被缩短为 1/n。

同步多线程（simultaneous multithreading）

有些处理器的硬件核心有两个（或多个）寄存器集，可以相应地执行两条或多条指令
流。当一条指令流停顿时（如需要访问主内存），处理器核心能够执行另外一条指令流
上的指令。具有这种特性的处理器核心的行为就像是有两个（或多个）核心一样，这
样一个“四核处理器”就能够真正地处理八个硬件线程。

多进程

进程是并发的执行流，这些执行流有它们自己的受保护的虚拟内存空间。进程之间通过
管道、队列、网络 I/O 或是其他不共享的机制
进行通信。线程使用同步原语或是通过
等待输入（即发生阻塞直至输入变为可用状态）来进行同步。
进程的主要优点是操作系统会隔离各个进程。如果一个进程崩溃了，其他进程依然活
着，尽管它们可能什么也不会做。
进程最大的缺点是它们有太多的状态：虚内存表、多执行单元上下文、所有暂停线程的
上下文。进程的启动、停止以及互相之间的切换都比线程慢。
C++ 无法直接操作进程。通常，一个 C++ 程序的表现形式就是操作系统中的一个进程。
C++ 中没有任何工具能够操作进程，因为并非所有的操作系统都有进程的概念。有些小
型处理器会为程序分割时间，但不会隔离程序，所以这些程序看起来更像是线程。

分布式处理（distributed processing）

分布式处理是指程序活动分布于一组处理器上。这些处理器可以不同。相比于处理器的
处理速度，它们之间的通信速度非常慢。一组通过 TCP/IP 协议进行通信的云服务器的
实例就是一种分布式处理。在一台单独的 PC 上也存在着分布式处理，例如将驱动器分
流（offload）给运行于磁盘驱动器和网卡之上的处理器。另一个例子是将图形任务分流
给图形处理单元（GPU）中的多种专用处理器。在典型的分布式处理结构中，数据通过管道或网络流向进程，进程在对输入数据进行处
理后再将数据放入到下一段管道中。这种模型与 Unix 的命令行管道一样古老，使得相
对重量级的进程也能够高效地运行。管道中的进程具有很长的生命周期，这样能够避免
启动进程的开销。进程能够连续地对工作单元进行处理，因此根据输入数据的情况，它
们可能会使用整个分割时间。最重要的是，进程之间不会共享内存或是同步，因此它们
能够全速运行。
尽管 C++ 中没有进程的概念，但 C++ 开发依然与分布式处理有关，因为它会影响程序
设计和程序结构。共享内存不会超过几个线程。有些并发方案提倡完全放弃共享内存。
分布式处理系统通常都会自然而然地被分解为子系统，形成模块化的、易理解的和能够
重新配置的体系结构。

线程

线程是进程中的并发执行流，它们之间共享内存。线程使用同步原语进行同步，使用共
享的内存地址进行通信。
与进程相比，线程的优点在于消耗的资源更少，创建和切换也更快。
不过，线程也有几个缺点。由于进程中的所有线程都共享相同的内存空间，一个线程写
入无效的内存地址可能会覆盖掉其他线程的数据结构，导致线程崩溃或出现不可预测的
行为。此外，访问共享内存远比访问不共享的内存慢，并且内存中保存的内容必须在线
程之间同步，否则线程将会难以解释这些内容。
大多数操作系统都有自己的支持多线程的库。一直到现在，具有丰富的并发开发经验
的 C++ 开发人员一直都使用原生线程库或是提供了基本线程服务功能的跨平台解决方
案——POSIX 线程库。

任务

任务是在一个独立线程的上下文中能够被异步调用的执行单元。在基于任务的并发中，
任务和线程是独立地和显式地被管理的，这样可以将一个任务分配给一个线程去执行。
相比之下，在基于线程的并发中，线程以及在线程上运行的可执行代码是作为一个单元
被管理的。
基于任务的并发构建于线程之上，因此任务也具有线程的优点和缺点。
基于任务的并发的另外一个优势是，处于活动状态的软件线程的数量能够与硬件线程的
数量匹配起来，这样线程就能运行得非常高效。程序能够设置待执行任务的优先级和队
列。相比之下，在基于线程的系统中，操作系统以一种不透明的和依赖于操作系统的方
式设置线程优先级。
任务的灵活性的代价比应用程序的复杂性更大。程序必须实现对任务设置优先级或是排
序任务的方法。另外，程序还必须管理任务运行的基础——线程池。

C++并发方式

线程

头文件提供了 std::thread 模板类，它允许程序创建线程对象作为操作系统自
身的线程工具的包装器。 std::thread 的构造函数接收一个可调用对象（函数指针、函数
对象、lambda 或是绑定表达式）作为参数，并会在新的软件线程上下文中执行这个对象。
C++ 使用可变模板参数转发“魔法”调用带有可变参数列表的函数，而底层操作系统的线
程调用通常接收一个指向带有 void* 参数的 void 函数的指针作为参数。

promise 和 future

C++ 中的 std::promise 模板类和 std::future 分别是一个线程向另外一个线程发送和接收
消息的模板类。 promise 和 future 允许线程异步地计算值和抛出异常。 promise 和 future
共享一个称为共享状态（shared state）的动态分配内存的变量，这个变量能够保存一个已
定义类型的值，或是在标准包装器中封装的任意类型的异常。一个执行线程能够在 future
上被挂起，因此 future 也扮演着同步设备的角色。C++ 头文件中包含 promise 和 future 的功能。 std::promise 模板的实例允许线程
将共享状态设置为一个指定类型的值或是一个异常。发送线程并不会等待共享状态变为可
读状态，它能够立即继续执行。
promise 的共享状态直到被设置为一个值或是一个异常后才就绪。共享状态必须且只能被
设置一次，否则会发生以下情况。

• 如果某个线程多次试图将共享状态设置为一个值或是一个异常，那么共享状态将会被设置为 std::future_error 异常，错误代码是 promise_already_satisfied ，而且共享状态变为就绪状态，为释放所有在 promise 上等待的 future 做好准备。
• 如果某个线程从来没有将共享状态设置为一个值或是一个异常，那么在 promise 被销毁时，它的析构函数会将共享状态设置为 std::future_error 异常，错误代码是 broken_promise ，而且共享状态变为就绪状态，为释放所有在 promise 上等待的 future 做好准备。要想获得这个有用的错误提示，我们必须在线程的可调用对象中销毁 promise 。

std::future 允许线程接收保存在 promise 的共享状态中的值或是异常。 future 是一个同步
原语，接收线程会在对 future 的 get() 成员函数的调用中挂起，直到相应的 promise 设置
了共享状态的值或是异常，变为就绪状态为止。
在被构造出来或是通过 promise 赋值后， future 才是有效的。在 future 无效时，接收线程
是无法在 future 上挂起的。 future 必须在发送线程被执行之前通过 promise 构造出来。否
则，接收线程会试图在 future 变为有效之前在它上面挂起。
promise 和 future 无法被复制。它们是代表特定通信集结点的实体。我们能构造和移动构
造它们，可以将一个 promise 赋值给一个 future 。理想情况下， promise 是在发送线程中
被创建的，而 future 则是在接收线程中被创建的。有一种编程惯用法是在发送线程中创建
promise ，然后使用 std::move(promise) 将其作为右值引用传递给接收线程，这样它的内
容就会被移动到属于接收线程的 promise 中。开发人员可以使用 std::async() 来做到这一
点。我们也可以通过指向发送线程的引用来传递 promise 。

promise 、 future 和线程

void promise_future_example()
{
    auto meaning = [](std::promise<int> &prom)
    {
        prom.set_value(42); // 计算"meaning of life"
    };
    std::promise<int> prom;
    std::thread(meaning, std::ref(prom)).detach();
    std::future<int> result = prom.get_future();
    std::cout << "the meaning of life: " << result.get() << "\n";
}

异步任务

C++11 提供了将可调用对象包装为任
务，并在可复用的线程上调用它的 async() 模板函数。在 C++ 标准库 头文件中定义了任务。 std::packaged_task 模板类能够包装任意
的可调用对象（可以是函数指针、函数对象、lambda 表达式或是绑定表达式），使其能够
被异步调用。 packaged_task 自身也是一个可调用对象，它可以作为可调用对象参数传递
给 std::thread 。与其他可调用对象相比，任务的最大优点是一个任务能够在不突然终止
程序的情况下抛出异常或返回值。任务的返回值或抛出的异常会被存储在一个可以通过
std::future 对象访问的共享状态中。

packaged_task 和线程

void promise_future_example_2()
{
    auto meaning = std::packaged_task<int(int)>(
                       [](int n)
    {
        return n;
    });
    auto result = meaning.get_future();
    auto t = std::thread(std::move(meaning), 42);
    std::cout << "the meaning of life: " << result.get() << "\n";
    t.join();
}

任务和 async()

void promise_future_example_3()
{
    auto meaning = [](int n)
    {
        return n;
    };
    auto result = std::async(std::move(meaning), 42);
    std::cout << "the meaning of life: " << result.get() << "\n";
}

互斥量

头文件包含了四种互斥量模板。

std::mutex

一种简单且相对高效的互斥量。在 Windows 上，这个类会首先尝试繁忙等待策略，如
果它无法很快获得互斥量，就会改为调用操作系统。

std::recursive_mutex

一种线程能够递归获取的互斥量，就像函数的嵌套调用一样。由于该类需要对它被获取
的次数计数，因此可能稍微低效。

std::timed_mutex

允许在一定时间内尝试获取互斥量。要想在一定时间内尝试获取互斥量，通常需要操作
系统的介入，导致与 std::mutex 相比，这类互斥量的延迟显著地增大了。

std::recursive_timed_mutex

一种能够在一定时间内递归地获取的互斥量，开销也非常昂贵。

在 C++14 中加入的 头文件包含了对共享互斥量——也被称为 reader/writer
互斥量——的支持。

std::shared_timed_mutex

一种同时支持定时和非定时获取互斥量的共享互斥量。

std::shared_mutex

一个更加简单的共享互斥量，按照计划在 C++17 中会被加入

锁

在 头文件中有两个锁模板。

std::lock_guard

一种简单的 RAII 锁。在这个类的构造过程中，程序会等待直到获得锁；而在析构过程
中则会释放锁。这个类的预标准实现通常被称为 scope_guard 。

std::unique_lock

一个通用的互斥量所有权类，提供了 RAII 锁、延迟锁、定时锁、互斥量所有权的转移
和条件变量的使用。
在 C++14 的 头文件中加入了共享互斥量的锁。

std::shared_lock

共享（reader/writer）互斥量的一个互斥量所有权类。它提供了 std::unique_lock 的所
有复杂特性，另外还有共享互斥量的控制权。

条件变量

C++ 在 头文件中提供了条件变量的两种实现方式。它们之间的区别
在于所接收的参数锁的一般性。

std::condition_variable

最高效的条件变量，它需要使用 std::unique_lock 来锁住互斥量。

std::condition_variable_any

一种能够使用任何 BasicLockable 锁（即任何具有 lock() 和 unlock() 成员函数的锁）
的条件变量。该条件变量可能会比 std::condition_variable 低效。

使用条件变量实现的简单的生产者和消费者

void cv_example()
{
    std::mutex m;
    std::condition_variable cv;
    bool terminate = false;
    int shared_data = 0;
    int counter = 0;
    auto consumer = [&]()
    {
        std::unique_lock<std::mutex> lk(m);
        do
        {
            while (!(terminate || shared_data != 0))
                cv.wait(lk);
            if (terminate)
                break;
            std::cout << "consuming " << shared_data << std::endl;
            shared_data = 0;
            cv.notify_one();
        }
        while (true);
    };
    auto producer = [&]()
    {
        std::unique_lock<std::mutex> lk(m);
        for (counter = 1; true; ++counter)
        {
            cv.wait(lk, [&]()
            {
                return terminate || shared_data == 0;
            });
            if (terminate)
                break;
            shared_data = counter;
            std::cout << "producing " << shared_data << std::endl;
            cv.notify_one();
        }
    };
    auto p = std::thread(producer);
    auto c = std::thread(consumer);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    {
        std::lock_guard<std::mutex> l(m);
        terminate = true;
    }
    std::cout << "total items consumed " << counter << std::endl;
    cv.notify_all();
    p.join();
    c.join();
    exit(0);
}

共享变量上的原子操作

C++ 标准库 头文件提供了用于构建多线程同步原语的底层工具：内存栅栏和原子
性的加载与存储。

内存栅栏

std::atomic 的许多成员函数都会接收一个可选参数 memory_order ，它会选择一个围绕在操
作上下的栅栏。如果没有提供 memory_order 参数，它的默认值是 memory_order_acq_rel 。
这样会选择使用永远安全但开销昂贵的完全栅栏。当然，还有其他许多受限制的栅栏可
选，不过最好是由知识渊博的开发专家来做出决定。

内存栅栏通过多个硬件线程的高速缓存来同步主内存。通常，在一个线程与另一个线程同
步时，这两个线程上都会加上内存栅栏。在 C++ 中能够使用以下内存栅栏。

memory_order_acquire

你可以将 memory_order_acquire 理解为“通过其他线程完成所有工作”的意思。它确保
随后的加载不会被移动到当前的加载或是前面的加载之前。自相矛盾的是，它是通过等
待在处理器和主内存之间的当前的存储操作完成来实现这一点的。如果没有栅栏，当一
次存储还处于处理器和主内存之间，它的线程就在相同的地址进行了一次加载时，该线
程会得到旧的数据，仿佛这次在程序中加载被移动到了存储之前。
memory_order_acquire 可能会比默认的完全栅栏高效。例如，在原子性地读取在繁忙等
待 while 循环中的标识位时，可以使用 memory_order_acquire 。

memory_order_release

你可以将 memory_order_release 理解为“通过这个线程将所有工作释放到这个位置”的
意思。它确保这个线程完成的之前的加载和存储不会被移动到当前的存储之后。它是通
过等待这个线程内部的当前存储操作完成来实现这一点的。
memory_order_release 可能会比默认的完全栅栏高效。例如，在自定义的互斥量的尾部
设置标识位时，可以使用 memory_order_release 。

memory_order_acq_rel

这会结合之前的两种“确保”，创建一个完全栅栏。

memory_order_consume

memory_order_consume 是 memory_order_acquire 的一种弱化（但更快）的形式，它只要
求当前的加载发生在其他依赖这次加载数据的操作之前。例如，当一个指针的加载被标
记为 memory_order_consume 时，紧接着的解引这个指针的操作就不会被移动它之前。

memory_order_relaxed

使用这个值意味着允许所有的重新排序。

展望未来的C++并发特性

许多开发人员在使用原生调用或是 POSIX 线程
（pthreads）库的 C 风格的函数实现线程并发方面经验丰富。

以下是 C++17 可能会带给我们的一些并发特性。

协作多线程

在协作多线程中，两个或多个软件线程通过语句显式地互相传递执行，这样实际上在同
一时间只有一个线程在运行。协程（coroutines）就是协作多线程的例子。

SIMD 指令

SIMD 是单指令多数据（single instruction multiple data）的首字母缩写。在支持 SIMD
的处理器中，某些指令会操作寄存器向量。处理器会同时在向量中的每个寄存器上进行
相同的操作，与标量操作相比减少了间接开销。
C++ 编译器通常不会生成 SIMD 指令，因为它们的行为很复杂，不太符合 C++ 描述
程序的方式。依赖于编译器的编译指令或是内联汇编特性允许在函数中插入 SIMD 指
令，然后这些函数会被收录到用于数字信号处理或是计算机图形等专业任务的库中。因
此，SIMD 编程是同时依赖于处理器和编译器的。互联网上有许多关于 SIMD 指令的资
源，其中 Stack Exchange Q&A（http://gamedev.stackexchange.com/questions/12601/simd-
c-library）上有许多讨论如何在 C++ 中使用 SIMD 的资料。

优化多线程C++程序

用 std::async 替代 std::thread

并发编程的一项实用优化技巧是用复用线程取代在每次需要时创建新线程。线程可能会在
某个条件变量上挂起，直到程序需要使用它们时才会被释放，并接着执行一个可调用对象。尽管切换线程的有些开销（保存和恢复寄存器并刷新和重新填充高速缓存）是相同
的，但可以移除或减少为线程分配内存以及操作系统调度线程等其他开销。

模板函数 std::async() 会运行线程上下文中的可调用对象，但是它的实现方式允许复用
线程。从 C++ 标准来看， std::async() 可能是使用线程池的方式实现的。在 Windows 上，
std::async() 明显快得多。

使用 async() 启动和停止线程

std::async(std::launch::async, []() { return; });

async() 会返回一个 std::future ，在这种情况下它是一个匿名临时变量。只要 std::async()
一返回，程序就会立即调用这个匿名 std::future 的析构函数。析构函数会等待该 future
变为就绪状态，因此它可以抛出所有会发生的异常。这里不需要显式地调用 join() 或是
detach() 。

创建与核心数量一样多的可执行线程

C++ 提供了一个 std::thread::hardware_concurrency() 函数，它可以返回可用核心的数
量。这个函数会计算由 hypervisor 分配给其他虚拟机的核心，以及因多线程同步而表现为两个或多个逻辑核心的核心的数量。通过这个函数，以后我们可以方便地将程序部署到包
含更多（或少）核心的硬件上运行。

实现任务队列和线程池

解决不知道有多少个线程正在运行这个问题的方法是让线程更加明显：使用线程池（一种
保持固定数量的永久线程的数据结构）和任务队列（一种存储待执行的计算的列表的数据
结构），这些计算将由线程池中的线程负责执行。

在单独的线程中执行I/O

磁盘转速和网络连接距离等物理现实问题造成在程序请求数据和数据变为可用状态之间存
在着延迟。因此，I/O 是适用并发的绝佳位置。另外一个典型的 I/O 问题是，程序在写数
据之前或是读数据之后必须对它进行转换。例如，我们先从互联网上读取一个 XML 文件，
接着解析它，从中提取程序所需信息。由于在对数据进行转换之前是无法直接使用它的，
我们可以考虑将整个处理（包括读数据和解析数据）移动到一个单独的线程中。

没有同步的程序

面向事件编程

在面向事件编程中，程序是一组由框架调用的事件处理函数的集合。底层框架从事件队
列中将每个事件分发给注册了该事件的事件处理函数。面向事件编程在许多方面都与面
向任务编程类似。在面向事件的程序中，框架的行为类似于任务调度器，而事件处理函
数则类似于任务。它们两者之间的重要区别在于，在面向事件的程序中，框架是单线程
的，事件处理函数也不会并发执行。

协程

协程是可执行对象，虽然它会显式地将执行从一个对象转交给另外一个对象，但是它们
会记住执行指针，这样如果它们被再次调用了也可以继续执行。与面向事件的程序相
同，协程并非真正的多线程，因此只要它们不受多线程控制就不需要同步。
协程有两种。第一种有自己的栈，而且可以在执行途中的任何位置将控制转交给另外一
个协程。第二种是向另外一个线程借栈，并且只能在它的顶层转交控制。

消息传递

在消息传递程序中，控制线程从一个或多个输入源中接收输入，对输入进行转换后将它
放到一个或多个输出槽中。相互连接的输出和输入组成了一幅具有良好定义的入口节点
和出口节点的图。这些被实现了一个消息传递程序的各个阶段的线程所读写的元素可以
是网络数据报、字符 I/O 流或是隐式队列中的数据结构。
Unix 命令行管道和 Web 服务都是消息传递编程的例子。分布式处理系统的组件也都是
消息传递程序。

无锁编程（lock-free programming）

无锁编程是指无需互斥，允许多线程更新数据结构的编程实践。在无锁程序中，硬件同
步的原子性操作取代了昂贵的互斥量。无锁数据结构远比由互斥量保护的传统容器要优
秀，特别是当许多线程访问同一个容器时。
C++ 中无锁的数组、队列和散列表容器类已经发布了。Boost 也有无锁的栈和队列容器
（http://www.boost.org/doc/libs/1_59_0/doc/html/lockfree.html）， 但 是 只 在 GCC 和 Clang
编译器上进行了测试。英特尔的线程构建模块（http://www.threadingbuildingblocks.org/）
中有无锁的数组、队列和散列表容器。由于无锁编程的需求，这些容器并非与 C++ 标
准库中的容器完全相同。

让同步更加高效

• 减小临界区的范围
• 限制并发线程的数量
• 避免惊群，当有许多线程挂起在一个事件当发生这个事件时，所有的线程都会变为可运行状态，但由于只有几个核心，因此只有几个线程能够立即运行。
• 避免锁护送,当大量线程同步，挂起在某个资源或是临界区上时会发生锁护送（lock convoy）。这会导致额外的阻塞，因为它们都会试图立即继续进行处理，但是每次却只有一个线程能够继续处理，仿佛是在护送锁一样。
• 减少竞争
  • 注意内存和 I/O 都是资源
  • 复制资源
  • 分割资源
  • 细粒度锁,我们可以使用多个互斥量，而不是一个互斥量来锁住整个数据结构。
  • 无锁数据结构，我们使用无锁散列表等无锁数据结构来摆脱对互斥的依赖。这是细粒度锁的终极形态。
  • 资源的调度
• 不要在单核系统上繁忙等待
• 不要永远等待
• 自己设计互斥量可能会低效
• 限制生产者输出队列的长度

并发库

Boost.Thread（http://www.boost.org/doc/libs/1_60_0/doc/html/thread.html）和 Boost.Coroutine（http://www.boost.org/doc/libs/1_60_0/libs/coroutine/doc/html/index.html）

Boost 的线程库是对 C++17 标准库线程库的展望。其中有些部分现在仍然处于实验状
态。 Boost.Coroutine 也处于实验状态。

POSIX 线程

POSIX 线程（pthreads）是一个跨平台的线程和同步原语库，它可能是最古老和使
用最广泛的并发库了。POSIX 线程是 C 风格的函数库，提供了传统的并发能力。它
有非常完整的文档资源，不仅适用于多种 Linux 发行版，也适用于 Windows（http://
sourceware.org/pthreads-win32/）。

线程构建模块（TBB，http://www.threadingbuildingblocks.org/）

TBB 是一个有雄心壮志的、有良好文档记录的、具有模板特性的 C++ 线程 API。它提
供了并行 for 循环，任务和线程池，并发容器，数据流消息传递类以及同步原语。TBB
由英特尔开发，旨在提高多核处理器效率。现在它已经被开源了，同时支持 Windows
和 Linux。它有良好的文档记录，其中还包括一本优秀书籍（James Reinders 编写的
Intel Threading Building Blocks，O’Reilly 出版社）。

0mq（也拼写为 ZeroMQ，http://zeromq.org/）

0mq 是一个用于连接消息传递程序的通信库。它支持多种通信范式，追求高效与简约。
以我的个人经验来看，0mq 是非常优秀的。0mq 是开源的，有良好的文档，获得了不少
支持。0mq 还有一个称为 nanomsg 的改进版（http://www.nanomsg.org），它修正了 0mq
中的一些问题。

消息传递接口（MPI，http://computing.llnl.gov/tutorials/mpi/）

MPI 是分布式计算机网络中的消息传递的一个 API 规范。它的实现类似于 C 风格的函
数库。MPI 诞生于加利福尼亚的劳伦斯利弗莫尔国家实验室，该实验室长期与超级计算
机集群和繁荣的高能物理联系在一起。MPI 具有良好的文档记录，具有老式的 20 世纪
80 年代的 DoD 风格。它既有支持 Linux 的实现，也有支持 Windows 的实现，其中还包
括来自 Boost 的实现（http://www.boost.org/doc/libs/1_60_0/doc/html/mpi.html），但是这
些实现并非都完整地覆盖了规范。

OpenMP（http://openmp.org）

OpenMP 是一款用于“使用 C/C++ 和 Fortran 语言进行多平台共享内存并行编程”的
API。其用法是开发人员使用定义程序并行行为的编译指令装饰 C++ 程序。OpenMP 提
供了一个擅长数值计算的细粒度的并发模型，而且它正在朝着 GPU 编程的方向发展。
在 Linux 上，GCC 和 Clang 都支持 OpenMP；在 Windows 上 Visual C++ 支持 OpenMP。

C++ AMP（https://msdn.microsoft.com/en-us/library/hh265137.aspx）

C++ AMP 是一份关于设计 C++ 库在 GPU 设备上进行并行数据计算的开源规范。其中，
来自于微软的版本会被解析为 DirectX 11 调用。

优化内存管理

• 颜色调色板CPalette
• 调用CDC的SetViewportOrg来改变坐标原点
• TRACE与afxDump诊断信息
• CArchive序列化类
• DragAcceptFiles标识窗口是否接受从shell拖放过来的文件
• DragQueryFile 获得拖拽后的文件名称列表。
• DragFinish 释放系统为拖拽功能处理文件名称而分配的内存。
• OnQueryEndSession

OLE

• ubuntu系统文件
• Universal-USB-Installer
• EasyBCD 2.3

系统分盘：/boot与/swap

Windows环境

COVTOOL

（http://covtool.sourceforge.net）是一个开源的测试覆盖率工具。

OpenCppCoverage

• https://github.com/OpenCppCoverage/OpenCppCoverage
• https://github.com/OpenCppCoverage/OpenCppCoverage/wiki/Command-line-reference

• https://github.com/OpenCppCoverage/OpenCppCoverage/wiki/Jenkins

  OpenCppCoverage.exe –sources MySourcePath – YourProgram.exe arg1 arg2

打开VisualStudio –> 工具 –> 扩展和更新 –> 联机 –> 右上角输入OpenCppCoverage，在下面的结果会出现“OpenCppCoverage Plugin”点击安装即可（安装中需要将VisualStudio重启）

程序写好，编译执行之后，点击“工具 –> Run OpenCppCoverage”，程序运行，将命令行窗口关掉，则代码会出现红色或者绿色的阴影，下面会出现Coverage的报告

Linux环境

Linux下的C/C++代码，可以在gcc/g++工具编译代码时加上“–coverage”选项来生成可用于覆盖率分析的二进制文件，然后用gcov命令来生成覆盖率统计情况，也可用lcov工具来生成html版本的可读性很好的代码覆盖率报告。

c/c++:    gcc+gcov+lcov；

https://www.boost.org/doc/libs/1_55_0/doc/html/thread.html

thread

• 当创建一个thread对象后，线程就立刻开始执行。
• join()和timed_join()方法等待线程结束。
  • join()一直阻塞等待，直到线程结束。
  • timed_join()阻塞等待线程结束，或阻塞等待一定的时间段，然后不管线程是否结束都返回。
• detach()与线程执行体分离，线程执行体不受影响的继续执行直到运行结束。
• 可以使用bind()和function库。
• thread类的3个静态成员函数：
  • yield() 指示当前线程放弃时间片，允许其他的线程运行。
  • sleep() 让线程睡眠等待一小段时间。
  • hardware_concurrency() 获得硬件系统可并行的线程数量，即CPU数量。
• thread::this_thread 子命名空间：
  • get_id() 获得线程ID
  • yield() 放弃时间片
  • sleep() 睡眠等待
  • at_thread_exit(func)函数，允许“登记”一个线程在结束的时候执行可调用物func，无论线程是否被中断。
• interrupt() 中断线程，允许正在执行的线程被中断，被中断的线程会抛出一个thread_interrupted异常。

创建线程4种方法以及分离或等待线程

在任何一个时间点上，线程是可结合的（joinable），或者是分离的（detached）。

void my_func()
{
    std::cout << "detach-分离 或 join-等待 线程" << std::endl;
}

TEST(BoostThread, detachOrjoin)//简单线程,线程状态joinable、detached
{
    boost::thread t(my_func);
    boost::thread::yield();//当前线程放弃余下的时间片。
    std::cout << t.joinable() << std::endl;
    t.join();

    boost::thread t1(my_func);
    std::cout << t1.joinable() << std::endl;
    t1.detach();
    std::cout << t1.joinable() << std::endl;
}

//线程的创建需要传递给thread对象一个可调用物（函数或函数对象），它必须具
//有operator()以供线程执行。
boost::mutex io_mutex;
struct count 
{
    count(int id) : id(id) { }

    void operator()()
    {
        for (int i = 0; i < 10; ++i)
        {
            boost::mutex::scoped_lock
                lock(io_mutex);
            std::cout << id << ": "
                << i << std::endl;
        }
    }

    int id;
};

TEST(BoostThread, Typeobject)//复杂类型对象作为参数来创建线程
{
    boost::thread thrd1(count(1));
    boost::thread thrd2(count(2));
    thrd1.join();
    thrd2.join();
}

class HelloWorldStatic
{
public:
    static void hello()
    {
        std::cout <<
            "Hello world, I''m a thread!"
            << std::endl;
    }
    static void start()
    {

        boost::thread thrd(hello);
        thrd.join();
    }

};

TEST(BoostThread, InClassStatic)//类内部创建线程
{
    HelloWorldStatic::start();//在这里start()和hello()方法都必须是static方法。
}

class HelloWorld
{
public:
    void hello()
    {
        std::cout <<
            "Hello world, I''m a thread!"
            << std::endl;
    }
    void start()
    {
        boost::function0< void> f = boost::bind(&HelloWorld::hello, this);
        boost::thread thrd(f);
        thrd.join();
    }

};

TEST(BoostThread, InClass)//start()和hello()方法不是静态方法则采用此方法创建线程
{
    HelloWorld hello;
    hello.start();
}

class HelloWorldOut
{
public:
    void hello(const std::string& str)
    {
        std::cout << str;
    }
};

TEST(BoostThread, OutClass)
{
    HelloWorldOut obj;
    boost::thread thrd(boost::bind(&HelloWorldOut::hello, &obj, "Hello world, I''m a thread!" ) ) ;
    thrd.join();
}

线程的参数传递

void func1(const int &id)
{
    std::cout << "func1 id : " << id << std::endl;
}

struct MyThread
{
    void operator()(const int &id)
    {
        std::cout << "MyThread id : " << id << std::endl;
    }

    void func1(const int &id)
    {
        std::cout << "MyThread::func1 id : " << id << std::endl;
    }
};

TEST(BoostThread, Threadparameters)
{
    //普通函数  
    boost::thread t1(func1, 11);
    t1.join();

    //函数对象  
    MyThread myThread;
    boost::thread t2(myThread, 22);
    t2.join();

    //成员函数  
    boost::thread t3(&MyThread::func1, myThread, 33);
    t3.join();

    //临时对象  
    boost::thread t4(MyThread(), 44);
    t4.join();

    //对象引用  
    boost::thread t5(boost::ref(myThread), 55);
    t5.join();
}

还可使用bing与ref

线程中断

禁用于回复中断：
boost::this_thread::disable_interruption与boost::this_thread::restore_interruption

void f()
{
    // interruption enabled here
    {
        boost::this_thread::disable_interruption di;
        // interruption disabled
        {
            boost::this_thread::disable_interruption di2;
            // interruption still disabled
        } // di2 destroyed, interruption state restored
        // interruption still disabled
    } // di destroyed, interruption state restored
    // interruption now enabled
}

void g()
{
    // interruption enabled here
    {
        boost::this_thread::disable_interruption di;
        // interruption disabled
        {
            boost::this_thread::restore_interruption ri(di);
            // interruption now enabled
        } // ri destroyed, interruption disable again
    } // di destroyed, interruption state restored
    // interruption now enabled
}

函数检测当前线程是否允许中断：boost::this_thread::interruption_enabled()

函数检测当前线程是否被要求中断：boost::this_thread::interruption_requested()

类disable_interruption是一个RAII类型的对象，它在构造时关闭线程的中断，析构时自动恢复线程的中断状态。在disable_interruption 的生命期内线程始终是不可中断的，除非使用了restore_interruption 对象。

restore_interruption只能在disable_interruption 的作用域内使用，它在构造时临时打开线程的中断状态，在析构时又关闭中断状态。

thread库预定义了若干个线程的中断点:

boost::thread::join()
boost::thread::timed_join()
boost::thread::try_join_for(),
boost::thread::try_join_until(),
boost::condition_variable::wait()
boost::condition_variable::timed_wait()
boost::condition_variable::wait_for()
boost::condition_variable::wait_until()
boost::condition_variable_any::wait()
boost::condition_variable_any::timed_wait()
boost::condition_variable_any::wait_for()
boost::condition_variable_any::wait_until()
boost::thread::sleep()
boost::this_thread::sleep_for()
boost::this_thread::sleep_until()
boost::this_thread::interruption_point()

而最后一个位于子名字空间this_thread的interruption_point()则是一个特殊的中断点函数，它并不等待，只是起到一个标签的作用，表示线程执行到这个函数所在的语句就可以被中断。

thread_group线程组

thread库提供类thread_group用于管理一组线程，就像是一个线程池，它内部使用
std::list 来容纳创建的thread对象。

void thread_group_Fun()
{
    std::cout <<"当前线程ID:"<< boost::this_thread::get_id() << std::endl;
}

TEST(BoostThread, thread_group)
{
    boost::thread_group grp;
    boost::thread *p = new boost::thread(thread_group_Fun);
    grp.add_thread(p);
    std::cout << "remove_thread:" << p->get_id()<< std::endl;
    grp.remove_thread(p);

    grp.create_thread(thread_group_Fun);
    grp.create_thread(thread_group_Fun);   

    grp.join_all();                 
}

##作用域线程 ##

boost::strict_scoped_thread<> t((boost::thread(F)));

boost::scoped_thread<> t((boost::thread(F)));

锁

Lock Guard

Class template lock_guard
Non Member Function make_lock_guard
Non Member Function make_lock_guard

boost::lock_guard 在其内部构造和析构函数分别自动调用 lock() 和 unlock() 。 访问共享资源是需要同步的，因为它显示地被两个方法调用。

使用 lock_guard 自动加锁、解锁。原理是 RAII，和智能指针类似。

RAII型的lock_guard类

直接使用mutex的lock()函数来锁定互斥量不够方便，且在发生异常退出作用域等情况下很可能忘记解锁。
故，thread库提供了RAII型lock_guard类，辅助：在构造时锁定互斥量，析构时自动解锁。
mutex类使用内部类型定义了两种lock_guard对象：

scoped_lock 
scoped_try_lock

使用 unique_lock 自动加锁、解锁。
unique_lock 与 lock_guard 原理相同，但是提供了更多功能（比如可以结合条件变量使用）。
注意：mutex::scoped_lock 其实就是 unique_lock 的 typedef。

Lock Types

Class template unique_lock
Class template shared_lock - C++14
Class template upgrade_lock - EXTENSION
Class template upgrade_to_unique_lock -- EXTENSION
Mutex-specific class scoped_try_lock -- DEPRECATED

boost::unique_lock 这个所谓的独占锁意味着一个互斥量同时只能被一个线程获取。 其他线程必须等待，直到互斥体再次被释放。 除了独占锁，还有非独占锁。 Boost.Thread里有个 boost::shared_lock 的类提供了非独占锁。

shared_lock是read lock。被锁后仍允许其他线程执行同样被shared_lock的代码。这是一般做读操作时的需要。

unique_lock是write lock。被锁后不允许其他线程执行被shared_lock或unique_lock的代码。在写操作时，一般用这个，可以同时限制unique_lock的写和share_lock的读。

boost::mutex::scoped_lock

boost::mutex io_mutex;
void foo( )
{
    {
        boost::mutex::scoped_lock lock( io_mutex );         /// 锁定
    } /// 解锁
}

boost::lock_guard<>和boost::unique_lock<>的区别

boost::mutex  m;
void foo( )
{
    boost::lock_guard<boost::mutex> lk( m );
    process( data );
};
//lock_guard只能像上面这样使用，而unique_lock允许设置超时，推迟锁定lock以及在对象销毁之前unlock。
{
    boost::unique_lock<boost::mutex> lk( m );
    process( data );
    lk.unlock( );
    // do other thing
};

设置锁超时

boost::unique_lock<boost::timed_mutex> lk( m, std::chrono::milliseconds(3) ); // 超时3秒

if( lk )  process( data );

Other Lock Types - EXTENSION

Strict Locks
Locking pointers
Externally Locked
Class template shared_lock_guard
Class template reverse_lock

互斥类型

独占式互斥量：

Class mutex
Typedef try_mutex
Class timed_mutex

递归式互斥量：

Class recursive_mutex
Typedef recursive_try_mutex
Class recursive_timed_mutex

boost::recursive_mutex提供一个递归式的互斥量。对于一个实例最多允许一个线程拥有其锁定，如果一个线程已经锁定一个boost::recursive_mutex实例，那么这个线程可以多次锁定这个实例。

共享式互斥量：

Class shared_mutex -- C++14
Class upgrade_mutex -- EXTENSION

其他：

Class null_mutex -- EXTENSION

读写锁

typedef boost::shared_lock<boost::shared_mutex> readLock;
typedef boost::unique_lock<boost::shared_mutex> writeLock;
boost::shared_mutex rwmutex;

std::vector<int> random_numbers;

void readOnly()
{
    for (int i = 0; i < 3; ++i)
    {
        wait(1);
        readLock rdlock(rwmutex);
        std::cout << random_numbers.back() << std::endl;
    }
}

void writeOnly()
{
    std::srand(static_cast<unsigned int>(std::time(0)));
    for (int i = 0; i < 3; ++i)
    {
        writeLock wtlock(rwmutex);
        random_numbers.push_back(std::rand());
        wait(1);
    }
}

int sum = 0;

void count()
{
    for (int i = 0; i < 3; ++i)
    {
        wait(1);
        readLock rdlock(rwmutex);
        sum += random_numbers.back();
    }
}

TEST(BoostThread, readwrite)//读写锁
{
    boost::thread t1(writeOnly);
    boost::thread t2(readOnly);
    boost::thread t3(count);
    t1.join();
    t2.join();
    t3.join();
    std::cout << "Sum: " << sum << std::endl;
}

shared_mutex 比一般的 mutex 多了函数 lock_shared() / unlock_shared()，允许多个（读者）线程同时加锁、解锁，而 shared_lock 则相当于共享版的 lock_guard。

对 shared_mutex 使用 lock_guard 或 unique_lock 就达到了写者独占的目的。

Condition Variables条件变量

从一个线程中给另一个线程发送通知

条件变量是thread库提供的另一种用于等待的同步机制，可以实现线程间的通信，它必须和互斥量配合使用，等待另一个线程中某个事件的发送（满足某个条件），然后线程才能继续执行。
thread库提供两种条件变量对象：

condition_variable 
condition_variable_any （常用，能够适应更广泛的互斥量类型）

条件变量的使用方法很简单:

拥有条件变量的线程先锁定互斥量，然后循环检查某个条件，如果条件不满足，那么
就调用变量的成员函数wait()等待直至条件满足。其他线程处理条件变更要求的条件，
当条件满足时调用它的成员函数notify_one()或notify_all()，以通知一个或者所
有正在等待条件变更的线程停止等待继续执行。

其他用法
条件变量的wait()函数有一个有用的重载形式:wiat(lock_type& lock, predicate_type
predicate),它比普通的形式多接受一个谓词函数（或函数对象），当谓词predicate不
满足时持续等待。

使用这个重载形式或以写出更简洁清晰的代码，通常需要配合bind来简化谓词函数的
编写。
例如,buffer类的两个条件变量的等待可以改写成:
cond_put.wait(mu, !bind(&buffer::is_full, this));
cond_get.wait(mu, !bind(&buffer::is_empty, this));

https://segmentfault.com/a/1190000006679917

条件变量读写

boost::condition_variable_any cond;
boost::mutex rwmutexCV;
std::vector<int> random_numbersCV;

void print()
{
    std::size_t next_size = 1;
    for (int i = 0; i < 3; ++i)
    {
        boost::unique_lock<boost::mutex> lock(rwmutexCV);
        while (random_numbersCV.size() != next_size)
            cond.wait(rwmutexCV);
        std::cout << random_numbersCV.back() << std::endl;
        ++next_size;
        cond.notify_all();
    }
}

void fill()
{
    std::srand(static_cast<unsigned int>(std::time(0)));
    for (int i = 0; i < 3; ++i)
    {
        boost::unique_lock<boost::mutex> lock(rwmutexCV);
        random_numbersCV.push_back(std::rand());
        cond.notify_all();
        cond.wait(rwmutexCV);
    }
}

TEST(BoostThread, ConditionVariables)//条件变量
{
    boost::thread t1(fill);
    boost::thread t2(print);
    t1.join();
    t2.join();
}

生产者-消费者模式的后进先出型(std::stack)缓冲区

class Buffer
{
public:
    //构造函数
    Buffer(size_t n) :un_read(0), capacity(n) {}

    //写入数据x
    void put(int x) {
        //局部域
        {
            boost::mutex::scoped_lock lock(mu);  //锁定互斥量
            while (is_full()) {
                cond_put.wait(mu);  //条件变量等待
            }
            stk.push(x);  //写入数据
            ++un_read;
        }  //解锁互斥量

        cond_get.notify_one();  //通知可以读取数据
    }

    //读取数据
    void get(int *x) {

        {
            boost::mutex::scoped_lock lock(mu);
            while (is_empty()) {
                cond_get.wait(mu);
            }
            *x = stk.top();
            stk.pop();
            --un_read;
        }

        cond_put.notify_one();
    }

private:
    //判断缓冲区是否满
    bool is_full() {
        return un_read == capacity;
    }

    //判断缓冲区是否为空
    bool is_empty() {
        return un_read == 0;
    }

private:
    boost::mutex mu;  //互斥量，配合条件变量使用
    boost::condition_variable_any cond_put;  //写入条件变量
    boost::condition_variable_any cond_get;  //读取条件变量
    std::stack<int> stk;  //缓冲区对象
    int un_read;
    int capacity;
};

Buffer buf(5);  //定义一个缓冲区对象

boost::mutex io_mu_;  //定义一个输出互斥量

//生产者,n个
void producer(int n)
{
    for (int i = 0; i < n; i++) {
        //输出信息
        {
            boost::mutex::scoped_lock lock(io_mu_);
            std::cout << "put " << i << " to buffer" << std::endl;

        }
        buf.put(i);  //写入数据
    }
}

//消费者
void consumer(int n)
{
    int result(0);
    for (int i = 0; i < n; i++) {
        {
            buf.get(&result);  //读取数据
            boost::mutex::scoped_lock lock(io_mu_);
            std::cout << "get " << result << " from buffer" << std::endl;
        }
    }
}

TEST(BoostThread, producer_consumer_test)
{
    boost::thread t_producer(producer, 20);
    boost::thread t_consumer1(consumer, 10);
    boost::thread t_consumer2(consumer, 10);

    t_producer.join();
    t_consumer1.join();
    t_consumer2.join();
}

https://segmentfault.com/a/1190000006703543

#include <iostream>
#include <vector>
#include <boost/utility.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/thread/thread.hpp>

class BoundedBuffer : private boost::noncopyable {
public:
  BoundedBuffer(size_t size)
    : begin_(0), end_(0), buffered_(0), circular_buffer_(size) {
  }

  void Produce(int n) {
    boost::unique_lock<boost::mutex> lock(mutex_);

    // 等待缓冲不为满。
    not_full_cv_.wait(lock, [=] { return buffered_ < circular_buffer_.size(); });

    // 插入新的元素，更新下标。
    circular_buffer_[end_] = n;
    end_ = (end_ + 1) % circular_buffer_.size();

    ++buffered_;

    // 通知前，手动解锁。
    lock.unlock();

    // 通知消费者。
    not_empty_cv_.notify_one();
  }

  int Consume() {
    boost::unique_lock<boost::mutex> lock(mutex_);

    // 等待缓冲不为空。
    not_empty_cv_.wait(lock, [=] { return buffered_ > 0; });

    // 移除一个元素。
    int n = circular_buffer_[begin_];
    begin_ = (begin_ + 1) % circular_buffer_.size();

    --buffered_;

    // 通知前，手动解锁。
    lock.unlock();

    // 通知生产者。
    not_full_cv_.notify_one();
    return n;
  }

private:
  size_t begin_;
  size_t end_;
  size_t buffered_;
  std::vector<int> circular_buffer_;
  boost::condition_variable not_full_cv_;
  boost::condition_variable not_empty_cv_;
  boost::mutex mutex_;
};

BoundedBuffer g_buffer(2);
boost::mutex g_io_mutex;

void Producer() {
  int n = 0;
  while (n < 100000) {
    g_buffer.Produce(n);
    if ((n % 10000) == 0) {
      boost::unique_lock<boost::mutex> lock(g_io_mutex);
      std::cout << "Produce: " << n << std::endl;
    }
    ++n;
  }

  g_buffer.Produce(-1);
}

void Consumer() {
  boost::thread::id thread_id = boost::this_thread::get_id();

  int n;
  do {
    n = g_buffer.Consume();
    if ((n % 10000) == 0) {
      boost::unique_lock<boost::mutex> lock(g_io_mutex);
      std::cout << "Consume: " << n << " (" << thread_id << ")" << std::endl;
    }
  } while (n != -1);  // -1 表示缓冲已达末尾。

  // 往缓冲里再放一个 -1，这样其他消费者才能结束。
  g_buffer.Produce(-1);
}

int main() {
  boost::thread_group threads;

  threads.create_thread(&Producer);
  threads.create_thread(&Consumer);
  threads.create_thread(&Consumer);
  threads.create_thread(&Consumer);

  threads.join_all();

  return 0;
}

线程池

https://segmentfault.com/a/1190000006691692

也可使用ATL的ThreadPool或http://threadpool.sourceforge.net/

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <boost/asio.hpp>

class ThreadPool {
public:
  explicit ThreadPool(size_t size) : work_(io_service_) {
    for (size_t i = 0; i < size; ++i) {
      workers_.create_thread(
          boost::bind(&boost::asio::io_service::run, &io_service_));
    }
  }

  ~ThreadPool() {
    io_service_.stop();
    workers_.join_all();
  }

  // Add new work item to the pool.
  template<class F>
  void Enqueue(F f) {
    io_service_.post(f);
  }

private:
  boost::thread_group workers_;
  boost::asio::io_service io_service_;
  boost::asio::io_service::work work_;
};

成员变量 io_service::work 的作用是，让 asio::io_service 即使在没有异步任务可执行时也保持运行（即 io_service::run 不返回）。

int main() {
  // Create a thread pool of 4 worker threads.
  ThreadPool pool(4);

  // Queue a bunch of work items.
  for (int i = 0; i < 8; ++i) {
    pool.Enqueue([i] {
      std::cout << "hello " << i << std::endl;
      boost::this_thread::sleep(boost::posix_time::seconds(1));
      std::cout << "world " << i << std::endl;
    });
  }

  return 0;
}

线程局部存储

Boost线程库提供了智能指针boost::thread_specific_ptr来访问本地存储线程。每一个线程第一次使用这个智能指针的实例时，它的初值是NULL，所以必须要先检查这个它的只是否为空，并且为它赋值。Boost线程库保证本地存储线程中保存的数据会在线程结束后被清除。

void init_number_generator()
{
    static boost::thread_specific_ptr<bool> tls;
    if (!tls.get())
        tls.reset(new bool(false));
    if (!*tls)
    {
        *tls = true;
        std::srand(static_cast<unsigned int>(std::time(0)));
    }
}

boost::mutex mutex;

void random_number_generator()
{
    init_number_generator();
    int i = std::rand();
    boost::lock_guard<boost::mutex> lock(mutex);
    std::cout << i << std::endl;
}

TEST(BoostThread, thread_specific_ptr)//线程局部存储
{
    boost::thread t[3];

    for (int i = 0; i < 3; ++i)
        t[i] = boost::thread(random_number_generator);

    for (int i = 0; i < 3; ++i)
        t[i].join();
}

只初始化一次共享资源

std::call_once

准确执行一次可调用 (Callable) 对象 f ，即使同时从多个线程调用。

#include <iostream>
#include <thread>
#include <mutex>

std::once_flag flag1, flag2;

void simple_do_once()
{
    std::call_once(flag1, [](){ std::cout << "Simple example: called once\n"; });
}

void may_throw_function(bool do_throw)
{
  if (do_throw) {
    std::cout << "throw: call_once will retry\n"; // 这会出现多于一次
    throw std::exception();
  }
  std::cout << "Didn't throw, call_once will not attempt again\n"; // 保证一次
}

void do_once(bool do_throw)
{
  try {
    std::call_once(flag2, may_throw_function, do_throw);
  }
  catch (...) {
  }
}

int main()
{
    std::thread st1(simple_do_once);
    std::thread st2(simple_do_once);
    std::thread st3(simple_do_once);
    std::thread st4(simple_do_once);
    st1.join();
    st2.join();
    st3.join();
    st4.join();

    std::thread t1(do_once, true);
    std::thread t2(do_once, true);
    std::thread t3(do_once, false);
    std::thread t4(do_once, true);
    t1.join();
    t2.join();
    t3.join();
    t4.join();
}

boost::call_once

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/once.hpp>

// Some sort of connection class that should only be initialized once
struct Conn {
   static void init( ) {++i_;}
   static boost::once_flag init_;
   static int i_;
   // ...
};

int Conn::i_ = 0;
boost::once_flag Conn::init_ = BOOST_ONCE_INIT;

void worker( ) {
   boost::call_once(Conn::init, Conn::init_);
   // Do the real work...
}

Conn c;  // You probably don't want to use a global, so see the
         // next Recipe

int main( ) {

   boost::thread_group grp;

   for (int i = 0; i < 100; ++i)
      grp.create_thread(worker);

   grp.join_all( );

   std::cout << c.i_ << '\n';// c.i_ = 1
}

一个共享资源不得不在某个地方被初始化，并且你希望第一次使用这个资源的线程来完成初始化工作。一个once_flag类型和call_once函数能够保证多个线程不会重复的初始化同一个对象。首先，必须使用BOOST_ONCE_INIT宏来初始化这个once_flag对象。boost::onceflag Conn::init = BOOST_ONCE_INIT; 之后调用call_once函数，boost::callonce(Conn::init, Conn::init); 第一个形参是希望被执行一次的初始化函数的地址。

原子操作

boost::atomic<>

Futures

很多情况下线程不仅仅要执行一些工作，它还可能要返回一些计算结果。

thread库使用future范式提供了一种异步操作线程返回值的方法，

future使用packaged_task和promise两个模板类来包装异步调用，用unique_future
和shared_future来获取异步调用结果（即future值)。

package_task和unique_future

packaged_task用来存储packaged_task异步计算得到的future值，它只能持有结果的
唯一的一个引用。成员函数wait()和timed_wait()的行为类似thread.join()，可以
阻塞等待packaged_task的执行，直至获得future值。成员函数is_ready()、has_value()
和has_exception()分别用来测试unique_future是否可用。

下面代码示范了future特性的用法，使用packaged_task和unique_future:

int fab(int n)
{
    if (n == 0 || n == 1)
    {
        return 1;
    }
    return fab(n - 1) + fab(n - 2);
}


int main()
{
    // 声明packaged_task对象，用模板参数指明返回值类型
    // packaged_task只接受无参函数，因此需要使用bind
    packaged_task<int> pt(bind(fab, 10));


    // 声明unique_future对象，接受packaged_task的future值
    // 同样要用模板参数指明返回值类型
    unique_future<int> uf = pt.get_future();


    // 启动线程计算，必须使用boost::move()来转移package_task对象
    // 因为packaged_task是不可拷贝的
    thread(boost::move(pt));
    uf.wait(); // unique_future等待计算结果
    assert(uf.is_ready() && uf.has_value());
    cout << uf.get(); // 输出计算结果99
}

使用多个future对象

为了支持多个future对象的使用,future还提供wait_for_any()和wiat_for_all()两个
自由函数，它们可以阻塞等待多个future对象，直到任意一个或者所有future对象都
可以(is_ready())。这两个函数有多个重载形式，可以接受一对表示future容器区间
的迭代器或者最多5个future对象。

promise

promise也用于处理异步调用返回值，但它不同于packaged_task，不能包装一个函数，
而是包装一个值，这个值可以作为函数的输出参数，适用于从函数参数返回值的函数。

promise的用法与packaged_task类似，在线程中用set_value()设置要返回的值，用
成员函数get_future()获得future值赋给future对象。

int calculate_the_answer_to_life_the_universe_and_everything()
{
    return 42;
}

void invoke_lazy_task(boost::packaged_task<int>& task)
{
    try
    {
        task();
    }
    catch (boost::task_already_started&)
    {
    }
}

//shared_future与unique_future
TEST(BoostThread, BoostFuture)
{
    {
        boost::packaged_task<int> pt(calculate_the_answer_to_life_the_universe_and_everything);
        boost::unique_future<int> fi = pt.get_future();

        boost::thread task(boost::move(pt)); // launch task on a thread

        fi.wait(); // wait for it to finish

        ASSERT_TRUE(fi.is_ready());
        ASSERT_TRUE(fi.has_value());
        ASSERT_TRUE(!fi.has_exception());
        ASSERT_TRUE(fi.get_state() == boost::future_state::ready);
        ASSERT_TRUE(fi.get() == 42);
    }

    {
        boost::promise<int> pi;
        boost::unique_future<int> fi;
        fi = pi.get_future();

        pi.set_value(42);

        ASSERT_TRUE(fi.is_ready());
        ASSERT_TRUE(fi.has_value());
        ASSERT_TRUE(!fi.has_exception());
        ASSERT_TRUE(fi.get_state() == boost::future_state::ready);
        ASSERT_TRUE(fi.get() == 42);
    }

    {
        boost::packaged_task<int> task(calculate_the_answer_to_life_the_universe_and_everything);
        task.set_wait_callback(invoke_lazy_task);
        boost::unique_future<int> f(task.get_future());

        ASSERT_TRUE(f.get() == 42);
    }
}

参考

• https://www.cnblogs.com/renyuan/p/6613638.html
• https://blog.csdn.net/lp310018931/article/details/50596469
• https://www.cnblogs.com/lidabo/p/3785176.html
• https://blog.csdn.net/yvhqbat/article/details/51922153
• https://blog.csdn.net/liujiayu2/article/details/50587064
• https://blog.csdn.net/u012592062/article/details/80467118
• C++ 并发编程指南

视频开发：DShow、OpenCV、FFmpeg

FFmpeg

FFmpeg官网：

http://ffmpeg.org/

下载 Download FFmpeg for Windows:

https://ffmpeg.zeranoe.com/builds/

雷霄骅(leixiaohua1020)的专栏:

http://blog.csdn.net/leixiaohua1020

百度网盘资料：

链接：http://pan.baidu.com/s/1o80QYoy 密码：i5mb

FFmpeg介绍：

FFmpeg是一个集合的库和工具来处理多媒体内容诸如音频、视频、字幕和相关元数据。
图书馆查询系统

libavcodec提供了执行更广泛的范围,用于各种类型声音/图像编解码;
libavformat实现流媒体协议容器格式和基本I/O访问,用于各种音视频封装格式的生成和解析，包括获取解码所需信息以生成解码上下文结构和读取音视频帧等功能；
libavutil包括hashers、压缩器和杂项功能效用,包含一些公共的工具函数；
libavfilter提供了一种通过改变视频和音频解码的滤波器链。
libavdevice提供一个抽象访问捕获和回放设备。
libswresample实现音频混合和重采样例程。
libswscale执行缩放和色彩转换例程。

工具：

FFmpeg是一种命令行工具操纵、转换和流多媒体内容。
ffplay是一个简约的多媒体播放器。
ffprobe是一个简单的分析工具来检查多媒体内容。
ffserver为多媒体流传输服务器用于实况广播,一个 HTTP 多媒体即时广播串流服务器。
附加等小工具aviocat，ismindex and qt-faststart

其他：

jrtplib

jrtplib使用笔记

RTP 是目前解决流媒体实时传输问题的最好办法，而JRTPLIB 是一个用C++语言实现的RTP库，包括UDP通讯.

实时传送协议（Real-time Transport Protocol或简写RTP，也可以写成RTTP）是一个网络传输协议，RTP协议详细说明了在互联网上传递音频和视频的标准数据包格式。它一开始被设计为一个多播协议，但后来被用在很多单播应用中。RTP协议常用于流媒体系统（配合RTCP协议或者RTSP协议）。因为RTP自身具有Time stamp所以在ffmpeg 中被用做一种formate。

RTP协议的详细介绍，请参考这篇文章http://www.360doc.com/content/11/1009/15/496343_154624612.shtml

jrtplib需要使用jthread

• http://research.edm.uhasselt.be/jori/page/Main/HomePage.html
• http://research.edm.uhasselt.be/jori/page/CS/Jrtplib.html
• JRTPLIB 3.11.1 文档
• jrtplib-3.11.1.zip
• https://github.com/j0r1/JRTPLIB
• jrtplib-3.7.1在windows下的编译步骤

jthread

所述包包含jthread和jmutex，（显然）表示一个线程和一个互斥锁。对于类Unix平台上，实现使用的pthread库。在MS-Windows平台，本机Win32线程使用。

• http://research.edm.uhasselt.be/jori/page/CS/Jthread.html
• https://github.com/j0r1/JThread

emiplib

这个库的目的就是要完成一个多媒体的网络传输库，方便多种媒体在网络上进行传输。

• http://research.edm.uhasselt.be/jori/page/CS/Emiplib.html
• http://research.edm.uhasselt.be/~emiplib/
• https://github.com/j0r1/EMIPLIB

rtmp

RTMP是Real Time Messaging Protocol（实时消息传输协议）的首字母缩写。该协议基于TCP，是一个协议族，包括RTMP基本协议及RTMPT/RTMPS/RTMPE等多种变种。RTMP是一种设计用来进行实时数据通信的网络协议，主要用来在Flash/AIR平台和支持RTMP协议的流媒体/交互服务器之间进行音视频和数据通信。支持该协议的软件包括Adobe Media Server/Ultrant Media Server/red5等。

MainConcept

对视频进行编解码，安装文件在“第三方安装程序”目录

简介

curl

https://github.com/curl/curl

libcurl/

https://curl.haxx.se/download.html

https://curl.haxx.se/libcurl/c/example.html

libcurl作为是一个多协议的便于客户端使用的URL传输库，基于C语言，提供C语言的API接口，支持DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, POP3, POP3S, RTMP, RTSP, SCP, SFTP, SMTP, SMTPS, Telnet and TFTP这些协议，同时支持使用SSL证书的安全文件传输：HTTP POST, HTTP PUT, FTP 上传, 基于HTTP形式的上传、代理、Cookies、用户加密码的认证等多种应用场景。另外，libcurl是一个高移植性的库，能在绝大多数系统上运行，包括Solaris, NetBSD, FreeBSD, OpenBSD, Darwin, HPUX, IRIX, AIX, Tru64, Linux, UnixWare, HURD, Windows, Amiga, OS/2, BeOs, Mac OS X, Ultrix, QNX, OpenVMS, RISC OS, Novell NetWare, DOS等。

下载

https://curl.haxx.se/download/curl-7.60.0.tar.gz

https://www.gitbook.com/download/pdf/book/bagder/everything-curl

编译

项目支持Visual C++ v6.0 to v15.0

项目sln文件在curl-7.60.0\projects目录

依赖第三方库：OpenSSL, wolfSSL and SSH2 需要另外下载编译

OpenSSL

OpenSSL需要ActivePerl

build-openssl.bat支持openssl-1.0.2

build-openssl.bat vc10 x86 release

流程

主要函数

https://curl.haxx.se/libcurl/c/

curl_global_init 初始化libcrl

CURLcode curl_global_init(long flags);

flags参数取值范围

CURL_GLOBAL_ALL    初始化所有可能的调用
CURL_GLOBAL_SSL    初始化支持安全套接字层的调用
CURL_GLOBAL_WIN32    初始化WIN32套接字库
CURL_GLOBAL_NOTHING    没有额外的初始化要求

虽然libcurl是线程安全的，但curl_global_init是不能保证线程安全的，所以不要在每个线程中都调用curl_global_init，应该将该函数的调用放在主线程中。

curl_easy_init() 获取CURL操作符

CURL *curl_easy_init( );

初始化一个CURL的指针(有些像返回FILE类型的指针一样). 相应的在调用结束时要用curl_easy_cleanup函数清理.

curl_easy_setopt() 设置传输选项

CURLcode curl_easy_setopt(CURL *handle, CURLoption option, parameter);

可指定libcurl的工作方式或程序运行中改变其工作方式，实现回调函数以完成用户特定任务。

参数CURLoption

CURLOPT_URL

设置访问URL

CURLOPT_WRITEFUNCTION，CURLOPT_WRITEDATA

回调函数原型为：size_t function( void *ptr, size_t size, size_t nmemb, void *stream); 函数将在libcurl接收到数据后被调用，因此函数多做数据保存的功能，如处理下载文件。CURLOPT_WRITEDATA 用于表明CURLOPT_WRITEFUNCTION函数中的stream指针的来源。

如果你没有通过CURLOPT_WRITEFUNCTION属性给easy handle设置回调函数，libcurl会提供一个默认的回调函数，它只是简单的将接收到的数据打印到标准输出。你也可以通过 CURLOPT_WRITEDATA属性给默认回调函数传递一个已经打开的文件指针，用于将数据输出到文件里。

CURLOPT_HEADERFUNCTION，CURLOPT_HEADERDATA

回调函数原型为 size_t function( void *ptr, size_t size,size_t nmemb, void *stream); libcurl一旦接收到http 头部数据后将调用该函数。CURLOPT_WRITEDATA 传递指针给libcurl，该指针表明CURLOPT_HEADERFUNCTION 函数的stream指针的来源。

CURLOPT_READFUNCTION CURLOPT_READDATA

libCurl需要读取数据传递给远程主机时将调用CURLOPT_READFUNCTION指定的函数，函数原型是：size_t function(void *ptr, size_t size, size_t nmemb,void *stream). CURLOPT_READDATA 表明CURLOPT_READFUNCTION函数原型中的stream指针来源。

CURLOPT_NOPROGRESS，CURLOPT_PROGRESSFUNCTION，CURLOPT_PROGRESSDATA

跟数据传输进度相关的参数。CURLOPT_PROGRESSFUNCTION 指定的函数正常情况下每秒被libcurl调用一次，为了使CURLOPT_PROGRESSFUNCTION被调用，CURLOPT_NOPROGRESS必须被设置为false，CURLOPT_PROGRESSDATA指定的参数将作为CURLOPT_PROGRESSFUNCTION指定函数的第一个参数

CURLOPT_TIMEOUT，CURLOPT_CONNECTIONTIMEOUT

CURLOPT_TIMEOUT 由于设置传输时间，CURLOPT_CONNECTIONTIMEOUT 设置连接等待时间

CURLOPT_FOLLOWLOCATION

设置重定位URL

CURLOPT_RANGE: CURLOPT_RESUME_FROM

断点续传相关设置。CURLOPT_RANGE 指定char *参数传递给libcurl，用于指明http域的RANGE头域，例如：

表示头500个字节：bytes=0-499
表示第二个500字节：bytes=500-999
表示最后500个字节：bytes=-500
表示500字节以后的范围：bytes=500-
第一个和最后一个字节：bytes=0-0,-1
同时指定几个范围：bytes=500-600,601-999

CURLOPT_RESUME_FROM 传递一个long参数给libcurl，指定你希望开始传递的 偏移量。

参数parameter

parameter 这个参数 既可以是个函数的指针,也可以是某个对象的指针,也可以是个long型的变量.它用什么这取决于第二个参数.

curl_easy_perform() 实现传输任务

CURLcode curl_easy_perform(CURL * easy_handle );

返回0意味一切ok，非0代表错误发生。主要错误码说明：

CURLE_OK    任务完成一切都好
CURLE_UNSUPPORTED_PROTOCOL    不支持的协议，由URL的头部指定
CURLE_COULDNT_CONNECT    不能连接到remote 主机或者代理
CURLE_REMOTE_ACCESS_DENIED    访问被拒绝
CURLE_HTTP_RETURNED_ERROR    Http返回错误
CURLE_READ_ERROR    读本地文件错误

要获取详细的错误描述字符串，可以通过const char *curl_easy_strerror(CURLcode errornum ) 这个函数取得.

https://curl.haxx.se/libcurl/c/libcurl-errors.html

curl_easy_cleanup() 释放内存

curl_easy_cleanup() 

char *curl_version( )

char *curl_version( );

打印当前libcurl库的版本。

curl_slist_append与curl_slist_free_all

设置消息头

CURL *handle;
struct curl_slist *slist=NULL;

slist = curl_slist_append(slist, "pragma:");

if (slist == NULL)
  return -1;

curl_easy_setopt(handle, CURLOPT_HTTPHEADER, slist);

curl_easy_perform(handle);

curl_slist_free_all(slist); /* free the list again */

curl_easy_getinfo

获取的是应答头中特定的信息，这个函数还能获取curl的一些内部信息，如请求时间、连接时间等等。

CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ... );

中文乱码

获取的网页内容如果是UTF_8编码，需要转换为GBK编码

std::string UTF8ToGBK(const std::string& strUTF8)    
{    
    int len = MultiByteToWideChar(CP_UTF8, 0, strUTF8.c_str(), -1, NULL, 0);    
    WCHAR* wszGBK = new WCHAR[len+1];  
    memset(wszGBK, 0, len * 2 + 2);    
    MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)(LPCTSTR)strUTF8.c_str(), -1, wszGBK, len);    

    len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);    
    char *szGBK = new char[len + 1];    
    memset(szGBK, 0, len + 1);    
    WideCharToMultiByte(CP_ACP,0, wszGBK, -1, szGBK, len, NULL, NULL);     
    std::string strTemp(szGBK);    
    delete[]szGBK;    
    delete[]wszGBK;    
    return strTemp;    
} 

std::string GBKToUTF8(const std::string& strGBK)  
{  
    std::string strOutUTF8 = "";  
    WCHAR * str1;  
    int n = MultiByteToWideChar(CP_ACP, 0, strGBK.c_str(), -1, NULL, 0);  
    str1 = new WCHAR[n];  
    MultiByteToWideChar(CP_ACP, 0, strGBK.c_str(), -1, str1, n);  
    n = WideCharToMultiByte(CP_UTF8, 0, str1, -1, NULL, 0, NULL, NULL);  
    char * str2 = new char[n];  
    WideCharToMultiByte(CP_UTF8, 0, str1, -1, str2, n, NULL, NULL);  
    strOutUTF8 = str2;  
    delete[]str1;  
    str1 = NULL;  
    delete[]str2;  
    str2 = NULL;  
    return strOutUTF8;  
}

使用LibIconv

所需文件

iconv.exe
libcharset1.dll
libiconv2.dll
libintl3.dll

命令行

curl https://www.baidu.com | iconv.exe -f utf-8 -t gbk

代码：

int covert(char *desc, char *src, char *input, size_t ilen, char *output, size_t olen)
{
    char **pin = &input;
    char **pout = &output;
    iconv_t cd = iconv_open(desc, src);
    if (cd == (iconv_t)-1)
    {
        return -1;
    }
    memset(output, 0, olen);
    if (iconv(cd, (const char **)pin, &ilen, pout, &olen)) return -1;
    iconv_close(cd);
    return 0;
}

char *input = "中国";
size_t len = strlen(input);
char *output = (char *)malloc(OUTLEN);
covert("UTF-8", "GBK", input, len, output, OUTLEN);
printf("%s\n", output);

参考

libcurl库（C++）快速使用

C++ 用libcurl库进行http通讯网络编程

https://blog.csdn.net/tianzhaixing2013/article/details/74726040

http://my.huhoo.net/archives/2008/02/libiconv.html