Google C++编程规范指南

需积分: 3 26 浏览量更新于2024-07-31 收藏 329KB PDF 举报

"Google C++ Style Guide" Google的C++风格指南是该公司为了保持代码的一致性和可读性而制定的一套编程规范。这份指南详细涵盖了C++编程中的多个方面，包括头文件、命名规则、作用域、类设计、函数使用、访问控制、异常处理以及特定于Google的实践等。以下是对这些知识点的详细解释： 1. **头文件(Header Files)** - **#define Guard**：在每个头文件中使用预处理器宏来防止重复包含，通常形式如`#ifndef HEADER_FILE_H_ #define HEADER_FILE_H_ ... #endif` - **Header File Dependencies**：提倡最小化头文件之间的依赖关系，只包含真正需要的头文件。 - **Inline Functions**：鼓励将小的、不改变对象状态的函数声明为内联，以减少函数调用开销。 - **-inl.h Files**：用于存放内联函数的具体实现，分离接口和实现。 2. **命名与顺序(Names and Order of Includes)** - 文件包含顺序：先系统库（`<...>`），后自定义库（`"..."`）；同类型库按字母顺序排列。 3. **作用域(Scoping)** - 鼓励使用作用域限制变量的作用范围，以减少全局变量的使用。 - 使用`namespaces`来避免命名冲突，推荐使用小写的`google`或`myproject`等命名空间。 4. **类(Class)** - **非成员、静态成员和全局函数(Nonmember, Static Member, and Global Functions)**：优先考虑非成员函数，除非有明确的理由需要静态成员或全局函数。 - **构造函数(Constructor)**：避免在构造函数中做复杂的工作，尽量保持简洁。推荐使用默认构造函数、显式构造函数和拷贝构造函数。 - **结构体(Structs vs. Classes)**：通常使用类，除非有理由使用结构体，比如表示POD类型（Plain Old Data）。 - **继承(Inheritance)**：谨慎使用继承，避免多重继承，除非在实现接口时。 - **接口(Interfaces)**：如果需要接口，可以使用抽象基类或纯虚函数。 5. **函数(Function)** - **操作符重载(Operator Overloading)**：仅在语义上合理且能提高可读性时才重载运算符。 - **访问控制(Access Control)**：使用`private`、`protected`和`public`来控制成员的访问级别，遵循最小权限原则。 - **函数声明顺序(Declaration Order)**：按成员的访问级别顺序声明，然后是友元函数。 6. **其他C++特性(Other C++ Features)** - **引用参数(Reference Arguments)**：使用引用作为函数参数，以避免不必要的拷贝。 - **函数重载(Function Overloading)**：允许同一名称的函数具有不同的参数列表。 - **默认参数(Default Arguments)**：在适当的情况下使用默认参数，但要避免导致模糊的调用语法。 - **Variable-Length Arrays (VLAs) 和 alloca()**：通常不推荐使用，因为它们可能导致内存问题和不可移植性。 - **友元(Friends)**：限制使用，只有在必要时才声明为友元。 - **异常(Exceptions)**：支持使用异常处理，但避免在性能敏感的代码中抛出异常。 - **运行时类型信息(RTTI)**：适度使用`dynamic_cast`和`typeid`，但避免过度依赖。 - **Casting**：推荐使用`static_cast`、`const_cast`、`dynamic_cast`和`reinterpret_cast`，避免旧式的C风格类型转换。 7. **Google特定实践(Google-Specific)** - **Magic（智能指针）**：提倡使用智能指针，如`std::unique_ptr`和`std::shared_ptr`，以管理对象生命周期。 - **cpplint**：Google提供的代码质量检查工具，用于检测代码风格错误。这份指南旨在提高代码质量和团队协作效率，遵循它可以使代码更加清晰、易于理解和维护。

Cons:

Nonmember and static member functions may make more sense as

members of a new class, especially if they access external resources or have

significant dependencies.

Decision:

Sometimes it is useful, or even necessary, to define a function not bound to a

class instance. Such a function can be either a static member or a nonmember

function. Nonmember functions should not depend on external variables, and

should nearly always exist in a namespace. Rather than creating classes only to

group static member functions which do not share static data, use namespaces

instead.

Functions defined in the same compilation unit as production classes may

introduce unnecessary coupling and link-time dependencies when directly called

from other compilation units; static member functions are particularly susceptible

to this. Consider extracting a new class, or placing the functions in a namespace

possibly in a separate library.

If you must define a nonmember function and it is only needed in its

.cc

file, use

an unnamed namespace

static

linkage (eg

static int Foo() {...}

) to

limit its scope.

Local Variables

▽

Place a function's variables in the narrowest scope possible, and initialize

variables in the declaration.

LINK

C++ allows you to declare variables anywhere in a function. We encourage you

to declare them in as local a scope as possible, and as close to the first use as

possible. This makes it easier for the reader to find the declaration and see what

type the variable is and what it was initialized to. In particular, initialization

should be used instead of declaration and assignment, e.g.

int i;

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

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

Note that gcc implements

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

correctly (the

scope of

is only the scope of the

for

loop), so you can then reuse

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 efficient to declare such a variable used in a loop outside that

loop:

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

11/05/2010 Google C++ Style Guide

…googlecode.com/svn/…/cppguide.xml 9/50

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.

LINK

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.

LINK

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:

11/05/2010 Google C++ Style Guide

…googlecode.com/svn/…/cppguide.xml 10/50

剩余49页未读，继续阅读

皓月如我

粉丝: 475
资源: 77

Google C++编程规范指南

Google C++ Style Guide (中文版).pdf

Google C++ Style Guide中文.pdf

Google C++ Style Guide.zip

google c++ style guide

谷歌C++规范 Google C++ Style Guide PDF

Google C++ Style Guide(谷歌C++编码规范 )

google c++ style guide译文

google c++ style guide网盘

基于 .NET 5 + Ant Design Vue 的 Admin Fx.zip

基于java的KTV点歌系统设计新版源码+数据库+说明.zip

最新资源