C++编码规范解读

规范

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) {

...

}

少用多重继承

因为多重继承使用过程中有下面的典型问题：

1. 菱形继承所带来的数据重复，以及名字二义性。因此，C++引入了virtual继承来解决这类问题;
2. 即便不是菱形继承，多个父类之间的名字也可能存在冲突，从而导致的二义性;
3. 如果子类需要扩展或改写多个父类的方法时，造成子类的职责不明，语义混乱;
4. 相对于委托，继承是一种白盒复用，即子类可以访问父类的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;});