Google C++编码风格指南：实践与原则

5星 · 超过95%的资源需积分: 9 145 浏览量更新于2024-07-22 收藏 432KB PDF 举报

Google C++编码风格指南（Google C++ Style Guide），修订至第3.274版，由Benjy Weinberger、Craig Silverstein、Gregory Eitzmann、Mark Mentovai、Tashana Landray等多位专家共同编写，旨在提供一套全面且一致的编程实践规则，以提升代码质量、可读性和可维护性。该指南覆盖了C++编程中的各个重要方面，包括但不限于： 1. **头文件命名与包含**： - 使用`#define`定义guard来避免重复编译单元问题，确保每个文件只被包含一次。 - 始终遵循特定的函数参数顺序，如先包含依赖项，后声明函数。 2. **函数声明与实现**： - 避免过度使用内联函数，仅在必要时将其放在`.inl.h`文件中以提高效率。 - 按照特定的顺序组织函数参数，如类型、名称和作用域。 3. **命名与作用域**： - 采用明确的命名策略，遵循首字母小写的驼峰式命名规则。 - 倡导使用命名空间组织代码，减少全局变量冲突。 4. **类设计**： - 在构造函数中避免执行过多工作，确保清晰的初始化逻辑。 - 明确区分结构体和类，结构体通常用于值类型，而类用于引用类型。 - 合理运用继承和多继承，遵循单一职责原则。 5. **接口与操作符重载**： - 提倡接口设计，仅暴露必要的成员函数，减少复杂性。 - 对操作符重载进行谨慎处理，确保其行为符合预期并易于理解。 6. **访问控制**： - 根据功能需求选择合适的访问修饰符（public, protected, private）。 - 保持声明和定义的顺序一致性，便于理解和维护。 7. **函数长度与复用**： - 推崇编写短小、专注的函数，以提高代码可读性和测试性。 - 专属于Google的特殊编程“魔法”，如使用智能指针管理所有权。 8. **工具与辅助检查**： - 强烈推荐使用`cpplint`工具进行代码审查，确保遵循编码规范。 - 了解并合理使用C++的其他特性，如引用参数、rvalue references、默认参数等。 9. **内存管理**： - 推行现代C++的内存管理最佳实践，如使用RAII（Resource Acquisition Is Initialization）和智能指针（如`std::unique_ptr`和`std::shared_ptr`）。通过遵循Google C++编码风格指南，开发者可以创建出高效、可维护的代码，适应Google内部的标准和行业最佳实践。

link

▽

instead of declaration and assignment, e.g.

int i;

i = f(); // Bad -- initialization separate from declaration.

int j = g(); // Good -- declaration has initialization.

vector<int> v;

v.push_back(1); // Prefer initializing using brace initialization.

v.push_back(2);

vector<int> v = {1, 2}; // Good -- v starts initialized.

Note that gcc implements

for (int i = 0; i < 10; ++i)

correctly (the scope of

only the scope of the

for

loop), so you can then reuse

in another

for

loop in the

same scope. It also correctly scopes declarations in

and

while

statements, e.g.

while (const char* p = strchr(str, '/')) str = p + 1;

There is one caveat: if the variable is an object, its constructor is invoked every time it

enters scope and is created, and its destructor is invoked every time it goes out of

scope.

// Inefficient implementation:

for (int i = 0; i < 1000000; ++i) {

Foo f; // My ctor and dtor get called 1000000 times each.

f.DoSomething(i);

}

It may be more eﬃcient to declare such a variable used in a loop outside that loop:

Foo f; // My ctor and dtor get called once each.

for (int i = 0; i < 1000000; ++i) {

f.DoSomething(i);

}

Static and Global Variables

Static or global variables of class type are forbidden: they cause hard-to-ﬁnd bugs

due to indeterminate order of construction and destruction. However, such

variables are allowed if they are

constexpr

: they have no dynamic initialization or

destruction.

Objects with static storage duration, including global variables, static variables, static

class member variables, and function static variables, must be Plain Old Data (POD):

only ints, chars, ﬂoats, or pointers, or arrays/structs of POD.

The order in which class constructors and initializers for static variables are called is

only partially speciﬁed in C++ and can even change from build to build, which can

cause bugs that are diﬃcult to ﬁnd. Therefore in addition to banning globals of class

type, we do not allow static POD variables to be initialized with the result of a function,

unless that function (such as getenv(), or getpid()) does not itself depend on any other

globals.

Likewise, global and static variables are destroyed when the program terminates,

regardless of whether the termination is by returning from

main()

or by calling

exit()

The order in which destructors are called is deﬁned to be the reverse of the order in

which the constructors were called. Since constructor order is indeterminate, so is

destructor order. For example, at program-end time a static variable might have been

destroyed, but code still running — perhaps in another thread — tries to access it and

fails. Or the destructor for a static

string

variable might be run prior to the destructor

Google C++ Style Guide

10 of 57 03/17/2015 04:55 PM

link

▽

link

▽

for another variable that contains a reference to that string.

One way to alleviate the destructor problem is to terminate the program by calling

quick_exit()

instead of

exit()

. The diﬀerence is that

quick_exit()

does not invoke

destructors and does not invoke any handlers that were registered by calling

atexit()

If you have a handler that needs to run when a program terminates via

quick_exit()

(ﬂushing logs, for example), you can register it using

at_quick_exit()

. (If you have a

handler that needs to run at both

exit()

and

quick_exit()

, you need to register it in

both places.)

As a result we only allow static variables to contain POD data. This rule completely

disallows

vector

(use C arrays instead), or

string

(use

const char []

If you need a static or global variable of a class type, consider initializing a pointer

(which will never be freed), from either your main() function or from pthread_once().

Note that this must be a raw pointer, not a "smart" pointer, since the smart pointer's

destructor will have the order-of-destructor issue that we are trying to avoid.

Classes

Classes are the fundamental unit of code in C++. Naturally, we use them extensively.

This section lists the main dos and don'ts you should follow when writing a class.

Doing Work in Constructors

Avoid doing complex initialization in constructors (in particular, initialization that

can fail or that requires virtual method calls).

Deﬁnition:

It is possible to perform initialization in the body of the constructor.

Pros:

Convenience in typing. No need to worry about whether the class has been initialized

or not.

Cons:

The problems with doing work in constructors are:

There is no easy way for constructors to signal errors, short of using exceptions

(which are

forbidden

If the work fails, we now have an object whose initialization code failed, so it may

be an indeterminate state.

If the work calls virtual functions, these calls will not get dispatched to the

subclass implementations. Future modiﬁcation to your class can quietly introduce

this problem even if your class is not currently subclassed, causing much

confusion.

If someone creates a global variable of this type (which is against the rules, but

still), the constructor code will be called before

main()

, possibly breaking some

implicit assumptions in the constructor code. For instance,

gﬂags

will not yet

have been initialized.

Decision:

Constructors should never call virtual functions or attempt to raise non-fatal failures. If

your object requires non-trivial initialization, consider using a factory function or

Init()

method.

Initialization

If your class deﬁnes member variables, you must provide an in-class initializer for

every member variable or write a constructor (which can be a default constructor).

If you do not declare any constructors yourself then the compiler will generate a

Google C++ Style Guide

11 of 57 03/17/2015 04:55 PM

link

▽

default constructor for you, which may leave some ﬁelds uninitialized or initialized to

inappropriate values.

Deﬁnition:

The default constructor is called when we

new

a class object with no arguments. It is

always called when calling

new[]

(for arrays). In-class member initialization means

declaring a member variable using a construction like

int count_ = 17;

string

name_{"abc"};

, as opposed to just

int count_;

string name_;

Pros:

A user deﬁned default constructor is used to initialize an object if no initializer is

provided. It can ensure that an object is always in a valid and usable state as soon as

it's constructed; it can also ensure that an object is initially created in an obviously

"impossible" state, to aid debugging.

In-class member initialization ensures that a member variable will be initialized

appropriately without having to duplicate the initialization code in multiple

constructors. This can reduce bugs where you add a new member variable, initialize it

in one constructor, and forget to put that initialization code in another constructor.

Cons:

Explicitly deﬁning a default constructor is extra work for you, the code writer.

In-class member initialization is potentially confusing if a member variable is initialized

as part of its declaration and also initialized in a constructor, since the value in the

constructor will override the value in the declaration.

Decision:

Use in-class member initialization for simple initializations, especially when a member

variable must be initialized the same way in more than one constructor.

If your class deﬁnes member variables that aren't initialized in-class, and if it has no

other constructors, you must deﬁne a default constructor (one that takes no

arguments). It should preferably initialize the object in such a way that its internal

state is consistent and valid.

The reason for this is that if you have no other constructors and do not deﬁne a default

constructor, the compiler will generate one for you. This compiler generated

constructor may not initialize your object sensibly.

If your class inherits from an existing class but you add no new member variables, you

are not required to have a default constructor.

Explicit Constructors

Use the C++ keyword

explicit

for constructors with one argument.

Deﬁnition:

Normally, if a constructor takes one argument, it can be used as a conversion. For

instance, if you deﬁne

Foo::Foo(string name)

and then pass a string to a function

that expects a

Foo

, the constructor will be called to convert the string into a

Foo

and

will pass the

Foo

to your function for you. This can be convenient but is also a source of

trouble when things get converted and new objects created without you meaning them

to. Declaring a constructor

explicit

prevents it from being invoked implicitly as a

conversion.

Pros:

Avoids undesirable conversions.

Cons:

None.

Google C++ Style Guide

12 of 57 03/17/2015 04:55 PM

剩余56页未读，继续阅读

SeAL80s

粉丝: 0
资源: 3

Google C++编码风格指南：实践与原则

google c++ code style中文

Google coding style

Google C++ Style Guide

google c++ coding style guide

google c++ coding style.png

Google coding style xml file

Coding Style,咱程序员自己的Style1

Google C++ Style Guide(Google C++编程规范）高清PDF

C++ Coding Standard

Google C++ Style Guide.zip

最新资源