谷歌C++编程规范详解

需积分: 3 61 浏览量更新于2024-07-18 收藏 516KB PDF 举报

"Google_C++_Style_Guide" 谷歌C++编程规范是一份详细的文档，旨在为C++开发者提供一套统一的编码风格和最佳实践。这份规范由谷歌内部的开发人员编写，包括Benjy Weinberger、Craig Silverstein、Gregory Eitzmann、Mark Mentovai和Tashana Landray等，旨在提高代码的可读性、可维护性和团队协作效率。该指南涵盖了多个关键主题，包括文件结构、命名规则、函数设计、内存管理和继承等。 1. **Header Files** - **#define Guard**: 在头文件中使用预处理器宏定义来防止重复包含，通常命名为`<filename>_H_`，确保文件只被包含一次。 - **Forward Declarations**: 当只需要知道类的存在而不需要其具体实现时，使用前向声明来减少编译依赖。 2. **Inline Functions & .inl.h Files** - 内联函数用于避免函数调用带来的开销，但应当谨慎使用，以免增大编译后的代码大小。 - `.inl.h` 文件用于将内联函数的定义与声明分离，保持头文件的清晰。 3. **Function Parameter Ordering** - 参数顺序通常是：输出参数（如有）在前，输入参数在后。 4. **Names and Order of Includes** - 遵循特定的包含顺序，通常为：相关头文件、C++标准库、C标准库、其他项目文件和第三方库。 5. **Scoping** - 使用作用域来限制变量的可见性和生命周期，减少命名冲突。 6. **Namespaces** - 使用命名空间来组织代码，避免全局命名空间污染。 7. **Nested Classes, Nonmember, Static Member, and Global Functions** - 内联类常用于封装与类紧密相关的数据。 - 非成员函数和静态成员函数可以用于提供类的通用功能，而不依赖于特定对象。 8. **Local Variables** - 尽量减少作用域，尽早初始化，并避免使用全局变量。 9. **Static and Global Variables** - 避免过度使用全局和静态变量，因为它们可能导致意外的副作用和内存管理问题。 10. **Classes** - 构造函数应在执行任何工作之前完成初始化，避免在构造过程中做复杂操作。 - 明确指定构造函数为`explicit`，防止隐式类型转换。 - 复制构造函数和赋值运算符应遵循深拷贝和浅拷贝原则，处理资源转移。 - 使用 delegating constructors 和 inheriting constructors 提高代码效率和简洁性。 - 结构体和类的使用区别在于默认访问级别，结构体默认为public，类默认为private。 11. **Inheritance** - 继承用于表示"is-a"关系，谨慎选择继承方式，避免多继承带来的复杂性。 - 接口类（纯虚函数类）用于定义抽象行为，提供一种规范接口。 12. **Operator Overloading** - 运算符重载应谨慎使用，保持与原运算符的行为一致。 13. **Access Control** - 声明顺序通常为：public、protected、private，控制成员的访问权限。 14. **Declaration Order** - 成员变量和函数声明的顺序通常为：公有成员、保护成员、私有成员；然后是函数。 15. **Google-Specific** - Google特定部分可能包含公司内部使用的特殊工具和实践，如`cpplint`，一个静态代码分析工具。 16. **Ownership and Smart Pointers** - 强调智能指针（如`std::unique_ptr`, `std::shared_ptr`）的使用，以自动管理内存。 17. **Other C++ Features** - 引入了C++的其他特性，如引用参数、右值引用、函数重载、默认参数、以及不推荐的变量长度数组和`alloca()`。这份风格指南旨在促进良好的编程习惯，降低代码错误的可能性，提升代码质量和团队合作效率。遵循这些规则，可以帮助开发者写出更加专业、一致且易于理解的C++代码。

link

▽

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

Note that gcc implements for (int i = 0; i < 10; ++i) correctly (the scope of i is

only the scope of the for loop), so you can then reuse i in another for loop in

the same scope. It also correctly scopes declarations in if 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 efficient 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-find 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, floats, or pointers, or arrays/structs of

POD.

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

called is only partially specified in C++ and can even change from build to

build, which can cause bugs that are difficult to find. 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 defined 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 for

another variable that contains a reference to that string.

Google C++ Style Guide http://google-styleguide.googlecode.com/svn/trunk/cppg...

第12页共67页 2014/1/6 11:27

link

▽

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

calling quick_exit() instead of exit(). The difference 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() (flushing 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).

Definition:

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 modification 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,

gflags will not yet have been initialized.

Decision:

Google C++ Style Guide http://google-styleguide.googlecode.com/svn/trunk/cppg...

第13页共67页 2014/1/6 11:27

link

▽

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 defines 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 default constructor for you, which may leave some

fields uninitialized or initialized to inappropriate values.

Definition:

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; or string name_{"abc"};, as opposed to just int count_; or string

name_;.

Pros:

A user defined 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 defining 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 defines member variables that aren't initialized in-class, and if it

has no other constructors, you must define 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 define

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.

Google C++ Style Guide http://google-styleguide.googlecode.com/svn/trunk/cppg...

第14页共67页 2014/1/6 11:27

剩余66页未读，继续阅读

吉祥水

粉丝: 18
资源: 110

谷歌C++编程规范详解

掌握Google C++编码风格的权威指南

Google C++ Style Guide：编写规范与头文件处理

Google C++ Style Guide: 英文版，带目录与标签

Google_Cpp_Style_guide_CN.zip_C++_guide_style

Google_Cpp_Style_guide_CN_style_C++_google_standard_

Google_C++_Style_Guide中文+英文版

Google_C++_Style_Guide（中文版+英文版）

Google C++ Style Guide_编程规范_style_C++_google_

Google_Cpp_Style_guide_CN.rar_Google C++ 编程规范_style

Google_Cpp_Style_guide_CN.rar_goole c++_style

最新资源