More Effective C++条款10：在constructors内阻止资源泄露

最新推荐文章于 2024-09-16 17:46:36 发布
最新推荐文章于 2024-09-16 17:46:36 发布
阅读量697 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhongleyun/article/details/124003572
版权

想像你正在开发一个多媒体通信薄软件，这个软件可以放置包括人名， 地址，电话号码等文字，以及一张个人相片和一段个人声音。为了简单起见，本文中假设只包含个人相片和声音。代码实现下：

#include <stdio.h>
#include <iostream>
using namespace std;

class Image
{
public:
    Image(const string& imageDataFileName) {  printf("Image constructor\r\n");}
    ~Image() { printf("Image destructor\r\n"); }
};

class AudioClip
{
public:
    AudioClip(const string& audioDataFileName) 
    { 
        printf("AudioClip constructor\r\n"); 
    }
    ~AudioClip() { printf("AudioClip destructor\r\n"); }
};


class BookEntry
{
public:
    BookEntry(string &imageDataFileName, string& audioDataFileName);   
    ~BookEntry();
private:
    Image *theImage;
    AudioClip *theAudioClip;
};

BookEntry::BookEntry(string &imageDataFileName, string& audioDataFileName):theImage(0),theAudioClip(0)  
{
    printf("BookEntry constructor\r\n");

    if(imageDataFileName != "")
    {
        theImage = new Image(imageDataFileName);
    }

    if(audioDataFileName != "")
    {
        theAudioClip = new AudioClip(audioDataFileName);
    }
}

BookEntry::~BookEntry()
{
    printf("BookEntry destructor\r\n");
    delete theImage;
    delete theAudioClip;
}

int main()
{
    string imageDataFileName("abc");
    string audioDataFileName("def");
    BookEntry bookEntry(imageDataFileName, audioDataFileName); 
    return 0;
}

一切看起来好像没有什么问题。确实如此！在没有抛异常时，没有任何问题！但是假如现在BookEntry的构造函数在new AudioClip对象时抛异常了会怎么样呢？（完全有可能，比如空间不够了new操作符就会抛出异常）， 已经new好的Image对象会被释放吗？ 看下面代码：

#include <stdio.h>
#include <iostream>
using namespace std;

class Image
{
public:
    Image(const string& imageDataFileName) {  printf("Image constructor\r\n");}
    ~Image() { printf("Image destructor\r\n"); }
};

class AudioClip
{
public:
    AudioClip(const string& audioDataFileName) 
    { 
        printf("AudioClip constructor\r\n"); 
        throw invalid_argument("throw execption for testing!"); 

    }
    ~AudioClip() { printf("AudioClip destructor\r\n"); }
};


class BookEntry
{
public:
    BookEntry(string &imageDataFileName, string& audioDataFileName);   
    ~BookEntry();
private:
    Image *theImage;
    AudioClip *theAudioClip;
};

BookEntry::BookEntry(string &imageDataFileName, string& audioDataFileName):theImage(0),theAudioClip(0)  
{
    printf("BookEntry constructor\r\n");

    if(imageDataFileName != "")
    {
        theImage = new Image(imageDataFileName);
    }

    if(audioDataFileName != "")
    {
        theAudioClip = new AudioClip(audioDataFileName);
    }
}

BookEntry::~BookEntry()
{
    printf("BookEntry destructor\r\n");
    delete theImage;
    delete theAudioClip;
}

int main()
{
    string imageDataFileName("abc");
    string audioDataFileName("def");
    try
    {
        BookEntry bookEntry(imageDataFileName, audioDataFileName);
    }
    catch (invalid_argument e)
    {
        printf("%s\r\n", e.what());
        return -1;
    }

    return 0;
}

运行结果如下：

BookEntry constructor
Image constructor
AudioClip constructor
throw execption for testing!

BookEntry的析构函数没有被调用，Image对象并没有被释放，内存泄露了！这是因为面对尚未完全构造好的对象，C++拒绝调用其destructor。 如果destructor被调用于一个尚未完全构造好的对象身上, 这个destructor如何知道该做些什么事情呢？它唯一能够知道的机会就是：被加到对象的那些数据身上附带有某种指示，指示constructor进行到什么程度。那么destructor就可以检查这些数据（或许能够）理解应该如何应对。如此繁重的笔记工作会减低constructor的速度，使每一个对象变得更庞大。C++没有这样做。所以C++不会自动清理那些“构造期间抛出exception”的对象，所以你必须设计你的constructors，使他们在那种情况下亦能自我清理。

通常只需要将所有可能的exceptions捕捉起来，执行某种清理工作，然后重新抛出异常，使它继续传播出去即可。如下面代码：

#include <stdio.h>
#include <iostream>
using namespace std;

class Image
{
public:
    Image(const string& imageDataFileName) {  printf("Image constructor\r\n");}
    ~Image() { printf("Image destructor\r\n"); }
};

class AudioClip
{
public:
    AudioClip(const string& audioDataFileName) 
    { 
        printf("AudioClip constructor\r\n"); 
        throw invalid_argument("throw execption for testing!");

    }
    ~AudioClip() { printf("AudioClip destructor\r\n"); }
};


class BookEntry
{
public:
    BookEntry(string &imageDataFileName, string& audioDataFileName);   
    ~BookEntry();
private:
    Image *theImage;
    AudioClip *theAudioClip;
    void cleanup();
};

BookEntry::BookEntry(string &imageDataFileName, string& audioDataFileName):theImage(0),theAudioClip(0)  
{
    printf("BookEntry constructor\r\n");

    try
    {
        if(imageDataFileName != "")
        {
            theImage = new Image(imageDataFileName);
        }

        if(audioDataFileName != "")
        {
            theAudioClip = new AudioClip(audioDataFileName);
        }
    }
    catch(invalid_argument e)
    {
        printf("catched a exception in BookEntry constructor, now release the resource!\r\n");
        cleanup();
        throw;
    }
}

BookEntry::~BookEntry()
{
    printf("BookEntry destructor\r\n");
    cleanup();
}

void BookEntry::cleanup()
{
    printf("BookEntry cleanup\r\n");
    delete theImage;
    delete theAudioClip;
}

int main()
{
    string imageDataFileName("abc");
    string audioDataFileName("def");
    try
    {
        BookEntry bookEntry(imageDataFileName, audioDataFileName);
    }
    catch (invalid_argument e)
    {
        printf("%s\r\n", e.what());
        return -1;
    }

    return 0;
}

运行结果:

BookEntry constructor
Image constructor
AudioClip constructor
catched a exception in BookEntry constructor, now release the resource!
BookEntry cleanup
Image destructor
throw execption for testing!

进一步思考，如果theImage和theAudioClip都变成常量了会怎么样：

    Image * const theImage;
    AudioClip * const theAudioClip;

常量指针必须通过BookEntry constructor的成员初始链表加以初始化，如下所示：

BookEntry::BookEntry(string &imageDataFileName, string& audioDataFileName):
theImage(imageDataFileName != "" ? new Image(imageDataFileName):0),
theAudioClip(audioDataFileName != "" ? new AudioClip(audioDataFileName):0) 
{
    printf("BookEntry constructor\r\n");
}

但这却导致了我们最初想消除的问题：如果在theAudioClip初始化期间发生了exception， theImage所指对象不能销毁。此外我们也无法借此在constructor内加上try/catch语句来解决此问题，因为try和catch都是语句，而初始化链表只接受表达式。尽管如此，我们还有一种办法，就是封装对象的构造过程在其它private function内，让theImage和theAudioClip在其中获得初值，如下所示：

class BookEntry
{
public:
    BookEntry(string& imageDataFileName, string& audioDataFileName);   
    ~BookEntry();
private: 
    Image * InitImage(string& imageDataFileName);
    AudioClip * InitAudioClip(string& audioDataFileName);
    Image * const theImage;
    AudioClip * const theAudioClip;
};

BookEntry::BookEntry(string& imageDataFileName, string& audioDataFileName):
theImage(InitImage(imageDataFileName)),
theAudioClip(InitAudioClip(audioDataFileName)) 
{
    printf("BookEntry constructor\r\n");
}

对于第一个private函数InitImage， 因为image是最开始初始化的，不用捕捉异常。对于第二个private函数，需要捕捉异常并且在异常时销毁theImage。如下所示：

Image * BookEntry::InitImage(string& imageDataFileName)
{
    if(imageDataFileName != "") return new Image(imageDataFileName);

    return 0;
}

AudioClip * BookEntry::InitAudioClip(string& audioDataFileName)
{
    try 
    {
        if(audioDataFileName != "") return new AudioClip(audioDataFileName);
    }
    catch(invalid_argument e)
    {
        printf("catched a exception in %s, now release the resources\r\n",__func__);
        delete theImage;
        throw;
    }
    
    return 0;
}

这样做能解决问题，但是这样有没有不好的地方呢？有的！初始化函数要写成多个，并且初始化函数之间是有耦合性的，第二个调用的函数要释放第一个产生的对象，第三个调用的要释放第二个以及第一个产生的对象...代码不够clean.  那么有没有更加好一点的方案呢？答案是智能指针！将theImage和theAudioClip所指对象为资源，交给局部对象来管理。不论theImage和theAudioClip作为局部变量何时释放（生命周期到），其所指资源一定得到释放。在发生异常时，BookEntry对象被销毁（虽然还没完全构造好）， 同时其下所有的对象（theImage，theAudioClip）也同样会被销毁，那么根据智能指针的特性，当指针销毁时，其所指资源一定会得到释放。完整代码如下：

#include <stdio.h>
#include <iostream>
#include <memory>
using namespace std;

class Image
{
public:
    Image(const string& imageDataFileName) {  printf("Image constructor\r\n");}
    ~Image() { printf("Image destructor\r\n"); }
};

class AudioClip
{
public:
    AudioClip(const string& audioDataFileName) 
    { 
        printf("AudioClip constructor\r\n"); 
        throw invalid_argument("throw execption for testing!");

    }
    ~AudioClip() { printf("AudioClip destructor\r\n"); }
};


class BookEntry
{
public:
    BookEntry(string &imageDataFileName, string& audioDataFileName);   
    ~BookEntry();
private:
    const unique_ptr<Image> theImage;
    const unique_ptr<AudioClip> theAudioClip;
};

BookEntry::BookEntry(string &imageDataFileName, string& audioDataFileName):
theImage(imageDataFileName != "" ? new Image(imageDataFileName):0),
theAudioClip(audioDataFileName != "" ? new AudioClip(audioDataFileName):0) 
{
    printf("BookEntry constructor\r\n");
}

BookEntry::~BookEntry()
{
    printf("BookEntry destructor\r\n");
}

int main()
{
    string imageDataFileName("abc");
    string audioDataFileName("def");
    try
    {
        BookEntry bookEntry(imageDataFileName, audioDataFileName);
    }
    catch (invalid_argument e)
    {
        printf("%s\r\n", e.what());
        return -1;
    }

    return 0;
}

运行结果：

Image constructor
AudioClip constructor
Image destructor
throw execption for testing!

至此，问题完美解决！

一条叫做nemo的鱼
关注
专栏目录
More Effective C++ 10：在构造函数中防止资源泄漏
qq_44800780的博客
05-24 223
如果你正在开发一个具有多媒体功能的通讯录程序。这个通讯录除了能存储通常的文字信息如姓名、地址、电话号码外，还能存储照片和声音。 可以这样设计： class Image // 用于图像数据 { public: Image(const string& imageDataFileName); ... }; class AudioClip // 用于声音数据 { public: AudioClip(const string& audioDataFileName); .
《More Effective C++》笔记
weixin_42065178的博客
01-29 1126
《More Effective C++》笔记
More Effective C++（条款10：在constructors内阻止资源泄露）
Unique-You的博客
03-12 322
1. “C++ 只会析构已完成的对象”，“面对未完成的对象，C++ 拒绝调用其析构函数”，因为对于一个尚未构造完成的对象，构造函数不知道对象已经被构造到何种程度，也就无法析构。当然，并非不能采取某种机制使对象的数据成员附带某种指示，“指示constructor进行到何种程度，那么destructor就可以检查这些数据并(或许能够)理解应该如何应对。但这种机制无疑会降低constructor的效率，...
10. 在constructors内阻止资源泄露
xupeng1644的博客
12-03 1178
如果在构造函数中抛出了一个异常，那么需要确保抛出异常前申请的资源能够被释放。这里不能期待析构函数来帮忙释放资源。因为面对尚未完全构造好的对象，C++拒绝调用其析构函数。因为析构函数不知道如果去析构，哪些成员已经构造好需要析构，哪些没有构造好不需要析构。如果需要使析构函数有这个能力，又会导致构造函数臃肿不堪，同时会降低构造函数的速度与效率，使每一个对象更加庞大。 由于C++不自动清理那些"构造期间抛...
More effective c++ 条款10（上）
追随技术的梦想
10-10 980
条款10：在构造函数中防止资源泄漏（上）如果你正在开发一个具有多媒体功能的通讯录程序。这个通讯录除了能存储通常的文字信息如姓名、地址、电话号码外，还能存储照片和声音（可以给出他们名字的正确发音）。为了实现这个通信录，你可以这样设计：class Image {                        // 用于图像数据public:  Image(const string& image
more effective C++条款十解析
weixin_38911779的博客
09-13 296
在处理异常的时候 利用对象来管理资源来避免资源泄露 我们的程序可能在某一条语句抛出异常，导致其之后的代码没有被执行。这时候我们利用对象来管理资源，避免泄露，你可能会说利用try  catch的形式，但是形式使我们的程序的复用性降低，并且可读性降低。利用对象来管理资源，如果抛出异常来的话，当程序离开其作用域析构函数就会被调用。避免资源泄露。 在构造函数内阻止资源泄露 构造函数尚未完成，C++不
7 More Effective C++—条款10（构造函数内阻止内存泄漏）
26栀子枫香
10-21 229
1 提出问题
Effective Modern C++ 纯人工翻译，持续更新，不为博你眼球，旨在自我提升
07-12 1720
纯手动翻译Effective Modern C++，志在学习，不为博你眼球！
cocos2d-x中的C++ 编码规范
Fairy的专栏
08-01 4020
声明务必要看 头文件 define用法 前向声明 内联函数 -inlh文件 函数参数顺序 include的命名和顺序 作用域 命名空间 非命名的命名空间 命名空间的使用规则 嵌套类 非成员函数静态成员函数全局函数 局部变量 静态变量和全局变量 类 在构造函数里面完成工作 初始化 显式构造函数 拷贝构造函数 委派和继承构造函数 结构体 vs 类 继承 多重继承 接口 操作符重载 访问控制 声明顺序 编
C++ STL中sort函数
weixin_43349440的博客
09-15 368
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1150
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
【C++】 —— string的使用
LH__1314的博客
09-16 1333
string类虽然不在STL的容器中，但string类十分重要，string类是对字符串的存储和相关操作。
CF C. Nikita and LCM
qq_74190237的博客
09-13 298
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 556
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 1011
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C++函数重载
Jason_from_China的博客
09-13 359
概念： C++支持在同一作用域中出现同名函数,但是要求这些同名函数的形参不同,可以是参数个数不同或者 类型不同。这样C++函数调用就表现出了多态行为,使用更灵活。C语言是不支持同一作用域中出现同名函数的。
完全背包（C++）
lim6ere的博客
09-11 930
DP42 【模板】完全背包以上就是今天要讲的内容，本文仅仅详细介绍了。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
CCF201903_1
m0_67663419的博客
09-14 228
【代码】CCF201903_1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一条叫做nemo的鱼

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值