Google C++编程规范全览

4星 · 超过85%的资源需积分: 16 169 浏览量更新于2024-07-26 收藏 1.58MB PDF 举报

"Google C++ 编码规范(完整版)" Google C++编码规范是一份详尽的指南，旨在为Google的开源项目和其他采用C++语言的开发者提供一套统一的编程标准，以降低代码的复杂性，减少错误，提高可读性和维护性。这份规范由Benjy Weinberger、Craig Silverstein、Gregory Eitzmann、Mark Mentovai和Tashana Landray等人共同编写，并更新至Revision 3.180。规范的内容包括多个详细风格点，每个风格点都有一个简洁的总结，可以通过点击箭头按钮展开获取更多信息。用户还可以通过顶部的“展开所有”按钮一次性显示所有详细信息。例如，文档中有一个隐藏的提示，通过点击三角形图标可以展示隐藏的“Hooray”信息，以此来演示如何查看隐藏的详细内容。 C++作为主要开发语言，其强大的特性使得开发更为灵活，但同时也带来了复杂性，这可能导致代码更容易出错，更难以理解和维护。Google C++编码规范的目标就是通过规定一系列“应做”和“不应做”的规则，来解决这些问题。这些规则涵盖了命名约定、代码布局、注释、错误处理、内存管理、效率、模板使用、异常处理、多线程编程等多个方面。命名约定部分，规范要求变量、函数和类的命名清晰、一致，通常使用小驼峰式命名（lowerCamelCase）和下划线分隔（snake_case）两种方式。类名通常使用大驼峰式命名（UpperCamelCase），而常量则全部大写，单词间用下划线分隔。在代码布局方面，规范强调代码应有良好的缩进和空格使用，以提高可读性。例如，每个函数定义应有一行空行分隔，大括号通常放置在新的一行，并与控制语句对齐。注释方面，提倡使用Doxygen格式的注释，以便于自动生成文档。每行注释应以两个斜杠（//）开头，多行注释则使用/* 和 */ 包裹，但避免在代码块内部使用多行注释。错误处理推荐使用异常处理机制，而不是返回错误代码。同时，提倡使用智能指针（如std::unique_ptr和std::shared_ptr）来自动管理内存，以防止内存泄漏。模板使用上，建议谨慎使用，避免过度泛型编程，以减少编译时间和可能的二进制大小增加。对于多线程编程，规范提供了关于同步原语（如互斥锁）的使用指导，以保证线程安全。 Google C++编码规范是一份深入细致的指南，它不仅关注代码的正确性，更重视代码的可维护性和团队协作效率。遵循这些规范，可以大大提高代码质量，减少潜在问题，使得C++项目更加稳健和高效。

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.

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

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

In general, constructors should merely set member variables to their initial values. Any complex initialization

should go in an explicit Init() method.

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:

If your object requires non-trivial initialization, consider having an explicit Init() method. In particular, constructors

should not call virtual functions, attempt to raise errors, access potentially uninitialized global variables, etc.

Default Constructors

You must define a default constructor if your class defines member variables and has no other constructors.

Otherwise the compiler will do it for you, badly.

link

▽

link

▽

link

▽

剩余33页未读，继续阅读

Qigai_chen

粉丝: 2
资源: 17

Google C++编程规范全览

Google_C++编码规范_中文版.pdf

Google_C++编码规范_中文版

Google_C++编码规范_中文版.rar

高质量C++_C编程指南和Google_C++编码规范_中文版

Google_C++编码规范_中文.pdf

Google_Cpp_Style_guide_CN_style_C++_google_standard_

google_c++ 编程风格

google_c++编程风格(高清版).pdf

Google_C 编码规范_中文版.pdf

Google C++编码规范.pdf

最新资源