Effective C++ 条款13 以对象管理资源

女爷i 2022-05-13 09:10 231阅读 0赞

//
    //  main.cpp
    //  条款13：以对象管理资源
    //
    //  Created by 于磊 on 2018/7/8.
    //  Copyright © 2018 于磊. All rights reserved.
    //
    
    #include <iostream>
    class Investment {
    public:
        ~Investment(){
            std::cout<<" release ! "<<std::endl;
        }
    };
    
    Investment *createInvestment() {
        static Investment *investment = nullptr;//条款4
        if (!investment)
            investment = new Investment();
        return investment;
    }
    int main(int argc, const char *argv[]) {
        Investment *pInv = createInvestment();//不太好的写法
        std::auto_ptr<Investment>pInv1(createInvestment());//使用auto_ptr注意，在auto_ptr析构时会
        std::auto_ptr<Investment>pInv2(pInv1);             //销毁所指物，所以多个auto_ptr指向同一对象，
        pInv1 = pInv2;                                     //此对象会被销毁一次以上，产生未定义行为
        //替代者是shared_ptr
        std::shared_ptr<Investment>pSInv1(createInvestment());
        std::shared_ptr<Investment>pSInv2(pSInv1);
        pSInv1 = pSInv2;
        return 0;
    }

1. 在使用堆开辟内存后,需要手动delete指针以防内存泄露，但有难免会产生不可避免的情况，例如产生异常会使得内存资源无法释放，另外使用者也极有可能忘记释放“堆内存”。因此有必要借助以对象的析构函数将资源管理起来，以确保资源被正确的释放，,这种思想被称为"资源取得时机就是初始化时机"(Resource Acquisition is Initialization; RAII,名字并没有体现这种思想)

2. 除了手动编写一个指针类以外,C++标准库提供了auto\_ptr类模板(在<memory>头文件中),使用它需注意:

a. auto\_ptr<T>只能由T\*显示初始化或由auto\_ptr<T>对象初始化

b. auto\_ptr<T>只能指向堆内存,因为它的析构函数会delete它所指向的对象,因此务必不要用指向堆栈的指针初始化auto\_ptr<T>

c. auto\_ptr<T>没有使用计数的概念,同一块内存只能由一个auto\_ptr<T>指向,auto\_ptr<T>对象的赋值操作和拷贝构造会使右操作数指向NULL.由于auto\_ptr<T>的复制不同于一般意义上的复制,因此它不能作为STL容器的元素.

std::auto_ptr<Investment>pInv1(createInvestment());//使用auto_ptr注意，在auto_ptr析构时会
    std::auto_ptr<Investment>pInv2(pInv1);             //销毁所指物，所以多个auto_ptr指向同一对象，
    pInv1 = pInv2;                                     //此对象会被销毁一次以上，产生未定义行为

3. 从上图中可以看出,auto\_ptr的使用具有一定局限性和危险性,并且它所管理的内存不能同时被多个auto\_ptr引用,TR1的"引用计数型智能指针"(reference-counting smart poiner; RCSP) shared\_ptr就是一个很好的替代品."TR1代表'Technical Report 1',那是C++程序库工作小组对该份文档的称呼",TR1是C++ 03标准的一个扩展,它并不属于C++ 03标准,只是一份草稿文件,但它所提出的项目很可能成为官方标准,它叙述了14个新组件,统统放在命名空间std内,其中包括shared\_ptr和weak\_ptr,gcc和vs2008SP2以上已经可以支持它了gcc需要include头文件<tr1/memory>,vs需要include头文件<memory>,有的编译器需要装boost库并且include<boost/shared\_ptr.hpp>和<boost/weak\_ptr.hpp>才可以使用(需加命名空间限定boost::)

shared\_ptr<T>的使用比较简单,它具有引用计数功能,通过使用use\_count()观测资源的引用计数,使用unique()观测判断引用计数是否为1(若为1返回true),使用reset()将指针重设(默认设为空)(详细成员函数介绍见

[http://www.cplusplus.com/reference/memory/shared\_ptr/][http_www.cplusplus.com_reference_memory_shared_ptr]),可以共享对象的所有权,只有最后一个指向该对象的指针被撤销时,它所指向的堆内存才会被释放,属于强引用(只要有一个强应用存在,所指对象就不能释放),因此不能解决循环引用的问题,以下就是一个循环引用的例子:

#include<iostream>
    #include<memory>
    using namespace std;
    class A;
    class B;
    class A{
    public:
        shared_ptr<B> ptrb;
        ~A(){ cout << "A was destructed!" << endl; }
    };
    class B{
    public:
        shared_ptr<A> ptra;
        ~B(){ cout << "B was destructed!" << endl; }
    };
    void foo(){
        shared_ptr<A>  s_ptra(new A());
        shared_ptr<B>  s_ptrb(new B());
        s_ptra->ptrb = s_ptrb;
        s_ptrb->ptra = s_ptra;
    }
    
    int main(int argc, const char * argv[]) {
        foo();
        return 0;
    }

当然无任何运行结果，可见,当foo()被调用结束后,尽管ptr\_a和ptr\_b被销毁,但a和b形成了循环引用,资源无法被释放。

位于堆内存中的a和b的成员ptr\_a和ptr\_b分别指向a和b导致a和b既不能被释放,又不能被使用,从而造成循环引用.

要解决循环引用,就要使用弱引用——weak\_ptr.

weak\_ptr只能通过shared\_ptr或weak\_ptr来初始化,它不会增加使用计数,也不可以通过它来访问所引用的对象,它的作用是协助shared\_ptr来访问,通过使用成员函数lock()来获得一个与它指向相同对象的shared\_ptr对象,通过使用use\_count()观测资源的引用计数，使用expired()观测判断所指向的内存是否被释放(若被释放返回true),使用reset()将指针重设(默认设为空)(详细成员函数介绍见[http://www.cplusplus.com/reference/memory/weak\_ptr/][http_www.cplusplus.com_reference_memory_weak_ptr]).要使用弱引用来打破循环引用,只要把循环引用的其中一方所使用的指针成员改为弱引用即可,即:

#include<iostream>
    #include<memory>
    
    using namespace std;
    class A;
    class B;
    class A{
    public:
        weak_ptr<B> ptrb;
        ~A(){ cout << "A was destructed!" << endl; }
    };
    class B{
    public:
        shared_ptr<A> ptra;
        ~B(){ cout << "B was destructed!" << endl; }
    };
    void foo(){
        shared_ptr<A>  s_ptra(new A());
        shared_ptr<B>  s_ptrb(new B());
        s_ptra->ptrb = s_ptrb;
        s_ptrb->ptra = s_ptra;
    }
    
    int main(int argc, const char * argv[]) {
        foo();
        return 0;
    }

运行结果为:

![70][]

4. 注意:

1). 不管auto\_ptr,shared\_ptr还是weak\_ptr它们只用于指向单个对象而不是数组,实际上vector和string就可以取代动态分配的数组,此外,在boost中提供了boost::scoped\_array和shared\_array用于指向动态分配的数组.

2). shared\_ptr不要与普通指针交互使用,例如,对于以下代码:

int* p = new int;
        shared_ptr<int> ptr(p);
        cout << ptr.use_count() << endl;
        delete p;
        cout << ptr.use_count();

程序甚至会出错!

5. C++标准并没有针对动态分配数组"而设计的类似auto\_ptr或tr1::shared\_ptr的模板(TR1中也没有),毕竟使用vector和string就可以取代所有动态内存分配取得的数组.幸运的是Boost库提供的boost::scoped\_array和boost::shared\_array 提供这种功能.

[http_www.cplusplus.com_reference_memory_shared_ptr]: http://www.cplusplus.com/reference/memory/shared_ptr/
[http_www.cplusplus.com_reference_memory_weak_ptr]: http://www.cplusplus.com/reference/memory/weak_ptr/
[70]: /images/20220513/9170f27205f84a4eba2a3f802bd2bdf7.png