C++高级编程技法：从RAII到CRTP #

引言 #

C++作为一门强大的系统级编程语言，掌握其高级编程技法对于构建高性能、可维护的大型项目至关重要。文中整理了一些我认为 C++ 中比较重要且常用的编程技法，希望大家都能掌握它们，因为，真的很重要。

RAII #

RAII 可能是 C++ 中最常用的编程技法。它的思想是把资源映射到对象，根据这些对象的作用域自动管理它们的生命周期。

例如，如果在堆上打开一个文件句柄，那么一旦我们从函数返回（或循环，或任何它在内部声明的作用域）时，它都应该被隐式关闭。

如果类的成员中有动态内存分配，那么当该类实例被销毁时，相关内存应该被隐式释放。

每一种资源 - 内存分配、文件句柄、数据库连接、套接字和任何其他需要获取和释放的资源 - 都应该包装在这样一个 RAII 类中，其生命周期由它的对象所在的作用域决定，和 RAII 类对象绑定。

C++ 语言会保证，当对象超出作用域时，析构函数被调用，不管对象如何离开该作用域。即使抛出异常，所有相关对象也将超出作用域，所以它们的相关资源都会被释放。

void f() {
  std::ifstream file("f.txt"); // 打开一个名为 "f.txt" 的文件
  if (rand() % 2) {
    // 如果抛出异常，我们离开函数，因此 file 的析构函数被调用，关闭文件句柄。
    throw std::exception();
  }
  // 如果未抛出异常，我们正常离开函数，因此再次，file 的析构函数被调用，关闭文件句柄。
}

上例，无论如何离开函数，以及文件打开后发生了什么，我们都不需要显式关闭文件，也不需要在函数内处理异常（例如，try-finally），这就是 RAII 的妙用。

C++ 很多地方都用到了 RAII 特性，例如 lock_guard、智能指针等等，我们自己也可以利用 RAII 特性方便的统计函数耗时等，之前我也写过类似的文章。

这里也推荐大家研究下 ScopeGuard：https://stackoverflow.com/questions/31365013/what-is-scopeguard-in-c

使用 enum class 而非 enum #

当创建枚举时，以前我们可能需要将它放在 namespace 中，使用有意义的名称访问它们：

namespace EntityType {
    enum Enum {
        Ground = 0,
        Human,
        Aerial,
        Total
    };
}

void foo(EntityType::Enum entityType){
    if (entityType == EntityType::Ground) {
        /*code*/
    }
}

但是，这种技术在 C++11 中已经过时。

C++11 后，我们应该使用 enum class：它更加类型安全、简洁和灵活。

enum class EntityType {
    Ground = 0,
    Human,
    Aerial,
    Total
};

void foo(EntityType entityType){
    if (entityType == EntityType::Ground) {
        /*code*/
    }
}

我认为 enum class 最重要的好处就是：防止隐式转换，详见：https://zhuanlan.zhihu.com/p/139515439

Copy-and-swap #

copy-and-swap 技法保证了强异常安全的保证，它可以非常方便的实现 operator=。

class String{
    char * str;
public:
    String & operator = (String s) // the pass-by-value parameter serves as a temporary
    {
       s.swap (*this); // Non-throwing swap
       return *this;
    }// Old resources released when destructor of s is called.
    void swap(String & s) noexcept // Also see non-throwing swap idiom
    {
        std::swap(this->str, s.str);
    }
};

补充知识点，异常安全的四种保证：

Nothrow（或者nofail）异常保证：该函数永远不会抛出异常。对于可能在堆栈展开期间被调用的析构函数和其他函数，期望它们不会抛出异常（错误通过其他方式报告或隐藏）。析构函数默认情况下是 noexcept 的（自 C++11 起）。Nofail（函数总是成功执行）的要求适用于交换（swaps）、移动构造函数和其他被那些提供强异常保证的函数所使用的函数。
强异常保证：如果该函数抛出异常，程序的状态将回滚到函数调用之前的状态（例如，std::vector::push_back）。即使抛出异常，程序仍然处于有效状态。
基本异常保证：如果该函数抛出异常，程序仍然处于有效状态。没有资源泄漏，所有对象的不变性仍然保持完整。没有资源泄漏，所有对象的不变性仍然保持完整。
无异常保证：如果该函数抛出异常，程序可能处于无效状态，可能会发生资源泄漏、内存损坏或其他破坏不变性的错误。

CRTP: Curiously Recurring Template Pattern #

CRTP 是指将一个类作为模板参数传递给其基类的情况：

template<class Derived>
struct BaseCRTP {};

struct Example : BaseCRTP<Example> {};

在基类中，通过进行类型转换（可以使用 static_cast 或 dynamic_cast）可以获取派生类实例，包括派生类型：

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 已经被注入到派生类中，并可以访问派生类的成员。详情可以直接参考 Wiki：https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern。

我之前也写过相关文章：https://articles.zsxq.com/id_f383ae6bfwcr.html

pImpl: 指向实现的指针 #

pImpl 技法是一种将类的接口与其实现解耦的非常有用的方式。

通常，类定义必须包含成员变量和方法，但这可能会暴露太多信息。例如，成员变量可能是在头文件中定义的类型，我们不希望在每个地方都包含它。

windows.h 头文件就是一个典型的例子。我们可能希望在类内部包装一个 HANDLE 或另一个 Win32 类型，但是如果不在类定义中放置 HANDLE，就必须在使用类的每个地方都包含 windows.h。

解决方案是创建一个类的私有实现或指向实现的指针（pImpl），并让公共实现仅存储对私有实现的指针，并转发所有成员方法。

例如：

class private_foo; // 一个指针可以使用的前向声明

// foo.h
class foo {
public:
  foo();
  ~foo();
  void bar();
private:
  private_foo* pImpl;
};

// foo.cpp
#include 相关头文件

// 定义私有实现类
class private_foo {
public:
  void bar() { /*...*/ }
private:
  T member1;
  U member2;
};

// 填写公共接口函数定义：
foo::foo() : pImpl(new private_foo()) {}
foo::~foo() { delete pImpl; }
void foo::bar() { pImpl->bar(); }

现在，foo 的实现与其公共接口解耦，因此：

它可以使用来自其他头文件的成员和类型，而无需在使用类的地方都要求这些依赖项存在。
可以修改实现而不会强制重新编译使用该类的代码。

使用该类的用户只需包含头文件，该头文件不包含任何关于类实现的特定信息。所有实现细节都包含在 foo.cpp 中。

参考链接