C++代码风格指南 - Revision history

Gongminmin at 06:31, 17 June 2012

2012-06-17T06:31:55Z

Show changes

Gongminmin at 14:32, 11 June 2012

2012-06-11T14:32:32Z

Gongminmin at 07:28, 10 June 2012

2012-06-10T07:28:29Z

Gongminmin: /* 访问控制 */

2012-06-10T07:11:24Z

‎访问控制

Gongminmin at 07:10, 10 June 2012

2012-06-10T07:10:32Z

Gongminmin at 08:35, 9 June 2012

2012-06-09T08:35:06Z

Gongminmin at 09:22, 3 June 2012

2012-06-03T09:22:03Z

Gongminmin at 08:41, 3 June 2012

2012-06-03T08:41:26Z

Gongminmin at 14:44, 29 May 2012

2012-05-29T14:44:24Z

Gongminmin at 06:26, 27 May 2012

2012-05-27T06:26:33Z

← Older revision		Revision as of 14:32, 11 June 2012
Line 650:		Line 650:

	= 写短函数 =		= 写短函数 =
		+
		+	优先采用短小专一的函数。
		+
		+	我们发现长函数有的时候是有用的，所以在函数长度上没有强制限制。如果一个函数超过了大概40行，就应该考虑是否可以在不影响程序结构的基础上把它拆开。
		+
		+	即使你的长函数现在的工作状况良好，在未来几个月内别人对它的修改可能会增加新的行为。这会引入难以寻找的bug。保持函数短小简单可以让别人更容易阅读和修改你的代码。
		+
		+	有时候你会发现冗长复杂的函数。不要立即修改现有代码：如果和这样的函数打交道很困难、发现了难以调试的错误、或者在不同的情况下你只要使用其中一段，可以考虑把那个函数拆成更小更好管理的片段。

	= 其他C++特性 =		= 其他C++特性 =

@@ Line 630: / Line 630: @@
 == 声明顺序 ==
-Use the specified order of declarations within a class: public: before private:, methods before data members (variables), etc.
+在类里面使用特定的声明顺序：public:在private:之前，函数在数据成员（变量）之前，等。
-Your class definition should start with its public: section, followed by its protected: section and then its private: section. If any of these sections are empty, omit them.
+类定义应该从public:区域开始，接着是protected:区域，然后是private:区域。如果任何一个区域是空的，就跳过去。
-Within each section, the declarations generally should be in the following order:
+在每一区域内，声明顺序一般如下：
-*Typedefs and Enums
+*Typedef和枚举
-*Constants (static const data members)
+*常量（静态常量数据成员）
-*Constructors
+*构造函数
-*Destructor
+*析构函数
-*Methods, including static methods
+*函数，包括静态函数
-*Data Members (except static const data members)
+*数据成员（除了静态常量数据成员）
-Friend declarations should always be in the private section, and the copy constructor and assignment operator for disallow copying should be at the end of the private: section. It should be the last thing in the class. See [[#Copy Constructors|Copy Constructors]].
+友元声明应该总是在私有区域，用来禁止拷贝的拷贝构造和赋值操作符应该在private:区域的结尾。它应该是类的最后一个东西。参见[[#拷贝构造函数|拷贝构造函数]]。
-Method definitions in the corresponding .cpp file should be the same as the declaration order, as much as possible.
+在相应.cpp文件中定义的函数应该和声明顺序一致，至少尽可能一致。
-Do not put large method definitions inline in the class definition. Usually, only trivial or performance-critical, and very short, methods may be defined inline. See C++ style guide#Inline Functions|Inline Functions]] for more details.
+不要在类定义中放入大函数定义。通常，只有琐碎的或者性能相关、而且非常短的函数可能定义成内联。细节参见[[#内联函数|内联函数]]。
 = 写短函数 =

@@ Line 622: / Line 622: @@
 == 访问控制 ==
-数据成员都应该是private的，并通过需要的访问函数来访问它们。一般来说一个变量应该命名为foo_，访问函数是foo()。你可能也需要一个修改函数foo()。例外：静态常量数据成员（一般称为FOO）不需要私有。
+数据成员都应该是private的，并通过需要的访问函数来访问它们。一般来说一个变量应该命名为foo_，访问函数是Foo()。你可能也需要一个修改函数Foo()。例外：静态常量数据成员（一般称为FOO）不需要私有。
 访问函数的定义一般inline在头文件里。

@@ Line 622: / Line 622: @@
 == 访问控制 ==
-Make data members private, and provide access to them through accessor functions as needed. Typically a variable would be called foo_ and the accessor function foo(). You may also want a mutator function set_foo(). Exception: static const data members (typically called Foo) need not be private.
+数据成员都应该是private的，并通过需要的访问函数来访问它们。一般来说一个变量应该命名为foo_，访问函数是foo()。你可能也需要一个修改函数foo()。例外：静态常量数据成员（一般称为FOO）不需要私有。
-The definitions of accessors are usually inlined in the header file.
+访问函数的定义一般inline在头文件里。
-See also [[#Inheritance|Inheritance]] and [[#Function Names|Function Names]].
+参见[[#继承|继承]]和[[#函数名|函数名]]。
 == 声明顺序 ==

@@ Line 591: / Line 591: @@
 == 操作符重载 ==
-Do not overload operators except in rare, special circumstances.
+不要重载操作符，除了在很稀少、很特殊的情况下。
-'''Definition:'''
+'''定义：'''
-A class can define that operators such as + and / operate on the class as if it were a built-in type.
+一个类可以定义操作符，比如+和/，就好象它们是内建类型一样。
-'''Pros:'''
+'''优点：'''
-Can make code appear more intuitive because a class will behave in the same way as built-in types (such as int). Overloaded operators are more playful names for functions that are less-colorfully named, such as Equals() or Add(). For some template functions to work correctly, you may need to define operators.
+可以让代码更直观，因为一个类会表现得像内建类型（比如int）。比起函数那样平淡无奇的名字，例如Equals()或Add()，重载操作符的名字则更有趣。为了让一些模板函数正确执行，你可能必须定义操作符。
-'''Cons:'''
+'''缺点：'''
-While operator overloading can make code more intuitive, it has several drawbacks:
+虽然操作符重载会让代码更直观，但它也有几个缺点：
-*It can fool our intuition into thinking that expensive operations are cheap, built-in operations.
+*它会愚弄你的直觉，让你以为昂贵的操作是廉价的内建操作。
-*It is much harder to find the call sites for overloaded operators. Searching for Equals() is much easier than searching for relevant invocations of ==.
+*重载操作符让调用的位置更加难以寻找。搜索Equals()比搜索==的相关调用容易得多。
-*Some operators work on pointers too, making it easy to introduce bugs. Foo + 4 may do one thing, while &Foo + 4 does something totally different. The compiler does not complain for either of these, making this very hard to debug.
+*有些操作符也能接受指针，更容易引入bug。Foo + 4做的是一件事情，而&Foo + 4则会做完全不同的事情。编译器不会报告其中任何一种情况，使得debug更困难。
-*Overloading also has surprising ramifications. For instance, if a class overloads unary operator&, it cannot safely be forward-declared.
+*重载也会有意外的副作用。例如，如果一个类重载了一元操作符&，它就不能安全地进行前置声明。
-'''Decision'''
+'''决定'''
-In general, do not overload operators. The assignment operator (operator=), in particular, is insidious and should be avoided. You can define functions like Equals() and CopyFrom() if you need them. Likewise, avoid the dangerous unary operator& at all costs, if there's any possibility the class might be forward-declared.
+总的来说，不要重载操作符。特别是赋值操作符（operator=）很危险，应该避免定义。如果需要的话，可以定义类似Equals()和 CopyFrom()的函数。同样，无论如何应该避免定义危险的一元操作符&，如果这个类有任何会被前置声明的可能性的话。
-However, there may be rare cases where you need to overload an operator to interoperate with templates or "standard" C++ classes (such as operator<<(ostream&, const T&) for logging). These are acceptable if fully justified, but you should try to avoid these whenever possible. In particular, do not overload operator== or operator< just so that your class can be used as a key in an STL container; instead, you should create equality and comparison functor types when declaring the container.
+但是，在非常罕见的情况下，你需要重载操作符来与模板和“标准”C++类交互（比如用operator<<(ostream&, T const &)来记录日志）。如果条件完全满足的话也是可以接受的，但你应该试图尽量避免这些。特别是，不要仅仅为了让你的类可以在STL容器中用作key就重载operator==或operator<；取而代之的是，你在声明容器的时候应该建立相等和比较的仿函数类型。
-Some of the STL algorithms do require you to overload operator==, and you may do so in these cases, provided you document why.
+有些STL算法确实需要你重载operator==，在这些情况下你也得那么做，同时在文档中标明原因。
-See also [[#Copy Constructors|Copy Constructors]] and [[#Function Overloading|Function Overloading]].
+参见[[#拷贝构造函数|拷贝构造函数]]和[[#函数重载|函数重载]]。
 == 访问控制 ==

@@ Line 564: / Line 564: @@
 == 接口 ==
-Classes that satisfy certain conditions are allowed, but not required, to end with an Interface suffix.
+满足一定条件的类可以，但不是必须，以Interface后缀为结尾。
-'''Definition:'''
+'''定义：'''
-A class is a pure interface if it meets the following requirements:
+一个类如果符合下列要求，就是一个纯接口：
-*It has only public pure virtual ("= 0") methods and static methods (but see below for destructor).
+*只含有public纯虚（"= 0"）方法和静态方法（析构函数看下面）。
-*It may not have non-static data members.
+*不能有非静态数据成员。
-*It need not have any constructors defined. If a constructor is provided, it must take no arguments and it must be protected.
+*不需要定义任何构造函数。如果提供了构造函数，它不能有参数而且必须是protected。
-*If it is a subclass, it may only be derived from classes that satisfy these conditions and are tagged with the Interface suffix.
+*如果是个子类，它只能从符合这些条件而且有Interface后缀的类继承而来。
-An interface class can never be directly instantiated because of the pure virtual method(s) it declares. To make sure all implementations of the interface can be destroyed correctly, the interface must also declare a virtual destructor (in an exception to the first rule, this should not be pure). See Stroustrup, The C++ Programming Language, 3rd edition, section 12.4 for details.
+接口类不能被直接实例化，因为它声明了纯虚方法。为了确保这个接口的所有实现都正确地销毁了，这个接口也必须声明虚析构函数（作为第一条规则的例外，析构不能是纯虚的）。细节参见Stroustrup的《The C++ Programming Language》第三版，第12.4节。
-'''Pros:'''
+'''优点：'''
-Tagging a class with the Interface suffix lets others know that they must not add implemented methods or non static data members. This is particularly important in the case of multiple inheritance. Additionally, the interface concept is already well-understood by Java programmers.
+给一个类加上Interface的后缀可以让其他人知道他们不能增加函数实现或非静态数据成员。这一点在多重继承的时候尤为重要。另外，Java程序员已经非常了解接口的概念了。
-'''Cons:'''
+'''缺点：'''
-The Interface suffix lengthens the class name, which can make it harder to read and understand. Also, the interface property may be considered an implementation detail that shouldn't be exposed to clients.
+Interface后缀加长了类名，使得类较难阅读和明白。同时，接口属性算作实现细节，不该暴露给用户。
-'''Decision'''
+'''决定'''
-A class may end with Interface only if it meets the above requirements. We do not require the converse, however: classes that meet the above requirements are not required to end with Interface.
+只有符合上面要求的类可以以Interface结尾。但是，我们不要求反过来也成立：符合上面要求德雷不是必须以Interface结尾。
 == 操作符重载 ==

@@ Line 544: / Line 544: @@
 == 多重继承 ==
-Only very rarely is multiple implementation inheritance actually useful. We allow multiple inheritance only when at most one of the base classes has an implementation; all other base classes must be pure interface classes tagged with the Interface suffix.
+多重继承只在一种稀有的情况下真能发挥作用。我们只有在最多一个基类有实现、其他基类都是纯接口类的时候才允许多重继承。
-'''Definition:'''
+'''定义：'''
-Multiple inheritance allows a sub-class to have more than one base class. We distinguish between base classes that are pure interfaces and those that have an implementation.
+多重继承允许子类有多于一个基类。我们需要区分纯接口的基类和有实现的基类。
-'''Pros:'''
+'''优点：'''
-Multiple implementation inheritance may let you re-use even more code than single inheritance (see [[#Inheritance|Inheritance]]).
+多重实现继承可以让你比单继承重用更多的代码（参见[[#继承|继承]]）。
-'''Cons:'''
+'''缺点：'''
-Only very rarely is multiple implementation inheritance actually useful. When multiple implementation inheritance seems like the solution, you can usually find a different, more explicit, and cleaner solution.
+多重实现继承只在一种稀有的情况下真能发挥作用。当多重实现继承看似一个解决方案时，你通常可以找到另一个更明显、更干净的解决方案。
-'''Decision'''
+'''决定'''
-Multiple inheritance is allowed only when all superclasses, with the possible exception of the first one, are pure interfaces. In order to ensure that they remain pure interfaces, they must end with the Interface suffix.
+只有当所有父类，除了第一个可以例外，其他都是纯接口的时候才允许多重继承。为了确保它们确实是纯接口，类名必须有Interface的后缀。
 == 接口 ==

@@ Line 516: / Line 516: @@
 == 继承 ==
-Composition is often more appropriate than inheritance. When using inheritance, make it public.
+组合经常比继承更合适。当使用继承的时候，用public。
-'''Definition:'''
+'''定义：'''
-When a sub-class inherits from a base class, it includes the definitions of all the data and operations that the parent base class defines. In practice, inheritance is used in two major ways in C++: implementation inheritance, in which actual code is inherited by the child, and interface inheritance, in which only method names are inherited.
+当子类从基类继承而来的时候，它包含了基类定义的所有数据和操作。实际上，继承在C++里主要用作两种方式：实现继承——实际代码被子类继承，以及接口继承——只有方法名被继承。
-'''Pros:'''
+'''优点：'''
-Implementation inheritance reduces code size by re-using the base class code as it specializes an existing type. Because inheritance is a compile-time declaration, you and the compiler can understand the operation and detect errors. Interface inheritance can be used to programmatically enforce that a class expose a particular API. Again, the compiler can detect errors, in this case, when a class does not define a necessary method of the API.
+在实现继承对一个现有类型进行特化的时候，它可以通过重用基类的代码来减少代码长度。因为继承是编译期声明的，你和编译器都可以明白这个操作，以及检测错误。接口继承可以用来在程序上强制一个类暴露出特定的API。在这种情况下，当一个类并没有定义API需要的方法时，编译器可以检测出错误。
-'''Cons:'''
+'''缺点：'''
-For implementation inheritance, because the code implementing a sub-class is spread between the base and the sub-class, it can be more difficult to understand an implementation. The sub-class cannot override functions that are not virtual, so the sub-class cannot change implementation. The base class may also define some data members, so that specifies physical layout of the base class.
+对于实现继承，因为子类的代码实现分散在了基类和子类之间，所以会更难理解。子类不能覆盖不是virtual的函数，所以子类不能改变实现。基类可能也得定义一些数据成员，所以基类的物理布局也就确定了。
-'''Decision'''
+'''决定'''
-All inheritance should be public. If you want to do private inheritance, you should be including an instance of the base class as a member instead.
+所有的继承都应该是public的。如果你要private继承，你应该改成包含一个基类对象作为成员。
-Do not overuse implementation inheritance. Composition is often more appropriate. Try to restrict use of inheritance to the "is-a" case: Bar subclasses Foo if it can reasonably be said that Bar "is a kind of" Foo.
+不要过分使用实现继承，组合经常更合适。尽量把继承的使用限制在“是一个”的情况：如果Bar从Foo继承而来，是因为说Bar“是一种”Foo是合理的。
-Make your destructor virtual if necessary. If your class has virtual methods, its destructor should be virtual.
+必要的话把析构函数声明为虚的。如果你的类有虚函数，构造函数也必须是虚的。
-Limit the use of protected to those member functions that might need to be accessed from subclasses. Note that data members should be private.
+只有可能会被子类访问到的成员函数才用protect。注意数据成员应该是private。
-When redefining an inherited virtual function, explicitly declare it virtual in the declaration of the derived class. Rationale: If virtual is omitted, the reader has to check all ancestors of the class in question to determine if the function is virtual or not.
+当重定义一个继承来的虚函数时，在派生类的声明里把它显式声明成virtual。基本原理：如果virtual被省略了，读者就必须检查它的所有祖先类，才能确定这个函数是否是虚函数。
 == 多重继承 ==

@@ Line 504: / Line 504: @@
 == 结构体和类 ==
-Use a struct only for passive objects that carry data; everything else is a class.
+结构体仅用于只有数据的被动对象，其他都应该是类。
-The struct and class keywords behave almost identically in C++. We add our own semantic meanings to each keyword, so you should use the appropriate keyword for the data-type you're defining.
+在C++中，struct和class关键字的行为几乎完全相同。我们给每个关键字增加了语义上的含义，所以你应该对定义的数据类型使用适当的关键字。
-structs should be used for passive objects that carry data, and may have associated constants, but lack any functionality other than access/setting the data members. The accessing/setting of fields is done by directly accessing the fields rather than through method invocations. Methods should not provide behavior but should only be used to set up the data members, e.g., constructor, destructor, Initialize(), Reset(), Validate().
+结构体应该用于被动对象，只包含数据，以及相关的常量，但没有任何除了访问/设置数据成员之外的功能。通过直接访问成员，而不是通过调用函数来访问/设置一个成员。函数只应该用来建立数据成员，比如，构造函数、析构函数、Initialize()、Reset()、Validate()。
-If more functionality is required, a class is more appropriate. If in doubt, make it a class.
+如果需要更多的功能，定义成类更合适。如果还犹豫不决，就定义成类。
-For consistency with STL, you can use struct instead of class for functors and traits.
+为了和STL一致，定义functor和trait可以使用结构体而不是类。
 == 继承 ==