浅谈C++11智能指针

微信搜索“编程笔记本”,获取更多信息
------------- codingbook2020 -------------

C++ 需要程序员手动管理内存,而内存的使用又离不开指针。申请的空间在函数结束时忘记释放,就会造成内存泄漏。而智能指针的作用就是管理指针,使用指针指针可以很大程度上避免内存泄漏的问题。

智能指针的本质是一个类,当超出了类的作用域时,类会自动调用析构函数,析构函数会释放资源。智能指针的作用原理就是在函数结束时自动释放内存空间,而不需要程序员手动释放。

1. auto_ptr

auto_ptr 是 STL 的智能指针之一,由 C++98 引入,定义在头文件 <memory>中。出于安全考虑,C++11 已经弃用 auto_ptr,用更安全、更灵活的 unique_ptr 代替。auto_ptr 采用所有权模式,auto_ptr 对象通过初始化指向由 new 创建的动态内存,它是这块内存的拥有者,一块内存不能同时被分给两个拥有者。当 auto_ptr 对象生命周期结束时,其析构函数会将 auto_ptr 对象拥有的动态内存自动释放。

我们下来看一个示例:

auto_ptr<string> p1 = new string("I am a string");  // p1 拥有该字符串的所有权
auto_ptr<string> p2;
p2 = p1;    // 语句合法,此时字符串的所有权被 p2 剥夺

接下来我们可以正常地通过 p2 去访问字符串,但 p1 并没有被销毁,它仍然指向该字符串,但当我们试图通过 p1 去访问字符串就会报错,导致程序崩溃。

正是由于潜在这种内存崩溃的问题,C++11 已经弃用 auto_ptr。

2. unique_ptr

发现问题就要解决问题。unique_ptr 就是为了解决 auto_ptr 转移所有权带来的弊端而提出来的。unique_ptr 采用独占式拥有严格拥有的概念,确保同一时间内只有一个指针指向给定内存。unique_ptr 不共享它管理的对象,也无法复制到其他的unique_ptr ,只能移动 unique_ptr ,即对资源管理权限可以实现转移。这意味着,内存资源所有权可以转移到另一个 unique_ptr ,并且原始的 unique_ptr 不再拥有该资源。

我们再来看一下上面的例子:

unique_ptr<string> p1 = new string("I am a string");  // p1 严格拥有该字符串的所有权
unique_ptr<string> p2;
p2 = p1;    // 语句不合法

正是由于编译器不允许上面示例中的赋值行为,才有效避免了 p1 不再指向有效数据的问题,因此 unique_ptr 比 auto_ptr 更安全。

当然了,这只是说编译器不允许对 unique_ptr 对象之间直接进行赋值,但我们还有另外一种方式,看下面的示例:

unique_ptr<string> p1 = new string("I am a string");  // p1 严格拥有该字符串的所有权
unique_ptr<string> p2;
// p2 = p1;    // 语句不合法
p2 = unique_ptr<string>(new string("I am a string"));    // 语句合法

这又是为什么呢?仔细分析一下就不难得出结论。unique_ptr<string>(new string("I am a string"))虽然是一个 unique_ptr 对象,但这个对象在此之前并没有被任何变量拥有,也就是说,这是个临时右值,既然它没有被任何变量拥有,那么我们可以首次将其“安置”某一变量,“安置”完成后,临时对象就会自动调用析构函数进行销毁,就不会留下悬挂的 unique_ptr 对象了。

既然不允许赋值,那我们前面说的可以转移资源的管理权限又要怎么实现呢?

原来,C++ 设计了一个标准库函数 std::move(),通过该函数我们能够实现unique_ptr 之间的移动。

#include <iostream>
#include <string>
#include <memory>

using namespace std;

int main() {
    unique_ptr<string> p1(new string("I am a string"));
    unique_ptr<string> p2;
    p2 = move(p1);

    cout << *p2 << endl;    // I am a string

    // cout << *p1 << endl;    // 错误,因为 p1 已经不再拥有该字符串的管理权
    // 但是 p1 仍然是个 unique_ptr 对象,我们可以重新为其赋值
    p1 = unique_ptr<string> (new string("I am also a string"));
    cout << *p1 << endl;    // I am also a string

    return 0;
}

/*
运行结果:
I am a string
I am also a string
*/

3. shared_ptr
shared_ptr 采用共享式拥有概念。多个智能指针可以指向相同的对象,该对象及其相关资源会在最后一个引用被销毁时释放。顾名思义,shared_ptr 指向的资源会被多个指针共享,它使用计数机制来记录资源被多少指针共享,通过成员函 use_count()来查看资源所有者的数量。通过调用 reset()函数,当前指针会释放资源的所有权,资源所有者数量减一。除了可以通过 new 来构造,还可以通过传入 auto_ptr,unique_ptr,weak_ptr 来构造。

#include <iostream>
#include <string>
#include <memory>

using namespace std;

int main() {
    shared_ptr<string> p1(new string("I am a string"));
    shared_ptr<string> p2;
    p2 = p1;

    cout << *p1 << endl;    // I am a string
    cout << *p2 << endl;    // I am a string

    cout << p1.use_count() << endl;    // 2
    p1.reset();
    cout << p2.use_count() << endl;    // 1

    return 0;
}

/*
运行结果:
I am a string
I am a string
2
1
*/

下面介绍几个 shared_ptr 常用的成员函数。

use_count    // 返回当前资源的引用计数
unique       // 返回当前资源是否被独占(use_count=1)
swap         // 交换两个 shared_ptr 对象
reset        // 放弃当前资源的所有权,引起引用计数 -1
get          // 返回当前资源的指针(由于重载了()方法,因此 p 与 p.get() 等价)

4. weak_ptr

weak_ptr 是一种不控制对象生命周期的智能指针,它指向一个 shared_ptr 管理的对象。weak_ptr 设计的目的是为了配合 shared_ptr 工作,提供了对 shared_ptr 管理对象的一个访问手段。weak_ptr 可以从一个 shared_ptr 或另一个 weak_ptr 对象来构造,它的构造函数和析构函数不会引起引用计数的增加或减少。weak_ptr 和 shared_ptr 之间可以相互转换,shared_ptr 可以 直接赋值给 weak_ptr ,weak_ptr 通过成员函数 lock()来获得 shared_ptr 。

关于 weak_ptr 是怎么配合 share_ptr 工作的,我们通过后面的具体示例来说明。


既然智能指针这么牛皮,那使用智能指针应该不会引起内存泄漏了吧?
答案是:你想得美!

下面我们就来看一下使用智能指针仍然存在内存泄漏的示例:

#include <iostream>
#include <memory>

using namespace std;

class B;

class A {
public:
    void setp(shared_ptr<B> p) {
        ppb = p;
    }
    ~A() {
        cout << "A is destroyed" << endl;
    }
private:
    shared_ptr<B> ppb;
};

class B {
public:
    void setp(shared_ptr<A> p) {
        ppa = p;
    }
    ~B() {
        cout << "B is destroyed" << endl;
    }
private:
    shared_ptr<A> ppa;
};


void test() {
    shared_ptr<A> pa(new A);
    shared_ptr<B> pb(new B);

    pa->setp(pb);
    pb->setp(pa);

    cout << pa.use_count() << endl;    // 2
    cout << pb.use_count() << endl;    // 2
}

int main() {
    test();
    return 0;
}

上面的示例,在 test 函数中定义了两个智能指针对象,他们互相引用,从而导致这两个智能指针的引用计数都是 2 。当跳出 test 函数时,两个智能指针的引用计数各自减一,此时二者的引用计数都为 1 。

那这意味着什么呢?

智能指针的引用计数不为零,那么智能指针的析构函数就不会被调用,也就是说,在 test 函数中请求的资源就不会被释放。而 test 函数已经退出了,资源却没有被释放,这无疑是一种内存泄漏。

那这个问题该怎么解决呢?还记得上面我们讲过的 weak_ptr 吗?对了,该它登场了!

前面说到 weak_ptr 不会引起引用计数的增减,那我们将其中的一个 shared_ptr 改为 weak_ptr 来看看会怎么样。

#include <iostream>
#include <memory>

using namespace std;

class B;

class A {
public:
    void setp(shared_ptr<B> p) {
        ppb = p;
    }
    ~A() {
        cout << "A is destroyed" << endl;
    }
private:
    shared_ptr<B> ppb;
};

class B {
public:
    void setp(weak_ptr<A> p) {
        ppa = p;
    }
    ~B() {
        cout << "B is destroyed" << endl;
    }
private:
    weak_ptr<A> ppa;
};


void test() {
    shared_ptr<A> pa(new A);
    shared_ptr<B> pb(new B);

    pa->setp(pb);
    pb->setp(pa);

    cout << pa.use_count() << endl;    // 1
    cout << pb.use_count() << endl;    // 2
}

int main() {
    test();
    return 0;
}

/*
运行结果:
1
2
A is destroyed
B is destroyed
*/

上面的示例中,我们将类 B 中的私有智能指针改为 weak_ptr 。从结果中可以看到,pa 的引用计数为 1 ,pb 的引用计数为 2 。这是因为,将 shared_ptr 传递给 weak_ptr 并不会使得 shared_ptr 的引用计数增加。还可以看到,当 test 函数退出时,pa 的作用域结束,pa 的引用计数从 1 减为 0 ,所以 A 的析构函数被调用,当 A 的析构函数被调用后,pb 的引用计数会从 2 减为 1 ,而随着 test 函数的退出,pb 的作用域结束,pb 的引用计数又从 1 减为 0, 所以 B 的析构函数被调用。至此,资源被清理完成,未产生内存泄漏。

点击下方图片关注我,或微信搜索**“编程笔记本”**,获取更多信息。

发布了19 篇原创文章 · 获赞 0 · 访问量 212
展开阅读全文
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览