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

最新推荐文章于 2024-11-02 20:20:37 发布
最新推荐文章于 2024-11-02 20:20:37 发布
阅读量742 收藏
点赞数
分类专栏： 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++》笔记
weixin_42065178的博客
01-29 1205
《More Effective C++》笔记
More Effective C++中文版
04-07
　全面地描述了C++专家所使用的高级技术，包括placement new、virtual constructors、smart pointers、reference counting、proxy classes和double-dispatching等。 　以实例说明异常处理带给C++类和函数的冲击。 　...
More Effective C++（条款10：在constructors内阻止资源泄露）
Unique-You的博客
03-12 346
1. “C++ 只会析构已完成的对象”，“面对未完成的对象，C++ 拒绝调用其析构函数”，因为对于一个尚未构造完成的对象，构造函数不知道对象已经被构造到何种程度，也就无法析构。当然，并非不能采取某种机制使对象的数据成员附带某种指示，“指示constructor进行到何种程度，那么destructor就可以检查这些数据并(或许能够)理解应该如何应对。但这种机制无疑会降低constructor的效率，...
10. 在constructors内阻止资源泄露
xupeng1644的博客
12-03 1192
如果在构造函数中抛出了一个异常，那么需要确保抛出异常前申请的资源能够被释放。这里不能期待析构函数来帮忙释放资源。因为面对尚未完全构造好的对象，C++拒绝调用其析构函数。因为析构函数不知道如果去析构，哪些成员已经构造好需要析构，哪些没有构造好不需要析构。如果需要使析构函数有这个能力，又会导致构造函数臃肿不堪，同时会降低构造函数的速度与效率，使每一个对象更加庞大。 由于C++不自动清理那些"构造期间抛...
More effective c++ 条款10（上）
追随技术的梦想
10-10 1016
条款10：在构造函数中防止资源泄漏（上）如果你正在开发一个具有多媒体功能的通讯录程序。这个通讯录除了能存储通常的文字信息如姓名、地址、电话号码外，还能存储照片和声音（可以给出他们名字的正确发音）。为了实现这个通信录，你可以这样设计：class Image {                        // 用于图像数据public:  Image(const string& image
more effective C++条款十解析
weixin_38911779的博客
09-13 312
在处理异常的时候 利用对象来管理资源来避免资源泄露 我们的程序可能在某一条语句抛出异常，导致其之后的代码没有被执行。这时候我们利用对象来管理资源，避免泄露，你可能会说利用try  catch的形式，但是形式使我们的程序的复用性降低，并且可读性降低。利用对象来管理资源，如果抛出异常来的话，当程序离开其作用域析构函数就会被调用。避免资源泄露。 在构造函数内阻止资源泄露 构造函数尚未完成，C++不
7 More Effective C++—条款10（构造函数内阻止内存泄漏）
26栀子枫香
10-21 252
1 提出问题
More Effective C++
baidu_16370559的博客
03-08 4328
Scott Meyers大师Effective三部曲：Effective C++、More Effective C++、Effective STL。 1. 指针与引用的区别 相同点：指针和引用都是让你间接引用其它对象。 不同点： 1.在任何情况下都不能使用指向空值的引用。一个引用必须总是指向某些对象。在C++里，引用应被初始化。 不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针的要高。因为在使用引用之前不需要测试它的合法性。 2.指针与引用的另一个重要的不同是指针可以被重新赋值以指向
More Effective C++：3、异常
qq_30534935的博客
10-14 242
C++新增的异常 (exception) 机制改变了某些事情，这种改变是深刻的，彻底的，可能是令人不舒服的。例如：使用未经处理的或原始的指针变得很危险;资源泄漏的可能性增加了；写出具有你希望的行为的构造函数与析构函数变得更加困难。特别小心防止程序执行时突然崩溃。执行程序和库程序尺寸增加了，同时运行速度降低了。 这就使我们所知道的事情。很多使用 C++ 的人都不知道在程序中使用异常，大多数人不知道...
More Effective C++中文版（封面绝对是最新版）（带目录）
10-29
　虽然出版年代稍嫌久远，但本书并没有第2版，原因是当其出版之时（1996），C++ Standard已经几乎定案，《More Effective C++：35个改善编程与设计的有效方法（中文版）》即依当时的标准草案而写，其与现今的C++ ...
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 245
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 212
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 585
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1197
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C++ -- 模板进阶
最新发布
zy1215058242的博客
11-02 661
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 188
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
C语言用GNU源码编译建构系统工具（GNU BUILD SYSTEM）编译创建源码包
gwsong52的博客
10-30 865
C语言用GNU源码编译建构系统工具（GNU BUILD SYSTEM）编译创建源码包，Makefile.am配置文件的编写、autoconf、configure、make等工具的用法。
提升C++编程效率：Effective.C++中文版要点解析
"Effective.C++中文版.pdf" Effective C++ 是一本经典的C++编程指南，旨在帮助程序员提升代码质量，减少错误，并充分利用C++语言的特性。本书深入探讨了C++中的最佳实践和常见陷阱，特别关注如何利用C++的高级特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一条叫做nemo的鱼

你的鼓励是我最大的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值