Effective C++ 学习笔记 第三章:资源管理

第一章见 Effective C++ 学习笔记 第一章:让自己习惯 C++
第二章见 Effective C++ 学习笔记 第二章:构造、析构、赋值运算

文章目录

    • 条款 13: 以对象管理资源(重要)
      • 话题 1:不要让调用者回收资源
      • 话题 2:智能指针
      • 话题 3:智能指针不能用来指向数组
      • 原书建议
    • 条款 14 :在资源管理类中小心 copying 行为
      • 原书建议
    • 条款 15:在资源管理类中提供对原始资源的访问
      • 原书建议
    • 条款 16: 成对使用 new 和 delete 时要采用相同形式
    • 条款 17:以独立语句将 newed 对象置入智能指针
      • 原书建议

计算机资源,除了我们熟悉的内存,还包括其他需要在使用时占用,在使用后归还给系统的东西,还包括如文件描述符、互斥锁、图形控件、数据库连接、网络端口等。

条款 13: 以对象管理资源(重要)

Use objects to manage resources.

话题 1:不要让调用者回收资源

不要把 delete 的工作单独留给调用者。有些时候是担心调用者忘记 delete,但更隐晦的情况可能是调用程序写了 delete,但因为一些原因,不会执行到 delete,比如之前的一些异常,或者隐藏很深的 return 语句。程序在维护过程中,逐渐可能会暴露这种问题。
我们应该将资源管理的工作放到对象内,让对象的析构函数来完成资源回收的任务。

话题 2:智能指针

可以将资源赋给智能指针来引用,智能指针可以自动在退出作用域时,回收它指向的资源。
比如 auto_ptr:(注:auto_ptr 在 C++ 11 中被鄙视,替代用 unique_ptr)

class Inv();   // 省略定义
Inv* createInv();  // 工厂函数,返回 Inv 的对象

void f() {
    std::auto_ptr<Inv> pInv(createInv());
    // 退出 f() 作用域时,Inv 中的资源会被自动回收
}

两个关键工作:

  • 获得资源后立即将其放入对象内管理。比如上边代码放到了 auto_ptr pInv 中。 这叫 RAII,即资源取得时便是初始化时(Resource Acquisition Is Initialization)。
  • 管理对象运用析构函数确保资源被释放。比如上边代码中,auto_ptr 的析构函数会释放资源。因为我们要求析构函数中不得抛出异常,所以一旦管理对象要被析构了,它所管理的资源也一定会被释放。

别让多个 auto_ptr 指针指向同一个对象,如果其中一个 auto_ptr 已经析构了,那其他 auto_ptr 将指向已经被释放的资源位置!auto_ptr 有个特殊的性质,它的 copy 构造函数和copy 运算符重载,是会控制唯一性,它们会让 copy 的指针为 null:

std::auto_ptr<Inv> pInv1 (createInv());   // pInv1 指向 Inv 资源
std::auto_ptr<Inv> pInv2 (pInv1);         // 现在 pInv2 指向 Inv 资源,pInv1 为 null
pInv1 = pInv2;                            // 现在 pInv1 指向 Inv 资源,pInv2 为 null

注:auto_ptr 的这种操作可能导致访问非法内存,比如当 pInv1 为 null 时,用户错误的认为它依然指向资源而引用资源。unique_ptr 与其最大的不同是,unique_ptr 可以在编译期检查这种错误的引用。

对这个问题的替代方案是 shared_ptr,它是引用计数型智能指针。类似于互斥锁和共享锁的概念,当多个 shared_ptr 指向同一个资源时,它可计数,当计数不为 0 时,析构个别 shared_ptr 不会释放资源,只有当计数为 0 时,才会析构这些 shared_ptr 指向的资源。
但 shared_ptr 不能解决环状引用,也就是两个指针互相指向对方,所以它只是类似于资源回收。
注:原书中引用 std::tr1::shared_ptr,在 C++ 11 中,shared_ptr 引入到标准中,之后可通过 std::shared_ptr 直接访问。

auto_ptr 和 shared_ptr 只是 RAII 的一个典型应用,我们自己写的结构中也可以应用 RAII。

话题 3:智能指针不能用来指向数组

auto_ptr 和 shared_ptr 在释放资源时都是用 delete,而不是 delete[],所以它们不应该被用来指向数组结构,而且,编译器也无法检查这种错误,一旦指向了数组结构,那最后在析构时,就无法完全释放资源。
作者的理由是,C++ 中总有办法取代数组,比如 string 和 vector。不过,Boost 库中的 boost::scopted_array 和 boost::shared_array 可以实现指向数组的操作。

其实,createInv() 这个接口本身设计的有问题,它不应该把一个资源直接扔出来。

注:C++ 11 中的 unique_ptr 可以在模板类型中指定带 [] 的类型,从而可以正常释放数组成员。

原书建议

  • 为了防止资源泄漏,请使用 RAII 对象,它们在构造函数中获取资源并在析构函数中释放资源。
  • 两个常被使用的 RAII 对象是 tr1::shared_ptr 和 auto_ptr,前者通常更常用,区别在于 copy 时是否允许多个指针指向同一个资源对象。

条款 14 :在资源管理类中小心 copying 行为

Think carefully about copying behavior in resource-managing classes.

  1. 禁止资源管理类对象的复制,这种操作会导致意外情况。使用 private Uncopyable 方式来处理,见 条款6
  2. 或者,使用引用计数,这和 tr1::shared_ptr 是类似的境况。shared_ptr 支持定义删除器(deleter),默认情况下,auto_ptr 和 shared_ptr 都是通过 delete 来释放资源,但有些时候,我们希望通过其他方式释放资源,比如 unlock(mutex)。
  3. 复制资源管理类时,进行深度拷贝。也就是并不是复制类对象本身,而是复制类对象管理的所有资源,都形成副本。比如 string 的复制,虽然 string 的内容是指向 heap 上字符内容的指针,但复制 string 对象时, heap 上的字符内容都会产生副本。
  4. 控制任何时刻,只允许最多 1 个资源管理类对象来管理资源,就像 auto_ptr 那样子。通过重载两个 copy 函数来实现。

原书建议

  • 复制 RAII 对象必须一并复制它所管理的资源,所以资源的 copying 行为决定 RAII 对象的 copying 行为。
  • 普遍而常见的 RAII classes copying 行为是:禁止 copying、引用计数法。

条款 15:在资源管理类中提供对原始资源的访问

Provide access to raw resources in resource-managing classes.
虽然我们寄希望于把资源放到资源管理类中管理,从而避免资源泄漏的问题。但是有些时候,我们难免还是会遇到一些 APIs,他们需要直接操作资源。
对于智能指针,它们提供 get 方法来获取资源,将资源管理类的指针显式转换为对应指向的资源。
同时,它们也提供了隐式的指针取值操作,来获取资源。智能指针也是指针,通过取值操作(operator-> 和 operator*),隐式的获取原始资源。
还有一种自定义的办法,如果显示提供 get 方法来获取资源比较繁琐,可以隐式指定一个转换函数,也就是重载隐式类型转换函数:

FH getFont();    // 这是一个 C API,我们希望做一个资源管理类来管理这个 API
void releaseF(FH f);    // 另一个 C API,用来释放 FH

// 以下是资源管理类
class F {
public:
    explicit F (FH fh) : f(fh) {}
    ~F() { releaseF(f); }
    FH get() const;
    operator FH() const;
private:
    FH f;
};

// 我们可以提供 get 方法显式获取原始资源:
FH F::get() const { return f; }

// 我们也可以自定义一个类型转换成员函数:
F::operator FH() const { return f; }

通常,get 方法更常用,因为隐式的类型转换可能会导致用户误用。

原书建议

  • APIs 往往要求访问原始资源(raw resources),所以每个 RAII class 应该提供一个能够取得其所管理资源的方法。
  • 对原始资源的访问可能经过显式转换或隐式转换,一般而言,显式转换比较安全,但隐式转换对用户使用更为方便。

条款 16: 成对使用 new 和 delete 时要采用相同形式

Use the form in corresponding uses of new and delete.
如果 new 时指定的是一个资源对象,那释放资源用 delete;如果 new 时指定的是一个资源对象的数组,那释放资源用 delete[]。
究其根源是因为,new 一个单一的资源对象时,内存中将直接保存这个资源,并将指向该资源的指针返回;new 一个资源对象的数组时,会在内存中开头先存放一个数组长度,然后才会分配资源内存,并将指向该资源内存开头的位置返回。
程序运行时无法得知一块资源内存中的开头,存放的是单一资源还是资源数组的长度,从而需要用户来自己控制。
虽然大多数情况下,我们不会犯这种错误,但有些错误比较隐晦:

typedef std::string Address[4];    // 定义了一个类型 Address,其结构是 4 个 std::string 的对象数组
std::string* p = new Address;      // 当我们这么使用时,本质上是 new 了一个资源数组
... // 大量的其他代码
delete p;   // 出错,资源泄漏,我们可能会忽略掉 Address 其实是一个数组
delete[] p; // 正确

为了避免这个问题,作者建议不要将数组结构用 typedef 定义成自定义类型,可以使用 vector 或 string 等现成的对象来取代。

条款 17:以独立语句将 newed 对象置入智能指针

Store newed objects in smart pointers in standalone statements.
错误示例:

int pR();
void pW(std::tr1::shared_ptr<W> pw, int pr);
pW(new W, pR());  // 调用 pW,并将资源放入智能指针
                  // 会报错,原因是 shared_ptr 的构造函数是 exclicit 的,不允许隐式类型转换
pW(std::tr1::shared_ptr<W>(new W), pR());   // 这样写就不会报错,但依然是错误示例

原因是,C++中不约定函数参数的初始化顺序,如果初始化参数的顺序是:

  1. new W;
  2. pR();
  3. shared_ptr 的构造函数

那么,一旦 pR() 中发生异常,走了其他路径,1 步骤获取的资源就无法被释放了。

避免办法就是,不要把资源获取并赋给智能指针的语句和其他语句放到一个语句中。
正确示例:

std::tr1::shared_ptr<W> pw(new W);   // 独立完成这个动作
pW(pw, pR());

原书建议

  • 以独立语句将 newed 对象存储于智能指针中。如果不这样做,一旦异常发生,可能会导致无法察觉的资源泄漏。

你可能感兴趣的:(C++,学习笔记)