c++ 代码规范

格式

非 ASCII 字符

尽量不使用非 ASCII 字符，使用时必须使用 UTF-8 编码

空格还是制表符

只使用空格，每次缩进两个空格。
使用了 IDE 的，要把制表符设置为空格。同时设置一下：行尾不要留空格

函数定义与声明

类型1：返回类型和函数名在同一行, 参数也放在同一行

ReturnType ClassName::FunctionName(Type par1, Type par2) {
  DoSomething();
  ...
}

类型2：同一行文本太多, 放不下所有参数:

ReturnType ClassName::ReallyLongFunctionName(Type par1, Type par2,
                                             Type par3) {
  DoSomething();
  ...
}

类型3：甚至连第一个参数都放不下:

ReturnType LongClassName::ReallyReallyReallyLongFunctionName(
    Type par1,  // 4 space indent
    Type par2,
    Type par3) {
  DoSomething();  // 2 space indent
  ...
}

注意：

参数名要尽量表达出实际的意义和尽量的简短，要在这两者之间做平衡
如果返回类型和函数名在一行放不下, 可以分行(此时返回类型和函数名对齐，不要缩进)
左圆括号总是和函数名在同一行.
函数名和左圆括号间永远没有空格.
圆括号与参数间没有空格.
左大括号总在最后一个参数同一行的末尾处, 不另起新行.
右大括号总是单独位于函数最后一行, 或者与左大括号同一行.
右圆括号和左大括号间总是有一个空格.
所有形参应尽可能对齐.
缺省缩进为 2 个空格.
换行后的参数保持 4 个空格的缩进.

函数调用

方式1：一行写完函数调用

bool retval = DoSomething(argument1, argument2, argument3);

方式2：在圆括号里对参数分行

如果同一行放不下, 可断为多行, 后面每一行和第一个实参对齐, 左圆括号后和右圆括号前不要留空格：

bool retval = DoSomething(averyveryveryverylongargument1,
                          argument2, argument3);

方式3：参数另起一行且缩进四格

if (...) {
  ...
  ...
  if (...) {
    DoSomething(
        argument1, argument2,  // 4 空格缩进
        argument3, argument4);
  }

如果参数本身是略复杂的表达式, 可读性不好, 可以创建临时变量描述该表达式, 传递给函数：

int my_heuristic = scores[x] * y + bases[x];
bool retval = DoSomething(my_heuristic, x, y, z);

或者补充注释：

bool retval = DoSomething(scores[x] * y + bases[x],  // Score heuristic.
                          x, y, z);

如果参数独立成行, 对可读性更有帮助，可以独立成行

或者一系列参数本身有一定的结构, 可以按其结构来决定参数格式：

// 通过 3x3 矩阵转换 widget.
my_widget.Transform(x1, x2, x3,
                    y1, y2, y3,
                    z1, z2, z3);

总结：

参数的格式处理应当以可读性作为最重要的原则
不影响可读性的情况下，尽量精简行数

列表初始化格式

和函数调用格式保持一致

条件语句

if/else 和括号之间要有空格，圆括号和大括号之间也有空格

if (condition) {  // 圆括号里没有空格.
  ...  // 2 空格缩进.
} else if (...) {  // else 与 if 的右括号同一行.
  ...
} else {
  ...
}

如果能增强可读性, 简单条件语句允许写在同一行.
只有当语句简单且没有 else 子句时使用:

if (x == kFoo) return new Foo();
if (x == kBar) return new Bar();

单行语句可以不使用大括号，但是只要有一个分支使用了大括号，两个分支都要使用：

if (condition) {
  foo;
} else {
  bar;
}

循环和 switch 语句

switch 语句中的 case 块可以使用大括号也可以不用.

switch 应该总是包含一个 default 匹配. 如果 default 永远执行不到, 加 assert:

switch (var) {
  case 0: {  // 2 空格缩进
    ...      // 4 空格缩进
    break;
  }
  case 1: {
    ...
    break;
  }
  default: {
    assert(false);
  }
}

在单语句循环里, 括号可用可不用：
注意：关键字和圆括号之间有空格，圆括号和大括号之间有空格

for (int i = 0; i < kSomeNumber; ++i)
  printf("I love you\n");

for (int i = 0; i < kSomeNumber; ++i) {
  printf("I take it back\n");
}

指针和引用

下面是指针和引用表达式的正确使用范例:

x = *p;
p = &x;
x = r.y;
x = r->y;

注意:

在访问成员时, 句点或箭头前后没有空格.
指针操作符 * 或 & 后没有空格.

在声明指针变量或参数时, 星号与类型或变量名紧挨都可以:

// good, 空格前置.
char *c;
const string &str;

// good, 空格后置.
char* c;
const string& str;

// 不允许 - 在多重声明中不能使用 & 或 *。
// 此处是声明了一个 int 类型的变量 x 和一个 int 类型的指针 y，语法上可以通过编译，但是不推荐这么使用
int x, *y;  

char * c;  // 差 - * 两边都有空格
const string & str;  // 差 - & 两边都有空格.

布尔表达式

如果一个布尔表达式超过标准行宽, 断行方式要统一:
可以位于行首，也可以位于行尾，但是要统一

下例中, 逻辑与 (&&) 操作符总位于行尾:

if (this_one_thing > this_other_thing &&
    a_third_thing == a_fourth_thing &&
    yet_another && last_one) {
  ...
}

函数返回值

不要在 return 表达式里加上非必须的圆括号.

只有在写 x = expr 要加上括号的时候才在 return expr; 里使用括号.

// 返回值很简单, 不加圆括号.
return result;

// 复杂表达式可以加圆括号, 改善可读性。非必要不加
return (some_long_condition &&
        another_condition);

return (value);                // 不推荐
return(result);                // 不推荐

变量及数组初始化

用 =, () 和 {} 均可.

说明

您可以用 =, () 和 {}, 以下的例子都是正确的：

int x = 3;
int x(3);
int x{3};
string name("Some Name");
string name = "Some Name";
string name{"Some Name"};

请务必小心列表初始化 {...} 用 std::initializer_list 构造函数初始化出的类型. 非空列表初始化就会优先调用 std::initializer_list, 不过空列表初始化除外, 后者原则上会调用默认构造函数. 为了强制禁用 std::initializer_list 构造函数, 请改用括号.

vector<int> v(100, 1);  // 数组大小为 100， 每个值都是1
vector<int> v{100, 1};  // 数组大小是 2，一个值是 100， 一个值是 2

此外, 列表初始化不允许整型类型的四舍五入, 这可以用来避免一些类型上的编程失误.

int pi(3.14);  // 好 - pi == 3.
int pi{3.14};  // 编译错误: 缩窄转换.

预处理指令

预处理指令不要缩进, 从行首开始.

即使预处理指令位于缩进代码块中, 指令也应从行首开始

// 好 - 指令从行首开始
  if (lopsided_score) {
#if DISASTER_PENDING      // 正确 - 从行首开始
    DropEverything();
# if NOTIFY               // 非必要 - # 后跟空格
    NotifyClient();
# endif
#endif
    BackToNormal();
  }

类格式

public 放在最前面, 然后是 protected, 最后是 private.

命名空间

命名空间内容不缩进

namespace {

void foo() {  // 正确. 命名空间内没有额外的缩进.
  ...
}

}  // namespace

声明嵌套命名空间时, 每个命名空间都独立成行.

namespace foo {
namespace bar {

} // namespace bar
} // namespace foo

水平留白

void f(bool b) {  // 左大括号前总是有空格.
  ...
int i = 0;  // 分号前不加空格.
// 列表初始化中大括号内的空格是可选的.
// 如果加了空格, 那么两边都要加上.
int x[] = { 0 };
int x[] = {0};

// 继承与初始化列表中的冒号前后恒有空格.
class Foo : public Bar {
 public:
  // 对于单行函数的实现, 在大括号内加上空格
  // 然后是函数实现
  Foo(int b) : Bar(), baz_(b) {}  // 大括号里面是空的话, 不加空格.
  void Reset() { baz_ = 0; }  // 用空格把大括号与实现分开.
  ...

行尾不要留空格

循环和条件语句

if (b) {          // if 条件语句和循环语句关键字后均有空格.
} else {          // else 前后有空格.
}
while (test) {}   // 圆括号内部不紧邻空格.

for (int i = 0; i < 5; ++i) { // 运算符有空格
}

switch (i) {
  case 1:         // switch case 的冒号前无空格.
    ...
  case 2: break;  // 如果冒号后有代码, 加个空格.
}

操作符：

// 赋值运算符前后总是有空格.
x = 0;

// 其它二元操作符也前后恒有空格
v = w * x + y / z;
v = w * (x + z);

// 在参数和一元操作符之间不加空格.
x = -5;
++x;
if (x && !y)
  ...

模板和转换

// 尖括号(< and >) 不与空格紧邻, < 前没有空格, > 和 ( 之间也没有.
vector<string> x;
y = static_cast<char*>(x);

// 在类型与指针操作符之间留空格也可以, 但要保持一致.
vector<char *> x;

垂直留白

类、函数等之间要留垂直留白。

class A {
};

class B {
};

void func1() {
}

void func2() {
}

垂直留白最多一行

命名约定

命名规则的关键在于一致性，很多时候没有好坏之分，重要的是一个项目内要保持一致。

所有的命名的关键：尽可能表达清楚含义和尽可能简短

文件命名

头文件以 .h 结尾
能被外界看到的，以 lib + 包名 + 下划线 + 描述命名，如：libdm_cell.h
只供内部使用的：包名 + 描述，以小驼峰命名方式如 dmGdsPasser.h

源文件以 .cc 结尾
包名 + 描述，以小驼峰命名方式如 dmGdsPasser.cc，dmCell.cc

类型命名

类名称、结构体名称：小驼峰命名
枚举、别名：大驼峰方式命名

变量命名

普通变量：小驼峰
成员变量：下划线 + 小驼峰
常量：全部大写

类静态成员变量：前缀 s_

头文件

头文件要可以独立编译

防止重复导入

推荐用方式2

方式1: `#define`

防止重定义，格式是：<项目>_<路径>_<文件名>_H_

如, foo 项目中的文件 foo/src/bar/baz.h 应该有如下防护:

#ifndef FOO_BAR_BAZ_H_
#define FOO_BAR_BAZ_H_
...
#endif  // FOO_BAR_BAZ_H_

优势： 所有的 c++ 编译器都支持

方式2：`#pragma once`

优势:

编译速度更快

编译器只需记住已包含的文件路径，不需要解析整个文件内容

不需要进行宏定义检查（免去了预处理器的符号表查找）

对于大型项目，可减少5-10%的编译时间（根据项目结构和编译器不同）
减少预处理标记

不需要生成和检查宏定义

预处理器工作量更小
避免宏命名冲突

传统方式需要确保每个头文件的保护宏名称唯一

缺点：

只保证同一个文件不会被包含多次，当两个文件内容一样时，还是会有重定义的问题。
某些老的编译器可能不支持

导入依赖

.cc 文件

使用了其它地方定义的符号，要直接 #include 该符号声明或定义的头文件。
不要依赖间接导入. 这样, 人们删除不再需要的 #include 语句时, 才不会影响使用者. 此规则也适用于配套的文件: 若 foo.cc 使用了 bar.h 的符号, 就需要导入 bar.h, 即使 foo.h 已经导入了 bar.h

.h 文件

对于能用前置声明的，尽量用前置声明

内联函数

只把 10 行以下的函数定义为内联函数。不要内联有循环或 switch 语句的函数

头文件 #include 的顺序

推荐按照以下顺序导入头文件: 配套的头文件, C 语言系统库头文件, C++ 标准库头文件, 其他库的头文件, 本项目的头文件.

posted @ 2025-04-28 11:44 卑以自牧lq 阅读(32) 评论(0) 收藏举报

刷新页面返回顶部

c++ 代码规范

c++ 代码规范

格式

非 ASCII 字符

空格还是制表符

函数定义与声明

函数调用

列表初始化格式

条件语句

循环和 switch 语句

指针和引用

布尔表达式

函数返回值

变量及数组初始化

预处理指令

类格式

命名空间

水平留白

垂直留白

命名约定

文件命名

类型命名

变量命名

头文件

头文件要可以独立编译

防止重复导入

方式1: #define

方式2：#pragma once

导入依赖

.cc 文件

.h 文件

内联函数

头文件 #include 的顺序

公告

方式1: `#define`

方式2：`#pragma once`