规范
C++文件名和类名保持一致
好处：代码整体结构清晰、明了。java里强制如此。
类型命名采用大驼峰
比如：UrlEncoder
FileParser
优先使用 头文件中的基本类型
如：
有符号类型 无符号类型 描述
int8_t uint8_t 宽度恰为8的有/无符号整数类型
int16_t uint16_t 宽度恰为16的有/无符号整数类型
int32_t uint32_t 宽度恰为32的有/无符号整数类型
int64_t uint64_t 宽度恰为64的有/无符号整数类型
intptr_t uintptr_t 足以保存指针的有/无符号整数类型
尽量不要使用int、long等，因为其宽度取决于操作系统和编译器。比如long可能是32bit或64bit。
少用全局变量
使用单例，封装性更好。
条件/循环语句必须要使用大括号
在已有条件/循环语句代码上增加新代码时不容易出错
switch语句要有default分支，除非switch的条件变量是枚举类型
switch语句中要有default分支，保证在遗漏case标签处理时能够有一个缺省的处理行为。
如果switch条件变量是枚举类型，加上default分支处理有些多余，现代编译器都具备检查是否在switch语句中遗漏了某些枚举值的case分支的能力，会有相应的warning提示。 另外，加上default分支处理，一些静态代码分析工具会报告default分支是死代码（deadcode）的warning。java也有这种情况。
不允许使用魔鬼数字
缺点：没有任何业务含义；修改麻烦
//xx
const MAX_VALUE = 120; //xx
if (a > MAX_VALUE )
if(b < MAX_VALUE )
不用的代码段直接删除，不要注释掉
现在有git、svn这样的版本管理工具，删掉也不怕丢失。
所有头文件都应当使用#define 防止头文件被多重包含
#ifndef VOS_INCLUDE_TIMER_TIMER_H
#define VOS_INCLUDE_TIMER_TIMER_H
...
#endif
.h文件用于声明需对外公开的类与接口，若没有对外接口，.h文件可不要
头文件包含顺序按照稳定度排序
建议按照稳定度排序：
- cpp对应的头文件
- C/C++标准库
- 系统库的.h
- 其他库的.h
- 本项目内的.h
举例来说，Foo.cpp中包含头文件的次序如下:：
#include "Foo/Foo.h"
#include <cstdlib>
#include <string>
#include <linux/list.h>
#include <linux/time.h>
#include "platform/Base.h"
#include "platform/Framework.h"
#include "project/public/Log.h"
不要在头文件中或者#include之前使用using指示符
原因：容易造成符号冲突。
在CPP文件的实现代码处可以视情况使用。
类的成员变量必须显式初始化
这跟java是不同的，java里类的成员变量会由编译器自动初始化。
若不使用拷贝构造函数或赋值操作符，使用private修饰，且不实现
class Foo {
private:Foo(const Foo&);Foo& operator=(const Foo&);
};
C++11下也可用delete关键字（注意这里的修饰符是public）：
class Foo {
public:Foo(const Foo&) = delete;Foo& operator=(const Foo&) = delete;
};
禁止在构造函数和析构函数中调用虚函数
结果不可知。
比如在基类的构造函数里调用虚函数，有可能触发派生类的构造，要知道这时候基类还没构造完呢。父之不存，子将焉附！
同样的道理，基类的析构函数调用虚函数，这个行为可能下放到派生类，但此时派生类已销毁了！（派生类销毁在基类之前，构造则在基类之后）。
基类的析构函数应该声明为public和virtual的
原因：只有基类析构函数是虚拟的，才能保证派生类的析构函数被调用。
输入参数使用引用取代指针，尽可能传递const应用
好处：引用肯定非空，避免繁琐的NULL检查。这是C++强于java的地方，java里即使引用也可能为null。
把：
f(A* a){
…
}
改成
f(const A& a) {
…
}
少用多重继承
因为多重继承使用过程中有下面的典型问题：
- 菱形继承所带来的数据重复，以及名字二义性。因此，C++引入了virtual继承来解决这类问题;
- 即便不是菱形继承，多个父类之间的名字也可能存在冲突，从而导致的二义性;
- 如果子类需要扩展或改写多个父类的方法时，造成子类的职责不明，语义混乱;
- 相对于委托，继承是一种白盒复用，即子类可以访问父类的protected成员, 这会导致更强的耦合。而多重继承，由于耦合了多个父类，相对于单根继承，这会产生更强的耦合关系。
多使用const来保证数据的不变性
数据不可变多安心啊，且并发编程下可以少费脑子去考虑锁的问题。
类型转换
dynamic_cast：downcast，类似于java的instanceof，尽量少用，往往是类的继承关系设计的不合理。
reinterpret_cast：这个就是强转，很危险。
const_cast：去掉数据的不可变性，不利于代码的稳定和并发操作
智能指针
f(A* a)
A* p = new A();
auto_ptr p(new A());
C++11普遍推广之前，为方便指针管理，一般要用auto_ptr。但这玩意也有缺点：它有一个隐式的所有权转移行为，容易出问题，比如不能放容器里、也不建议通过函数参数传递。
使用auto_ptr常见的有两种场景，一是作为智能指针传递到产生auto_ptr的函数外部，二是使用auto_ptr作为RAII管理类，在超出auto_ptr的生命周期时自动释放资源。 对于第1种场景，可以使用std::shared_ptr来代替。 对于第2种场景，可以
使用C++11标准中的std::unique_ptr来代替。其中std::unique_ptr是std::auto_ptr的代替品，支持显式的所有权转移。
具体到unique_ptr和shared_ptr，优先使用前者。因为：
- shared_ptr有专门的内存存放引用计数，有额外的开销；
- shared_ptr在循环依赖的时候，释放不了内存，参考python早期的垃圾回收问题
严格的说来，unique_ptr是C++14的标准，晚于shared_ptr。我们只需使用gcc5及以上的版本就没问题。
unique_ptr的使用
unique_ptr可以认为是“禁掉了隐式所有权转移的auto_ptr”（实现策略是禁用了拷贝构造和赋值运算符重载）。如果需要明确的所有权转移，使用std::move。所以有：
auto foo = std::make_unique<Foo>();
auto foo1 = foo; //Cannot compile!
auto foo2 = std::move(foo); //it's ok, foo has nothing now
不推荐复杂的模板编程
比如“模板元编程”，当年很痴迷，觉得很适合炫技，现在觉得太烧脑，代码不好维护。
auto
auto用于自动类型推断，本质上是一个类型占位符，而非真实的类型。可用于替代冗长的类型名（比如iterator）
注意：auto只能替代值类型，所以如果传一个引用给auto，它会自动去除引用，比如下面的例子：
class Foo
{
public:Foo() = default;Foo(const Foo&) = delete;Foo& operator=(const Foo&) = delete;void doSth(){std::cout << "do sth" << std::endl;}
};Foo s;
Foo& ref = s;
auto s1 = ref; //Cannot compile
要编译正确，需改成：
auto& s1 = ref;
override
这个是照抄了Java的@override注解，用于检查派生类的虚函数定义是否与基类一致，重构的时候能起一定的保护作用。
Lambda
Lambda有几个优点：
- 写起来简单
- 可以引用（C++里叫捕获）所在环境的局部变量（术语叫闭包，不过我更喜欢lua里的叫法：upvalue）
Lambda在Java里是使用匿名类来实现的，upvalue作为匿名类构造器的参数传递进来，从而做到长期持有，C++估计是类似的实现机制。由于java有gc，所以不用考虑upvalue生存周期的问题。但C++则不然，在C++里使用Lambda，我们引用的upvalue可能只是栈上的对象，在lambda执行时已经不存在了，这是需要特别注意的。
Lambda的形式：
[upvalue] (lambda参数) mutable|exception -> 返回值类型 {函数体}
upvalue（也叫函数对象参数）有以下形式：
- 空。没有任何函数对象参数。
- =。函数体内可以使用 Lambda 所在范围内所有可见的局部变量（包括 Lambda 所在类的 this），并且是值传递方式（相当于编译器自动为我们按值传递了所有局部变量）。
- &。函数体内可以使用 Lambda 所在范围内所有可见的局部变量（包括 Lambda 所在类的 this），并且是引用传递方式（相当于是编译器自动为我们按引用传递了所有局部变量）。
- this。函数体内可以使用 Lambda 所在类中的成员变量。
- a。将 a 按值进行传递。按值进行传递时，函数体内不能修改传递进来的 a 的拷贝，因为默认情况下函数是 const 的，要修改传递进来的拷贝，可以添加 mutable 修饰符。
- &a。将 a 按引用进行传递。
- a，&b。将 a 按值传递，b 按引用进行传递。
- =，&a，&b。除 a 和 b 按引用进行传递外，其他参数都按值进行传递。
- &，a，b。除 a 和 b 按值进行传递外，其他参数都按引用进行传递。
lambda参数有一点不好，必须明确给出参数类型，做不到自动推断（java和scala里都是可以自动推断的）。
返回值类型不是必给的，编译器可以推断出来。
一个例子：
std::vector<std::string> l, r;
l.push_back("e0");
l.push_back("e1");std::transform(l.begin(), l.end(), std::back_inserter(r), [](const std::string& v){return v + "_wrapper";});
std::for_each(r.begin(), r.end(), [](const std::string& v){std::cout << v << std::endl;});
