document/zh-google-styleguide
2
0
Fork 0
mirror of https://github.com/zh-google-styleguide/zh-google-styleguide.git synced 2025-02-19 20:50:10 +08:00
Code Issues Packages Projects Releases Wiki Activity
60c840e5c6
zh-google-styleguide/google-cpp-styleguide/formatting.rst

871 lines
28 KiB
ReStructuredText
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

9. 格式
------------
每个人都可能有自己的代码风格和格式, 但如果一个项目中的所有人都遵循同一风格的话, 这个项目就能更顺利地进行. 每个人未必能同意下述的每一处格式规则, 而且其中的不少规则需要一定时间的适应, 但整个项目服从统一的编程风格是很重要的, 只有这样才能让所有人轻松地阅读和理解代码.
为了帮助你正确的格式化代码, 我们写了一个 `emacs 配置文件 <http://google-styleguide.googlecode.com/svn/trunk/google-c-style.el>`_.
.. _line-length:
9.1. 行长度
~~~~~~~~~~~~~~~~~~~~
**总述**
每一行代码字符数不超过 80.
我们也认识到这条规则是有争议的, 但很多已有代码都遵照这一规则, 因此我们感觉一致性更重要.
**优点**
提倡该原则的人认为强迫他们调整编辑器窗口大小是很野蛮的行为. 很多人同时并排开几个代码窗口, 根本没有多余的空间拉伸窗口. 大家都把窗口最大尺寸加以限定, 并且 80 列宽是传统标准. 那么为什么要改变呢?
**缺点**
反对该原则的人则认为更宽的代码行更易阅读. 80 列的限制是上个世纪 60 年代的大型机的古板缺陷; 现代设备具有更宽的显示屏, 可以很轻松地显示更多代码.
**结论**
80 个字符是最大值.
如果无法在不伤害易读性的条件下进行断行, 那么注释行可以超过 80 个字符, 这样可以方便复制粘贴. 例如, 带有命令示例或 URL 的行可以超过 80 个字符.
包含长路径的 ``#include`` 语句可以超出80列.
:ref:`头文件保护 <define-guard>` 可以无视该原则.
9.2. 非 ASCII 字符
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
尽量不使用非 ASCII 字符, 使用时必须使用 UTF-8 编码.
**说明**
即使是英文, 也不应将用户界面的文本硬编码到源代码中, 因此非 ASCII 字符应当很少被用到. 特殊情况下可以适当包含此类字符. 例如, 代码分析外部数据文件时, 可以适当硬编码数据文件中作为分隔符的非 ASCII 字符串; 更常见的是 (不需要本地化的) 单元测试代码可能包含非 ASCII 字符串. 此类情况下, 应使用 UTF-8 编码, 因为很多工具都可以理解和处理 UTF-8 编码.
十六进制编码也可以, 能增强可读性的情况下尤其鼓励 —— 比如 ``"\xEF\xBB\xBF"``, 或者更简洁地写作 ``u8"\uFEFF"``, 在 Unicode 中是 *零宽度 无间断* 的间隔符号, 如果不用十六进制直接放在 UTF-8 格式的源文件中, 是看不到的.
(Yang.Y 注: ``"\xEF\xBB\xBF"`` 通常用作 UTF-8 with BOM 编码标记)
使用 ``u8`` 前缀把带 ``uXXXX`` 转义序列的字符串字面值编码成 UTF-8. 不要用在本身就带 UTF-8 字符的字符串字面值上, 因为如果编译器不把源代码识别成 UTF-8, 输出就会出错.
别用 C++11 的 ``char16_t`` 和 ``char32_t``, 它们和 UTF-8 文本没有关系, ``wchar_t`` 同理, 除非你写的代码要调用 Windows API, 后者广泛使用了 ``wchar_t``.
9.3. 空格还是制表位
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
只使用空格, 每次缩进 2 个空格.
**说明**
我们使用空格缩进. 不要在代码中使用制表符. 你应该设置编辑器将制表符转为空格.
9.4. 函数声明与定义
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
返回类型和函数名在同一行, 参数也尽量放在同一行, 如果放不下就对形参分行, 分行方式与 :ref:`函数调用 <function-calls>` 一致.
**说明**
函数看上去像这样:
.. code-block:: c++
ReturnType ClassName::FunctionName(Type par_name1, Type par_name2) {
DoSomething();
...
}
如果同一行文本太多, 放不下所有参数:
.. code-block:: c++
ReturnType ClassName::ReallyLongFunctionName(Type par_name1, Type par_name2,
Type par_name3) {
DoSomething();
...
}
甚至连第一个参数都放不下:
.. code-block:: c++
ReturnType LongClassName::ReallyReallyReallyLongFunctionName(
Type par_name1, // 4 space indent
Type par_name2,
Type par_name3) {
DoSomething(); // 2 space indent
...
}
注意以下几点:
- 使用好的参数名.
- 只有在参数未被使用或者其用途非常明显时, 才能省略参数名.
- 如果返回类型和函数名在一行放不下, 分行.
- 如果返回类型与函数声明或定义分行了, 不要缩进.
- 左圆括号总是和函数名在同一行.
- 函数名和左圆括号间永远没有空格.
- 圆括号与参数间没有空格.
- 左大括号总在最后一个参数同一行的末尾处, 不另起新行.
- 右大括号总是单独位于函数最后一行, 或者与左大括号同一行.
- 右圆括号和左大括号间总是有一个空格.
- 所有形参应尽可能对齐.
- 缺省缩进为 2 个空格.
- 换行后的参数保持 4 个空格的缩进.
未被使用的参数, 或者根据上下文很容易看出其用途的参数, 可以省略参数名:
.. code-block:: c++
class Foo {
public:
Foo(Foo&&);
Foo(const Foo&);
Foo& operator=(Foo&&);
Foo& operator=(const Foo&);
};
未被使用的参数如果其用途不明显的话, 在函数定义处将参数名注释起来:
.. code-block:: c++
class Shape {
public:
virtual void Rotate(double radians) = 0;
};
class Circle : public Shape {
public:
void Rotate(double radians) override;
};
void Circle::Rotate(double /*radians*/) {}
.. code-block:: c++
// 差 - 如果将来有人要实现, 很难猜出变量的作用.
void Circle::Rotate(double) {}
属性, 和展开为属性的宏, 写在函数声明或定义的最前面, 即返回类型之前:
.. code-block:: c++
MUST_USE_RESULT bool IsOK();
9.5. Lambda 表达式
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
Lambda 表达式对形参和函数体的格式化和其他函数一致; 捕获列表同理, 表项用逗号隔开.
**说明**
若用引用捕获, 在变量名和 ``&`` 之间不留空格.
.. code-block:: c++
int x = 0;
auto add_to_x = [&x](int n) { x += n; };
短 lambda 就写得和内联函数一样.
.. code-block:: c++
std::set<int> blacklist = {7, 8, 9};
std::vector<int> digits = {3, 9, 1, 8, 4, 7, 1};
digits.erase(std::remove_if(digits.begin(), digits.end(), [&blacklist](int i) {
return blacklist.find(i) != blacklist.end();
}),
digits.end());
.. _function-calls:
9.6. 函数调用
~~~~~~~~~~~~~~~~~~~~~~
**总述**
要么一行写完函数调用, 要么在圆括号里对参数分行, 要么参数另起一行且缩进四格. 如果没有其它顾虑的话, 尽可能精简行数, 比如把多个参数适当地放在同一行里.
**说明**
函数调用遵循如下形式：
.. code-block:: c++
bool retval = DoSomething(argument1, argument2, argument3);
如果同一行放不下, 可断为多行, 后面每一行都和第一个实参对齐, 左圆括号后和右圆括号前不要留空格：
.. code-block:: c++
bool retval = DoSomething(averyveryveryverylongargument1,
argument2, argument3);
参数也可以放在次行, 缩进四格：
.. code-block:: c++
if (...) {
...
...
if (...) {
DoSomething(
argument1, argument2, // 4 空格缩进
argument3, argument4);
}
把多个参数放在同一行以减少函数调用所需的行数, 除非影响到可读性. 有人认为把每个参数都独立成行, 不仅更好读, 而且方便编辑参数. 不过, 比起所谓的参数编辑, 我们更看重可读性, 且后者比较好办：
如果一些参数本身就是略复杂的表达式, 且降低了可读性, 那么可以直接创建临时变量描述该表达式, 并传递给函数：
.. code-block:: c++
int my_heuristic = scores[x] * y + bases[x];
bool retval = DoSomething(my_heuristic, x, y, z);
或者放着不管, 补充上注释：
.. code-block:: c++
bool retval = DoSomething(scores[x] * y + bases[x], // Score heuristic.
x, y, z);
如果某参数独立成行, 对可读性更有帮助的话, 那也可以如此做. 参数的格式处理应当以可读性而非其他作为最重要的原则.
此外, 如果一系列参数本身就有一定的结构, 可以酌情地按其结构来决定参数格式：
.. code-block:: c++
// 通过 3x3 矩阵转换 widget.
my_widget.Transform(x1, x2, x3,
y1, y2, y3,
z1, z2, z3);
.. _braced-initializer-list-format
9.7. 列表初始化格式
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
您平时怎么格式化函数调用, 就怎么格式化 :ref:`列表初始化 <braced-initializer-list>`.
**说明**
如果列表初始化伴随着名字, 比如类型或变量名, 格式化时将将名字视作函数调用名, `{}` 视作函数调用的括号. 如果没有名字, 就视作名字长度为零.
.. code-block:: c++
// 一行列表初始化示范.
return {foo, bar};
functioncall({foo, bar});
pair<int, int> p{foo, bar};
// 当不得不断行时.
SomeFunction(
{"assume a zero-length name before {"}, // 假设在 { 前有长度为零的名字.
some_other_function_parameter);
SomeType variable{
some, other, values,
{"assume a zero-length name before {"}, // 假设在 { 前有长度为零的名字.
SomeOtherType{
"Very long string requiring the surrounding breaks.", // 非常长的字符串, 前后都需要断行.
some, other values},
SomeOtherType{"Slightly shorter string", // 稍短的字符串.
some, other, values}};
SomeType variable{
"This is too long to fit all in one line"}; // 字符串过长, 因此无法放在同一行.
MyType m = { // 注意了, 您可以在 { 前断行.
superlongvariablename1,
superlongvariablename2,
{short, interior, list},
{interiorwrappinglist,
interiorwrappinglist2}};
9.9. 条件语句
~~~~~~~~~~~~~~~~~~~~~~
**总述**
倾向于不在圆括号内使用空格. 关键字 ``if`` 和 ``else`` 另起一行.
**说明**
对基本条件语句有两种可以接受的格式. 一种在圆括号和条件之间有空格, 另一种没有.
最常见的是没有空格的格式. 哪一种都可以, 最重要的是 *保持一致*. 如果你是在修改一个文件, 参考当前已有格式. 如果是写新的代码, 参考目录下或项目中其它文件. 还在犹豫的话, 就不要加空格了.
.. code-block:: c++
if (condition) { // 圆括号里没有空格.
... // 2 空格缩进.
} else if (...) { // else 与 if 的右括号同一行.
...
} else {
...
}
如果你更喜欢在圆括号内部加空格:
.. code-block:: c++
if ( condition ) { // 圆括号与空格紧邻 - 不常见
... // 2 空格缩进.
} else { // else 与 if 的右括号同一行.
...
}
注意所有情况下 ``if`` 和左圆括号间都有个空格. 右圆括号和左大括号之间也要有个空格:
.. code-block:: c++
if(condition) // 差 - IF 后面没空格.
if (condition){ // 差 - { 前面没空格.
if(condition){ // 变本加厉地差.
.. code-block:: c++
if (condition) { // 好 - IF 和 { 都与空格紧邻.
如果能增强可读性, 简短的条件语句允许写在同一行. 只有当语句简单并且没有使用 ``else`` 子句时使用:
.. code-block:: c++
if (x == kFoo) return new Foo();
if (x == kBar) return new Bar();
如果语句有 ``else`` 分支则不允许:
.. code-block:: c++
// 不允许 - 当有 ELSE 分支时 IF 块却写在同一行
if (x) DoThis();
else DoThat();
通常, 单行语句不需要使用大括号, 如果你喜欢用也没问题; 复杂的条件或循环语句用大括号可读性会更好. 也有一些项目要求 ``if`` 必须总是使用大括号:
.. code-block:: c++
if (condition)
DoSomething(); // 2 空格缩进.
if (condition) {
DoSomething(); // 2 空格缩进.
}
但如果语句中某个 ``if-else`` 分支使用了大括号的话, 其它分支也必须使用:
.. code-block:: c++
// 不可以这样子 - IF 有大括号 ELSE 却没有.
if (condition) {
foo;
} else
bar;
// 不可以这样子 - ELSE 有大括号 IF 却没有.
if (condition)
foo;
else {
bar;
}
.. code-block:: c++
// 只要其中一个分支用了大括号, 两个分支都要用上大括号.
if (condition) {
foo;
} else {
bar;
}
9.9. 循环和开关选择语句
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
``switch`` 语句可以使用大括号分段, 以表明 cases 之间不是连在一起的. 在单语句循环里, 括号可用可不用. 空循环体应使用 ``{}`` 或 ``continue``.
**说明**
``switch`` 语句中的 ``case`` 块可以使用大括号也可以不用, 取决于你的个人喜好. 如果用的话, 要按照下文所述的方法.
如果有不满足 ``case`` 条件的枚举值, ``switch`` 应该总是包含一个 ``default`` 匹配 (如果有输入值没有 case 去处理, 编译器将给出 warning). 如果 ``default`` 应该永远执行不到, 简单的加条 ``assert``:
.. code-block:: c++
switch (var) {
case 0: { // 2 空格缩进
... // 4 空格缩进
break;
}
case 1: {
...
break;
}
default: {
assert(false);
}
}
在单语句循环里, 括号可用可不用：
.. code-block:: c++
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");
}
空循环体应使用 ``{}`` 或 ``continue``, 而不是一个简单的分号.
.. code-block:: c++
while (condition) {
// 反复循环直到条件失效.
}
for (int i = 0; i < kSomeNumber; ++i) {} // 可 - 空循环体.
while (condition) continue; // 可 - contunue 表明没有逻辑.
.. code-block:: c++
while (condition); // 差 - 看起来仅仅只是 while/loop 的部分之一.
9.10. 指针和引用表达式
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
句点或箭头前后不要有空格. 指针/地址操作符 (``*, &``) 之后不能有空格.
**说明**
下面是指针和引用表达式的正确使用范例:
.. code-block:: c++
x = *p;
p = &x;
x = r.y;
x = r->y;
注意:
- 在访问成员时, 句点或箭头前后没有空格.
- 指针操作符 ``*`` 或 ``&`` 后没有空格.
在声明指针变量或参数时, 星号与类型或变量名紧挨都可以:
.. code-block:: c++
// 好, 空格前置.
char *c;
const string &str;
// 好, 空格后置.
char* c;
const string& str;
.. code-block:: c++
int x, *y; // 不允许 - 在多重声明中不能使用 & 或 *
char * c; // 差 - * 两边都有空格
const string & str; // 差 - & 两边都有空格.
在单个文件内要保持风格一致, 所以, 如果是修改现有文件, 要遵照该文件的风格.
9.11. 布尔表达式
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
如果一个布尔表达式超过 :ref:`标准行宽 <line-length>`, 断行方式要统一一下.
**说明**
下例中, 逻辑与 (``&&``) 操作符总位于行尾:
.. code-block:: c++
if (this_one_thing > this_other_thing &&
a_third_thing == a_fourth_thing &&
yet_another && last_one) {
...
}
注意, 上例的逻辑与 (``&&``) 操作符均位于行尾. 这个格式在 Google 里很常见, 虽然把所有操作符放在开头也可以. 可以考虑额外插入圆括号, 合理使用的话对增强可读性是很有帮助的. 此外, 直接用符号形式的操作符, 比如 ``&&`` 和 ``~``, 不要用词语形式的 ``and`` 和 ``compl``.
9.12. 函数返回值
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
不要在 ``return`` 表达式里加上非必须的圆括号.
**说明**
只有在写 ``x = expr`` 要加上括号的时候才在 ``return expr;`` 里使用括号.
.. code-block:: c++
return result; // 返回值很简单, 没有圆括号.
// 可以用圆括号把复杂表达式圈起来, 改善可读性.
return (some_long_condition &&
another_condition);
.. code-block:: c++
return (value); // 毕竟您从来不会写 var = (value);
return(result); // return 可不是函数！
9.13. 变量及数组初始化
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
用 ``=``, ``()`` 和 ``{}`` 均可.
**说明**
您可以用 ``=``, ``()`` 和 ``{}``, 以下的例子都是正确的：
.. code-block:: c++
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`` 构造函数, 请改用括号.
.. code-block:: c++
vector<int> v(100, 1); // 内容为 100 个 1 的向量.
vector<int> v{100, 1}; // 内容为 100 和 1 的向量.
此外, 列表初始化不允许整型类型的四舍五入, 这可以用来避免一些类型上的编程失误.
.. code-block:: c++
int pi(3.14); // 好 - pi == 3.
int pi{3.14}; // 编译错误: 缩窄转换.
9.14. 预处理指令
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
预处理指令不要缩进, 从行首开始.
**说明**
即使预处理指令位于缩进代码块中, 指令也应从行首开始.
.. code-block:: c++
// 好 - 指令从行首开始
if (lopsided_score) {
#if DISASTER_PENDING // 正确 - 从行首开始
DropEverything();
# if NOTIFY // 非必要 - # 后跟空格
NotifyClient();
# endif
#endif
BackToNormal();
}
.. code-block:: c++
// 差 - 指令缩进
if (lopsided_score) {
#if DISASTER_PENDING // 差 - "#if" 应该放在行开头
DropEverything();
#endif // 差 - "#endif" 不要缩进
BackToNormal();
}
9.15. 类格式
~~~~~~~~~~~~~~~~~~~~~~
**总述**
访问控制块的声明依次序是 ``public:``, ``protected:``, ``private:``, 每个都缩进 1 个空格.
**说明**
类声明 (下面的代码中缺少注释, 参考 :ref:`类注释 <class-comments>`) 的基本格式如下:
.. code-block:: c++
class MyClass : public OtherClass {
public: // 注意有一个空格的缩进
MyClass(); // 标准的两空格缩进
explicit MyClass(int var);
~MyClass() {}
void SomeFunction();
void SomeFunctionThatDoesNothing() {
}
void set_some_var(int var) { some_var_ = var; }
int some_var() const { return some_var_; }
private:
bool SomeInternalFunction();
int some_var_;
int some_other_var_;
};
注意事项:
- 所有基类名应在 80 列限制下尽量与子类名放在同一行.
- 关键词 ``public:``, ``protected:``, ``private:`` 要缩进 1 个空格.
- 除第一个关键词 (一般是 ``public``) 外, 其他关键词前要空一行. 如果类比较小的话也可以不空.
- 这些关键词后不要保留空行.
- ``public`` 放在最前面, 然后是 ``protected``, 最后是 ``private``.
- 关于声明顺序的规则请参考 :ref:`声明顺序 <declaration-order>` 一节.
9.16. 构造函数初始值列表
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
构造函数初始化列表放在同一行或按四格缩进并排多行.
**说明**
下面两种初始值列表方式都可以接受:
.. code-block:: c++
// 如果所有变量能放在同一行:
MyClass::MyClass(int var) : some_var_(var) {
DoSomething();
}
// 如果不能放在同一行,
// 必须置于冒号后, 并缩进 4 个空格
MyClass::MyClass(int var)
: some_var_(var), some_other_var_(var + 1) {
DoSomething();
}
// 如果初始化列表需要置于多行, 将每一个成员放在单独的一行
// 并逐行对齐
MyClass::MyClass(int var)
: some_var_(var), // 4 space indent
some_other_var_(var + 1) { // lined up
DoSomething();
}
// 右大括号 } 可以和左大括号 { 放在同一行
// 如果这样做合适的话
MyClass::MyClass(int var)
: some_var_(var) {}
9.17. 命名空间格式化
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
命名空间内容不缩进.
**说明**
:ref:`命名空间 <namespaces>` 不要增加额外的缩进层次, 例如:
.. code-block:: c++
namespace {
void foo() { // 正确. 命名空间内没有额外的缩进.
...
}
} // namespace
不要在命名空间内缩进:
.. code-block:: c++
namespace {
// 错, 缩进多余了.
void foo() {
...
}
} // namespace
声明嵌套命名空间时, 每个命名空间都独立成行.
.. code-block:: c++
namespace foo {
namespace bar {
9.19. 水平留白
~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
水平留白的使用根据在代码中的位置决定. 永远不要在行尾添加没意义的留白.
**说明**
通用
-----------------------------
.. code-block:: c++
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; } // 用括号把大括号与实现分开.
...
添加冗余的留白会给其他人编辑时造成额外负担. 因此, 行尾不要留空格. 如果确定一行代码已经修改完毕, 将多余的空格去掉; 或者在专门清理空格时去掉（尤其是在没有其他人在处理这件事的时候). (Yang.Y 注: 现在大部分代码编辑器稍加设置后, 都支持自动删除行首/行尾空格, 如果不支持, 考虑换一款编辑器或 IDE)
循环和条件语句
-----------------------------
.. code-block:: c++
if (b) { // if 条件语句和循环语句关键字后均有空格.
} else { // else 前后有空格.
}
while (test) {} // 圆括号内部不紧邻空格.
switch (i) {
for (int i = 0; i < 5; ++i) {
switch ( i ) { // 循环和条件语句的圆括号里可以与空格紧邻.
if ( test ) { // 圆括号, 但这很少见. 总之要一致.
for ( int i = 0; i < 5; ++i ) {
for ( ; i < 5 ; ++i) { // 循环里内 ; 后恒有空格, ; 前可以加个空格.
switch (i) {
case 1: // switch case 的冒号前无空格.
...
case 2: break; // 如果冒号有代码, 加个空格.
操作符
-----------------------------
.. code-block:: c++
// 赋值运算符前后总是有空格.
x = 0;
// 其它二元操作符也前后恒有空格, 不过对于表达式的子式可以不加空格.
// 圆括号内部没有紧邻空格.
v = w * x + y / z;
v = w*x + y/z;
v = w * (x + z);
// 在参数和一元操作符之间不加空格.
x = -5;
++x;
if (x && !y)
...
模板和转换
-----------------------------
.. code-block:: c++
// 尖叫括号(< and >) 不与空格紧邻, < 前没有空格, > 和 ( 之间也没有.
vector<string> x;
y = static_cast<char*>(x);
// 在类型与指针操作符之间留空格也可以, 但要保持一致.
vector<char *> x;
9.19. 垂直留白
~~~~~~~~~~~~~~~~~~~~~~~~
**总述**
垂直留白越少越好.
**说明**
这不仅仅是规则而是原则问题了: 不在万不得已, 不要使用空行. 尤其是: 两个函数定义之间的空行不要超过 2 行, 函数体首尾不要留空行, 函数体中也不要随意添加空行.
基本原则是: 同一屏可以显示的代码越多, 越容易理解程序的控制流. 当然, 过于密集的代码块和过于疏松的代码块同样难看, 这取决于你的判断. 但通常是垂直留白越少越好.
下面的规则可以让加入的空行更有效:
- 函数体内开头或结尾的空行可读性微乎其微.
- 在多重 if-else 块里加空行或许有点可读性.
译者 (YuleFox) 笔记
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#. 对于代码格式, 因人, 系统而异各有优缺点, 但同一个项目中遵循同一标准还是有必要的;
#. 行宽原则上不超过 80 列, 把 22 寸的显示屏都占完, 怎么也说不过去;
#. 尽量不使用非 ASCII 字符, 如果使用的话, 参考 UTF-8 格式 (尤其是 UNIX/Linux 下, Windows 下可以考虑宽字符), 尽量不将字符串常量耦合到代码中, 比如独立出资源文件, 这不仅仅是风格问题了;
#. UNIX/Linux 下无条件使用空格, MSVC 的话使用 Tab 也无可厚非;
#. 函数参数, 逻辑条件, 初始化列表: 要么所有参数和函数名放在同一行, 要么所有参数并排分行;
#. 除函数定义的左大括号可以置于行首外, 包括函数/类/结构体/枚举声明, 各种语句的左大括号置于行尾, 所有右大括号独立成行;
#. ``.``/``->`` 操作符前后不留空格, ``*``/``&`` 不要前后都留, 一个就可, 靠左靠右依各人喜好;
#. 预处理指令/命名空间不使用额外缩进, 类/结构体/枚举/函数/语句使用缩进;
#. 初始化用 ``=`` 还是 ``()`` 依个人喜好, 统一就好;
#. ``return`` 不要加 ``()``;
#. 水平/垂直留白不要滥用, 怎么易读怎么来.
#. 关于 UNIX/Linux 风格为什么要把左大括号置于行尾 (``.cc`` 文件的函数实现处, 左大括号位于行首), 我的理解是代码看上去比较简约, 想想行首除了函数体被一对大括号封在一起之外, 只有右大括号的代码看上去确实也舒服; Windows 风格将左大括号置于行首的优点是匹配情况一目了然.
译者（acgtyrant）笔记
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#. 80 行限制事实上有助于避免代码可读性失控, 比如超多重嵌套块, 超多重函数调用等等.
#. Linux 上设置好了 Locale 就几乎一劳永逸设置好所有开发环境的编码, 不像奇葩的 Windows.
#. Google 强调有一对 if-else 时, 不论有没有嵌套, 都要有大括号. Apple 正好 `有栽过跟头 <http://coolshell.cn/articles/11112.html>`_ .
#. 其实我主张指针／地址操作符与变量名紧邻, ``int* a, b`` vs ``int *a, b``, 新手会误以为前者的 ``b`` 是 ``int *`` 变量, 但后者就不一样了, 高下立判.
#. 在这风格指南里我才刚知道 C++ 原来还有所谓的 `Alternative operator representations <http://en.cppreference.com/w/cpp/language/operator_alternative>`_, 大概没人用吧.
#. 注意构造函数初始值列表（Constructer Initializer List）与列表初始化（Initializer List）是两码事, 我就差点混淆了它们的翻译.
#. 事实上, 如果您熟悉英语本身的书写规则, 就会发现该风格指南在格式上的规定与英语语法相当一脉相承. 比如普通标点符号和单词后面还有文本的话, 总会留一个空格; 特殊符号与单词之间就不用留了, 比如 ``if (true)`` 中的圆括号与 ``true``.
#. 本风格指南没有明确规定 void 函数里要不要用 return 语句, 不过就 Google 开源项目 leveldb 并没有写; 此外从 `Is a blank return statement at the end of a function whos return type is void necessary? <http://stackoverflow.com/questions/9316717/is-a-blank-return-statement-at-the-end-of-a-function-whos-return-type-is-void-ne>`_ 来看, ``return;`` 比 ``return ;`` 更约定俗成（事实上 cpplint 会对后者报错, 指出分号前有多余的空格）, 且可用来提前跳出函数栈.
Reference in New Issue View Git Blame Copy Permalink