什么是你最喜欢的C ++编码风格成语

你最喜欢的C ++编码风格成语是什么? 我正在问风格或编码排版,比如放大括号的地方,关键字后面是否有空格,缩进的大小等。这与最佳做法或要求相反,例如总是使用delete[]删除数组。

下面是我最喜欢的一个例子:在C ++类初始化程序中,我们把分隔符放在行的前面,而不是后面。 这使得保持最新更容易。 这也意味着版本之间的源代码控制差异更为清晰。

 TextFileProcessor:: TextFileProcessor( class ConstStringFinder& theConstStringFinder ) : TextFileProcessor_Base( theConstStringFinder ) , m_ThreadHandle ( NULL ) , m_startNLSearch ( 0 ) , m_endNLSearch ( 0 ) , m_LineEndGetIdx ( 0 ) , m_LineEndPutIdx ( 0 ) , m_LineEnds ( new const void*[ sc_LineEndSize ] ) { ; } 

创build枚举时,将它们放在一个名称空间中,以便可以用一个有意义的名称访问它们:

 namespace EntityType { enum Enum { Ground = 0, Human, Aerial, Total }; } void foo(EntityType::Enum entityType) { if (entityType == EntityType::Ground) { /*code*/ } } 

编辑 :但是,这种技术已经成为过时的C + + 11。 应该使用范围枚举 (用enum classenum struct ):它更安全,简洁,更灵活。 使用旧式枚举值将被放置在外部范围中。 使用新式枚举,它们被放置在enum class名的范围内。
前面的示例使用作用域枚举重写(也称为强types枚举 ):

 enum class EntityType { Ground = 0, Human, Aerial, Total }; void foo(EntityType entityType) { if (entityType == EntityType::Ground) { /*code*/ } } 

使用范围枚举还有其他一些重要的好处:没有隐式转换,可能的前向声明,以及使用自定义底层types(而不是默认的int )的能力。

RAII:资源获取是初始化

RAII可能是最重要的成语。 资源应该被映射到对象是这样的想法,所以它们的生命周期是根据这些对象被声明的范围自动pipe理的。

例如,如果文件句柄是在堆栈中声明的,那么一旦我们从函数(或者循环,或者其中声明的范围)返回,它就应该隐式closures。 如果dynamic内存分配是作为类的成员进行分配的,那么当该类实例被销毁时,它应该被隐式释放。 等等。 每一种资源内存分配,文件句柄,数据库连接,套接字以及任何其他需要获取和释放的资源都应该包装在这样一个RAII类中,它的生命周期取决于它的范围声明。

这样做的一个主要优点是C ++保证当对象超出范围时调用析构函数, 而不pipe控制权是如何离开范围的 。 即使抛出一个exception,所有的本地对象都将超出范围,所以它们的相关资源将被清除。

 void foo() { std::fstream file("bar.txt"); // open a file "bar.txt" if (rand() % 2) { // if this exception is thrown, we leave the function, and so // file's destructor is called, which closes the file handle. throw std::exception(); } // if the exception is not called, we leave the function normally, and so // again, file's destructor is called, which closes the file handle. } 

无论我们如何离开函数,以及打开文件后发生了什么,我们都不需要显式closures文件,也不需要在该函数中处理exception(例如try-finally)。 相反,文件被清理,因为它被绑定到一个本地对象,当它超出范围时被破坏。

RAII也不太知名,叫做SBRM(Scope-Bound Resource Management)。

也可以看看:

  • ScopeGuard允许代码“在抛出exception的情况下自动调用”撤消“操作。

复制交换

复制交换成语提供exception安全的复制。 它要求执行正确的拷贝和交换。

 struct String { String(String const& other); String& operator=(String copy) { // passed by value copy.swap(*this); // nothrow swap return *this; // old resources now in copy, released in its dtor } void swap(String& other) throw() { using std::swap; // enable ADL, defaulting to std::swap swap(data_members, other.data_members); } private: Various data_members; }; void swap(String& a, String& b) { // provide non-member for ADL a.swap(b); } 

您也可以直接使用ADL(参数相关查找)实现交换方法。

这个习语很重要,因为它处理自我赋值[1] ,做出强有力的例外保证[2] ,而且往往很容易写。


[1]虽然自我分配不是尽可能有效地处理,但它应该是罕见的 ,所以如果从来没有发生,这实际上更快。

[2]如果抛出任何exception,则对象( *this )的状态不会被修改。

CRTP:好奇地重复模板模式

当您将一个类作为模板parameter passing给其基类时,会发生CRTP :

 template<class Derived> struct BaseCRTP {}; struct Example : BaseCRTP<Example> {}; 

在基类中,它可以通过简单的cast( static_cast或者dynamic_cast work)来获得派生实例的inheritance, 并且派生types完整

 template<class Derived> struct BaseCRTP { void call_foo() { Derived& self = *static_cast<Derived*>(this); self.foo(); } }; struct Example : BaseCRTP<Example> { void foo() { cout << "foo()\n"; } }; 

实际上, call_foo已被注入到派生类中,并且可以完全访问派生类的成员。

随意编辑和添加使用的具体例子,可能到其他SO职位 。

pImpl:指针实现

pImpl习惯用法是将类的接口与其实现分离的一种非常有用的方法。

通常,类定义必须包含成员variables以及方法,这可能会暴露过多的信息。 例如,一个成员variables可能是头部定义的types,我们不希望在任何地方都包含这个头部。

windows.h头文件是一个很好的例子。 我们可能希望在一个类中包装一个HANDLE或者另一个Win32types,但是我们不能在类定义中放置一个HANDLE ,而不必在任何地方使用windows.h

然后,解决scheme是创build一个私有的IMPL ementationP ointer-to- IMPL ementation类,让公共实现只存储一个指向私有的指针,并转发所有的成员方法。

例如:

 class private_foo; // a forward declaration a pointer may be used // foo.h class foo { public: foo(); ~foo(); void bar(); private: private_foo* pImpl; }; // foo.cpp #include whichever header defines the types T and U // define the private implementation class class private_foo { public: void bar() { /*...*/ } private: T member1; U member2; }; // fill in the public interface function definitions: foo::foo() : pImpl(new private_foo()) {} foo::~foo() { delete pImpl; } void foo::bar() { pImpl->bar(); } 

现在foo的实现已经从它的公共接口中分离出来了

  • 它可以使用其他头文件中的成员和types,而不需要这些相关性在类被使用时出现
  • 可以在不强制重新编译使用类的代码的情况下修改实现。

这个类的用户只是简单的包含头文件,其中没有包含任何具体的类的实现。 所有的实现细节都包含在foo.cpp

我喜欢在“列”中排列代码/初始化…当使用“列”模式编辑器进行编辑时,certificate非常有用,而且似乎对我来说更容易阅读…

 int myVar = 1; // comment 1 int myLongerVar = 200; // comment 2 MyStruct arrayOfMyStruct[] = { // Name, timeout, valid {"A string", 1000, true }, // Comment 1 {"Another string", 2000, false }, // Comment 2 {"Yet another string", 11111000, false }, // Comment 3 {NULL, 5, true }, // Comment 4 }; 

相比之下,相同的代码不会像上面那样缩进和格式化…(稍微难以阅读我的眼睛)

 int myVar = 1; // comment 1 int myLongerVar = 200; // comment 2 MyStruct arrayOfMyStruct[] = { // Name, timeout, valid {"A string", 1000, true},// Comment 1 {"Another string", 2000, false }, // Comment 2 {"Yet another string", 11111000,false}, // Comment 3 {NULL, 5, true }, // Comment 4 }; 

公共顶部 – 私人羽绒服

一个看起来很小的优化,但是自从我转换到这个习惯之后,我有更多的时间来抓我的课程,特别是在我没有看了他们42年之后。

具有一致的成员可见性,从频繁的兴趣点到无聊的东西,是非常有用的,尤其是当代码应该自我logging。

(qt-users的旁注:插槽在信号之前,因为它们应该像非插槽成员函数一样可调用,并且除了它们的插槽之外,它们与非插槽没有区别)

  • 公共,保护,私人
  • 然后工厂,Ctor,Dtor,复制,交换
  • 那么类的接口最后,在一个单独的private: section中,传入数据(理想情况下只有一个impl指针)。

如果你在保持你的类声明不整齐的时候遇到问题,这个规则也有帮助。

 class Widget : public Purple { public: // Factory methods. Widget FromRadians (float); Widget FromDegrees (float); // Ctors, rule of three, swap Widget(); Widget (Widget const&); Widget &operator = (Widget const &); void swap (Widget &) throw(); // Member methods. float area() const; // in case of qt {{ public slots: void invalidateBlackHole(); signals: void areaChanged (float); // }} protected: // same as public, but for protected members private: // same as public, but for private members private: // data float widgetness_; bool isMale_; }; 

if语句中,当条件有困难时,可以清楚地显示每个条件使用缩进的级别。

 if ( ( (var1A == var2A) || (var1B == var2B)) && ( (var1C == var2C) || (var1D == var2D))) { // do something } 

没有最爱,但我修复代码:

  1. 选项卡 – 导致许多IDE和代码审查工具不匹配,因为它们并不总是在mod 8空格的选项卡上达成一致。
  2. 比80列更长的行 – 让我们面对它,更短的行更可读。 只要行数很短,我的大脑就可以parsing大部分编码规则。
  3. 行尾有空白 – git会抱怨它是空格错误 ,在diff中显示为红色斑点,这很烦人。

这里是find有问题的文件的一行代码:

 git grep -I -E '<tab>|.{81,}| *$' | cut -f1 -d: | sort -u 

其中<tab>是制表符(POSIX正则expression式不是\ t)

重新:ididak

我修复了将冗长的语句分解成太多短的代码。

让我们面对现实:这不是90年代。 如果你的公司买不起宽屏液晶显示器的编码器,你需要得到更好的工作:)

编译时多态性

(也称为语法多态和静态多态,与运行时多态对比)

使用模板函数,可以编写依赖于types构造函数的代码,并调用参数化types的系列的签名,而不必引入公共基类。

在“ 编程元素 ”一书中,作者将这种types的处理称为抽象属 。 有了概念,人们可以指定这些types参数的要求,尽pipeC ++没有强制规定这些规范。

两个简单的例子:

 #include <stdexcept> template <typename T> T twice(T n) { return 2 * n; } InIt find(InIt f, InIt l, typename std::iterator_traits<InIt>::reference v) { while (f != l && *f != v) ++f; return f; } int main(int argc, char* argv[]) { if (6 != twice(3)) throw std::logic_error("3 x 2 = 6"); int const nums[] = { 1, 2, 3 }; if (nums + 4 != find(nums, nums + 4, 42)) throw std::logic_error("42 should not have been found."); return 0; } 

可以使用定义了二元运算符的常规types调用twice 。 同样,可以使用任何可比较的types和模型Input Iterator调用find() 。 一组代码在不同types上运行类似,没有共享基类。

当然,这里实际上是在模板实例化时将相同的源代码扩展为各种types特定的函数,每个函数都有独立的生成的机器代码。 在没有模板的情况下容纳相同types的集合将需要1)具有特定签名的单独的手写函数,或2)通过虚拟函数的运行时多态性。

模板和钩子

这是在框架中尽可能多的处理方式,并为框架用户定制门户钩子 。 也被称为热点和模板方法 。

 class Class { void PrintInvoice(); // Called Template (boilerplate) which uses CalcRate() virtual void CalcRate() = 0; // Called Hook } class SubClass : public Class { virtual void CalcRate(); // Customized method } 

Wolfgang Pree在其着作“面向对象软件开发的devise模式”一书中进行了描述。

我不知道它是否符合成语的要求,但是相当多的重型模板编程依赖于SFINAE(通常很重要)(replace失败不是错误)。 上一个问题的答案有几个例子。

在与一个部分失明的人工作之后,他应他的要求,转而使用更多的空间。 我当时不喜欢它,但现在我更喜欢它。 在我的头顶,标识符和关键字之间没有空格的地方,以及函数名称后面和下面的括号之前的地方。

 void foo( int a, int b ) { int c = a + ( a * ( a * b ) ); if ( c > 12 ) c += 9; return foo( 2, c ); } 

if / while /用于带有空格分隔符的括号expression式

 if (expression) // preferred - if keyword sticks out more 

 if(expression) // looks too much like a void function call 

我想这意味着我喜欢我的函数调用没有空格分隔符

 foo(parm1, parm2); 

我真的很喜欢在if的同一行上写一个小的声明

 int myFunc(int x) { if(x >20) return -1; //do other stuff .... } 

不知道这是否算作一个成语,但我倾向于使用doxygen样式的内嵌注释,即使项目不是 – 使用doxygen …

 bool MyObjects::isUpToSomething() ///< Is my object up to something 

(旁白,我的评论通常不是那么蹩脚)。

把函数名放在一个新行上是很有用的,所以你可以像grep一样

 grep -R '^fun_name' . 

为他们。 我已经看到了用于大量GNU项目的样式,喜欢它:

 static void fun_name (int a, int b) { /* ... */ } 

将每个方法或函数参数写在一个单独的行上,以便可以轻松地进行评论。

 int ReturnMaxValue( int* inputList, /* the list of integer values from which to get the maximum */ long size, /* count of the number of integer values in inputList */ char* extraArgs /* additional arguments that a caller can provide. */ ) 

我build议PIMPL或James Coplien最初称之为“Handle Body”。

这个习惯用法可以让界面与执行完全分离。 在重新编写和重新发布一个主要的CORBA中间件组件时,这个习惯用来将API从实现中彻底解耦。

这实际上消除了任何可能的逆向工程。

James Coplien出色的书“ 高级C ++编程风格和习惯”是一个很好的C ++习语资源。 强烈推荐!

编辑:正如Neil在下面指出的那样,这本书已经过时了,他的许多build议实际上都被纳入了C ++标准本身。 不过,我仍然觉得它是有用信息的来源,尤其是, 在他的PLoP论文的C ++习惯用法中 ,许多习语被重写成pattermforms。

我总是挑选并编辑以下内容:

  • 多余的换行符
  • 在EOF没有换行符

我通常坚持* BSD STYLE(9)中描述的KNF

logging函数行的返回值,所以很容易find。

 int function(void) /* return 1 on success, 0 on failure */ { return 1; }; 

我倾向于把我的所有ifs。

 if (condition) { complicated code goes here } else { /* This is a comment as to why the else path isn't significant */ } 

尽pipe它惹恼了我的同事。 你可以一目了然地看到,在编码过程中,我考虑了其他情况。