C++学习 一、shared_ptr使用

前言

本篇开启C++专题。本来应该从最基础的数据类型开始,但为了服务于看代码,写到哪算哪。

C++11提供了智能指针类,包括unique_ptr,shared_ptr,weak_ptr三种,用以自动释放内存、减少内存泄漏和保障线程安全。首先从shared_ptr开始。

shared_ptr概述

shared_ptr即共享指针,因此多个shared_ptr对象可以与同一个指针相关联。

shared_ptr内部具有两个指针:

  1. 指向对象
  2. 指向控制引用计数的资源

第一个指针与普通指针无异,第二个指针用于计数自身被引用次数。

shared_ptr的构造函数会开辟出新的一片引用计数的资源,引用计数=1;拷贝构造函数不会开辟新的资源,而是使引用计数+1;当shared_ptr对象被销毁时,其相关的引用计数-1;当引用计数为0时,通过delete释放指针指向的内存,销毁指针。

创建shared_ptr对象

0 声明shared_ptr对象

std::shared_ptr<double> p1;

1 通过堆指针创建shared_ptr对象

std::shared_ptr<double> p2(new double(2.));

2 通过拷贝构造函数创建shared_ptr对象

std::shared_ptr<double> p3(p2);
// 等价于
std::shared_ptr<double> p3 = p2;

3 通过赋值运算符修改shared_ptr

p1 = p3;

4 通过std::make_ptr函数初始化

std::shared_ptr<double> p4 = std::make_shared<double>(3.0);
// 也可以初始化一个空对象
std::shared_ptr<double> p4 = std::make_shared<double>();

几个shared_ptr对象初始化问题

shared_ptr类禁止构造函数的隐式转换

 //std::shared_ptr<double> p3 = new double(3.0); error! forbid implicit conversions

这是因为销毁内部指针时,使用的是delete函数。

不能用栈指针进行初始化

//double x = 5.0;
//std::shared_ptr<double> p5(&x);
// error! invalid pointer

不能将同一普通指针给多个shared_ptr对象初始化

//std::shared_ptr<double> p3(p2.get());
//std::shared_ptr<double> p4(p2.get());

上面的初始化通过p2内的对象指针初始化p3和p4,当p3,p4的生命周期结束时,将会包delete double的错误。

原因是:两次初始化得到的p3,p4的引用计数都是1,首先销毁p4,其引用计数变为0,释放p2.get()指针指向的内存;然后销毁p3,其引用也变为0,再次释放内存。

循环引用问题

shared_ptr还有一个容易出现的循环引用问题,代码如下:

class A;
class B;

class A
{
public:
    std::shared_ptr<B> b_;
public:
    A(){
        std::cout << "construct A" << std::endl;
    }
    ~A(){
        std::cout << "destroy A" << std::endl;
    }
};

class B
{
public:
    std::shared_ptr<A> a_;
public:
    B(){
        std::cout << "construct B" << std::endl;
    }
    ~B(){
        std::cout << "destroy B" << std::endl;
    }
};

// *** circular reference *** ///
std::shared_ptr<A> a(new A());
std::shared_ptr<B> b(new B());
a->b_ = b;
b->a_ = a;

运行以上代码会发现,程序结束时,指针对象a,b的析构函数都没有被调用。

原因:创建a,b对象时,引用计数分别为1;a->b_ = b,对象b的引用计数为2,b->a_ = a,对象a的引用计数为2;销毁对象b,b的引用计数变为1(b_);销毁对象a,a的引用计数变为1(a_),a_,b_仍然没有被销毁,导致内存溢出。

对于这种问题,更好的理解方式是在内存层面上的,这个以后会提到。解决循环引用可以使用weak_ptr,这个将在下篇中学习。

shared_ptr与操作符

shared_ptr拥有和普通指针一样的访问数据方法*,->

std::shared_ptr<double> p2(new double(2.));
*p2;

也重载了=,==,!=,>,<,等赋值和比较操作:

p2 = nullptr;
p2 == nullptr;

但是没有++,–等算术操作。

shared_ptr的成员函数

shared_ptr主要有以下几个成员函数:

reset():重置函数,如果参数为空则把对象变为空指针,引用计数-1;如果参数为一个普通堆指针,则相当于把对象与该指针关联,原引用计数-1,新引用计数+1。

std::shared_ptr<double> p2(new double(2.));
p2.reset();

get()获得内部指针。

swap()用于把两个shared_ptr对象的内部指针做交换。

unique()用于判断与内部指针关联的shared_ptr对象是否唯一。

use_count()用于输出引用计数值。

shared_ptr数组

可以通过shared_ptr定义数组,但shared_ptr的析构函数只会释放数组的第一个对象,导致内存泄漏,因此需要提供删除器。

可以提供C++11提供的删除器default_delete

shared_ptr<A> pVec(new A[10](), std::default_delete<A[]>());

还要注意的是,shared_ptr没有++,–等算术运算符,也没有[]运算符,因此不能通过pVec[0]这样取数组成员值。

测试用代码

#include <iostream>
#include <memory>

class A;
class B;

class A
{
public:
    std::shared_ptr<B> b_;
public:
    A(){
        std::cout << "construct A" << std::endl;
    }
    ~A(){
        std::cout << "destroy A" << std::endl;
    }
};

class B
{
public:
    std::shared_ptr<A> a_;
public:
    B(){
        std::cout << "construct B" << std::endl;
    }
    ~B(){
        std::cout << "destroy B" << std::endl;
    }
};



int main(int argc, char **argv) {
    // *** construct shared ptr *** ///
    std::shared_ptr<double> p1;
    std::shared_ptr<double> p2(new double(2.));
    p1 = p2;
    std::cout << "p1 count: " << p1.use_count() << std::endl;
    p2.reset();
    std::cout << "p1 count: " << p1.use_count() << std::endl;
    // std::shared_ptr<double> p3 = new double(3.0); error! forbid implicit conversions
    std::shared_ptr<double> p3 = std::make_shared<double>(3.0);

    std::shared_ptr<double> p4 = p3;
    std::cout << "p4 unique: " << p4.unique() << std::endl;
    p3.reset(new double(3.0));
    std::cout << "p4 unique: " << p4.unique() << std::endl;

    //double x = 5.0;
    //std::shared_ptr<double> p5(&x);
    // std::cout << "p5: " << *p5 << std::endl; // error! invalid pointer
    std::shared_ptr<double> p5(new double(5.0));
    std::shared_ptr<double> p6 = p5;
    std::shared_ptr<double> p7 = p5;
    std::cout << "p5 count: " << p5.use_count() << std::endl;
    //p2.reset(p5.get()); // error! double free
    std::cout << "p5 count: " << p5.use_count() << std::endl;

    // *** circular reference *** ///
    std::shared_ptr<A> a(new A());
    std::shared_ptr<B> b(new B());
    a->b_ = b;
    b->a_ = a;

    std::cout << p3 << "  " << p5 << std::endl;
    p3.swap(p5);
    std::cout << p3 << "  " << p5 << std::endl;
   
    std::shared_ptr<A> pVec(new A[10], std::default_delete<A[]>());
    std::shared_ptr<int> pVecNum(new int[5](), std::default_delete<int[]>());

    std::cout << pVecNum << std::endl;

    return 1;
}

后记

下篇讲 unique_ptr

  • 6
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值