欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

EffectiveC++笔记 第3章

程序员文章站 2022-05-03 14:13:47
我根据自己的理解，对原文的精华部分进行了提炼，并在一些难以理解的地方加上了自己的“可能比较准确”的「翻译」。 Chapter 3 资源管理 条款13： 以对象管理资源 有时即使你顺利地写了对应对象的delete语句，但是前面的区域可能会有一个过早的return语句或者抛出了异常.它们一旦执行,控制流 ......

我根据自己的理解，对原文的精华部分进行了提炼，并在一些难以理解的地方加上了自己的“可能比较准确”的「翻译」。

Chapter 3 资源管理

条款13： 以对象管理资源

有时即使你顺利地写了对应对象的delete语句，但是前面的区域可能会有一个过早的return语句或者抛出了异常.它们一旦执行,控制流绝不会触及delete语句,造成内存泄漏

事实上我们可以将需要的动态资源放进对象内，因为对象的析构函数会自动释放那些资源

c++对应的解决方案有 auto_ptr，也就是所谓的智能指针，它其实是类指针(pointer-like)对象，其析构函数自动对其所指对象调用delete，可一定程度地避免潜在的资源泄漏可能性

先假设一个名叫func的函数，它会new一个xx类型的对象并返回其指针，你可以这样使用auto_ptr :

std::auto_ptr<xx> pt(func());

这个简单例子示范两个关键想法：

---获得资源后立即放进管理对象； 管理对象运用析构函数确保资源被释放---

由于auto_ptr被销毁会自动删除所指之物，所以注意别让多个auto_ptr同时指向一个对象。后果是对象很可能会被删除一次以上，那将使你的程序搭上驶向“未定义行为”的列车上。

为预防这个问题，auto_ptr有一个性质： 若通过copying函数复制它们，它们会变成null，而复制所得指针将取得资源唯一拥有权：

std::auto_ptr<xx> pt1(func());
std::auto_ptr<xx> pt2(pt1); //现在pt2指向原本pt1所指对象，而pt1变成
//nullptr
pt1 = pt2; //现在pt1指向原本pt2所指对象，而pt2变成
//nullptr

可以看出auto_ptr的底层条件：受管理的资源必须绝对没有一个以上的auto_ptrs指向它。对于STL容器，这个特性不是很好。

替代方案是“引用计数型智能指针(reference-counting smart pointer)”，
shared_ptr
它其实也是一个智能指针，持续追踪共有多少对象指向某笔资源，::并在无人指向它时自动删除该资源。::

下面我们会将“引用计数型智能指针(reference-counting smart pointer)”的缩写RCSP来作为shared_ptr的别称。

对于RCSP，你可以这么写：std::shared_ptr<xx> pInv(func());

对于以下操作，RCSP相对于auto_ptr正常多了：

...
std::tr1::shared_ptr<xx> pInv1(func());
std::tr1::shared_ptr<xx>. pInv2(pInv1); //现在pInv2与1指向同一个对象
pInv1 = pInv2; //同上，无任何改变
...
//pInv1和pInv2被销毁后，它们所指的对象也就被自动销毁

综上，RCSP很适合STL容器的操作。

值得注意的是，auto和shared_ptr两者都在其析构函数内做delete而不是delete[]动作。这意味着在动态分配而得的array身上使用auto_ptr和tr1::shared_ptr是馊主意，然而这样会通过编译！

std::auto_ptr<std::string> aps(new std::string[10]);
std::tr1::shared_ptr<int> spi(new int[1024]);

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

有可能你偶尔会发现，你需要建立自己的资源管理类

假设使用C API函数处理类型为Mutex的互斥器对象，共有lock和unlock两函数可用：

void lock(Mutek* pm); void unlock(Mutek* pm);

可能需要建立一个class来管理机锁:

class Lock{
public:
    explicit Lock(Mutex* pm)
        :mutexPtr(pm)
    { lock(mutexPtr); } //获得资源
    ~Lock() { unlock(mutexPtr); } //释放资源
private:
    Mutex* mutexPtr;
};

现在导入一个观念：

资源取得时机便是初始化时机(Resource Acquisition Is Initialization; RAII)
并以此作为“资源管理类的脊柱”

「客户」对Lock的用法符合RAII方式：

Mutex m; //定义需要的互斥器
...
{
    Lock ml(&m); //锁定互斥器
      ... 
    //在区块末尾解除锁定
}

此时假设Lock对象被复制：

Lock ml1(&m); 锁定m
Lock ml2(ml1); 将ml1复制到ml2身上，会发生啥？

大多数情况你会选择下面两种操作：

  1. 禁止复制. 许多时候允许RAII对象被复制并不合理，如果你发现不合理，就应该禁止之。
    根据条款6，我们发现可以：将copying操作声明为private.对Lock而言看起来是这样：
class Lock: private Uncopyable{
public:
    …
};
  1. 对底层资源祭出“引用计数法”. 有时我们希望保有资源，直到它的最后一个使用者（某对象）被销毁。此时复制RAII对象时应将该资源的“被引用数”递增。也就是使用tr1::shared_ptr

通常只需内含一个tr1::shared_ptr成员变量，RAII classes便可实现出reference-counting copying行为.

存在一个问题：shared_ptr缺省行为是“当引用次数为0时删除所指物”，然而我们想要的动作是解除锁定而非剔除。

幸运的是tr1::shared_ptr允许指定所谓的“删除器(deleter)”——当引用次数为0时便被调用，它是一个函数或函数对象，对于指针是可有可无的第二参数:

class Lock{
public:
    explicit Lock(Mutex* pm)
        :mutexPtr(pm,unlock)
        {
            lock(mutexPtr.get()); //以后谈到“get”
          }
private:
    std::tr1::shared_ptr<Mutex> mutexPtr;
};

注意，不再声明析构函数，因为没必要，编译器有缺省行为

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

假设有这种情况：

使用RCSP智能指针保存factory函数的调用结果：

std::tr1::shared_ptr<Investment> pInv(createInvestment());

假设有一个函数处理investment对象：

int dayHeld(const Investment* pi); //返回投资天数

而你想这么调用：

int days = daysHeld(pInv);

这样通不过编译，因为即使pInv指向的是investment对象，但是pInv本身是类型为tr1::shared_ptr

这时你需要一个函数来将RAII class对象(本例为tr1::shared_ptr) 转换为其内含原始资源(本例为Investment*)。

有两种办法：显式转换和隐式转换。

tr1::shared_ptr和auto_ptr都提供一个叫get的成员函数，用来执行显式转换，它将返回智能指针内部的原始指针的复件 :

int days = daysHeld(pink.get())

这两种指针还重载了指针取值操作符（operator->和operator*），这将允许隐式转换至原始指针：

class Investment{
public:
    bool isTaxFree() const;
};
...
std::tr1::shared_ptr<Investment> pInv(createInvestment());
bool ok = pInv->isTaxFree();
bool ok1 = *(pInv).isTaxFree();
...

很多传统的做法便是xx.get()来获取内部资源，如果这种操作很繁琐的话，有一种更轻松的做法（隐式转换）：

class XXX{
public:
    ...
    operator xxx() const    //隐式转换函数,xxx是返回类型
    { return f; }
    ...
};

比如某个函数参数原来得这么写

func(xx.get())

现在你可以写成func(xx)

但这种转换可能会引发错误：

假设类A里储存的是B类对象，当B类对象想拷贝一个A类对象时，却发生了隐式转换：

A obj(getA());
...
B obj2 = obj; //喔唷！原意是拷贝一个A对象，却将obj隐式转换为其底部的B对象了，然后再复制

很多时候显式转换更受欢迎

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

看一下这段代码：

std::string* stringArray = new std::string[100];
…
delete stringArray;

很明显此程序行为不明确。对象数组所含的100个string对象中的99
个不太可能被适当删除，因为它们的析构函数很可能没被调用。

delete最大的问题在于：::即将被删除的内存之内究竟有多少对象？::这个问题决定了有多少对象的析构函数必须被调用起来。

也就是， 即将被删除的指针，所指的是单一对象或对象数组？ 数组所用的内存通常还包括“数组大小”的记录，以便delete知道需要调用多少次析构函数。

所以记住，删除对象数组要用 delete[] xxx;

这种规则对typedef的使用也很重要：

typedef std::string AddressLines[4]; 
std::string* pal = new AddressLines;

此时AddressLines是一个数组，如果这样new：

std::string* pal = new AddressLines;

就必须匹配 delete[] pal

尽量不要对数组做typedef动作，你大可用STL中的vector等templates

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

假设有这样一个函数：

void process(std::tr1::shared_ptr<Widget> pw);

process将对传来的Widget对象运用智能指针
现在考虑调用函数：

process(new Widget);

嘿嘿，这是不能通过编译的。Widget对象需要被shared_ptr包装一下。因为tr1::shared_ptr构造函数需要一个原始指针(raw pointer)，但该构造函数是explicit的，无法隐式转换，可以这么写：

process(std::tr1::shared_ptr<Widget>(new Widget));//实际上仍有风险

假设process函数有第二个参数func()，它是一个函数的返回结果：

process(std::tr1::shared_ptr<Widget>(new Widget),func());

调用process之前，编译器必须创建代码，做以下三件事：

  1. 调用func()
  2. 执行”new Widget”
  3. 调用tr1::shared_ptr构造函数

对于c++，此行编译时，有可能编译器先执行”new Widget”操作：

  1. 执行”new Widget”
  2. 调用func()
  3. 调用tr1::shared_ptr构造函数

然而如果此时func()调用导致异常，”new Widget”返回的指针将会遗失，因为它尚未被置入tr1::shared_ptr内，这将引发资源泄漏。

我们可以使用分离语句，将异常干扰减小：

std::tr1::shared_ptr<Widget> pw(new Widget);
process(pw,func());

OVER

上一篇： 荀瓜怎么炒好吃？这三种烹饪方式，让你一秒钟就变成大厨师！

下一篇： 含雌激素高的食物有哪些？经常食用这些食物美白又健康！

推荐阅读