C++基础智能指针

于 2024-09-05 19:05:10 发布
阅读量805 收藏 6
点赞数 27
文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50357983/article/details/141938267
版权

目录

一、引入背景

二、智能指针 

三、unique_ptr(独占智能指针)

3.1 独占智能指针的概述

3.2 类的原型

3.3 初始化 

3.4 独占智能指针的注意事项

3.5 智能指针的更多技巧

四、shared_ptr（共享智能指针）

4.1 概述

 4.2 基本使用

4.3 更多细节

五、智能指针的删除器（了解）

六、weak_ptr(弱智能指针)

6.1 引入目的

6.2 weak_ptr是什么

6.3 如何使用weak_ptr

6.4 weak_ptr的使用

一、引入背景

        1> C++中在堆区申请空间和释放空间需要使用new和delete完成

        2> 多个指针指向同一个内存空间，释放其中一个的空间，另一个还在继续使用（悬空指针）

        3> 只是申请了内存空间，使用后忘记释放内存空间，堆区对象没有得到析构

        4> 栈取申请的对象空间，在脱离对象空间后，会自动调用析构函数完成资源的回收，但是堆区的不会自动释放

 

#include <iostream>
​
using namespace std;
class Test
{
private:
    string name;
public:
    Test() {cout<<"Test::无参构造"<<endl;}
    Test(string n):name(n) {cout<<name<<"::有参构造"<<endl;}
    ~Test() {cout<<name<<"::析构函数"<<endl;}
};
​
int main()
{
    Test *p = new Test("张飞");
​
    cout << "Hello World!" << endl;
    return 0;
}

 

        5> 总结：上述例子中，在堆区申请一个对象空间，但是没有手动释放空间，造成对象没有析构，为了保证堆区空间使用的安全性，我们引入了智能指针，目的是更加安全的使用堆区空间。

二、智能指针 

        1> C++11标准提供了两种智能指针，分别是unique_ptr（独占智能指针）、shared_ptr（共享智能指针）

        2> 除了上述两种指针外，还有auto_ptr（自动智能指针，已弃用）、weak_ptr（弱智能指针，辅助shared_ptr作用）

        3> 以上所有智能指针都在头文件：#include中

        4> 智能指针是类模板，在栈区创建智能指针对象

        5> 把普通指针交给智能指针管理

        6> 智能指针对象过期时，析构函数会自动释放智能指针管理的指针空间

三、unique_ptr(独占智能指针)

3.1 独占智能指针的概述

        独占智能指针会“拥有”它所指向的对象，某一时刻，只能有一个unique_ptr指向给定的对象，当该指针被销毁时，指向的对象也会随之释放。

3.2 类的原型

template <typename T, typename D = default_delete<T>>
class unique_ptr
{
public:
    explicit unique_ptr(pointer p) noexcept; // 不可用于转换函数。
    ~unique_ptr() noexcept;
    T& operator*() const;  // 重载*操作符。
    T* operator->() const noexcept; // 重载->操作符。
    unique_ptr(const unique_ptr &) = delete; // 禁用拷贝构造函数
    unique_ptr& operator=(const unique_ptr &) = delete; // 禁用赋值函数
    unique_ptr(unique_ptr &&) noexcept; // 右值引用。
    unique_ptr& operator=(unique_ptr &&) noexcept; // 右值引用
    
private:
    pointer ptr; // 内置的指针。
};

3.3 初始化 

方法一: unique_ptr<AA> p0(new AA("西施"));// 分配内存并初始化。

方法二: unique_ptr<AA> p0 = make_unique<AA>("西施"); // C++14标准。

方法三: AA* p = new AA("西施"); unique_ptr<AA> p0(p); // 用已存在的地址初始化。

1> 方法三

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
int main()
{
    Test *p1 = new Test("张三");          //在堆区申请空间
    unique_ptr<Test> up1(p1);            //使用原始指针实例化一个指针指针
​
    cout<<"name = "<<(*p1).name<<endl;        //指针找到对象使用
    cout<<"name = "<<p1->name<<endl;          //原始指针直接使用
    cout<<"name = "<<(*up1).name<<endl;       //智能指针访问
    cout<<"name = "<<up1->name<<endl;          //智能指针访问
​
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

2> 使用方式1：

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
int main()
{
​
    unique_ptr<Test> up1(new Test("张三"));            //使用原始指针实例化一个指针指针
​
​
    cout<<"name = "<<(*up1).name<<endl;       //智能指针访问
    cout<<"name = "<<up1->name<<endl;          //智能指针访问
​
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

 3> 使用方法2只有C++14标准后才能使用，C++11标准不支持

3.4 独占智能指针的注意事项

1> 重载的*和->运算符重载，所以可以跟像使用普通指针一样使用该智能指针

2> 不支持拷贝构造和拷贝赋值函数

3> 不要使用一个原始指针初始化多个unique_ptr

4> get()函数可以返回该智能指针的原始指针

5> 不要使用unique_ptr指向非new申请的空间

6> 有智能指针指向原始指针后，就不要再用原始指针手动释放了

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
int main()
{
    Test *p1 = new Test("张三");
​
    unique_ptr<Test> up1(p1);            //使用原始指针实例化一个指针指针
    unique_ptr<Test> up2(p1);           //使用一个原始指针实例化多个智能指针
​
​
​
    cout<<"name = "<<(*up1).name<<endl;       //智能指针访问
    cout<<"name = "<<up1->name<<endl;          //智能指针访问
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

7> 智能指针作为函数参数传递时，传递引用，不要传递值，因为智能指针没有拷贝构造函数

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
//void fun(unique_ptr<Test> up)        //定义时不会报错，但是使用时会报错
void fun(unique_ptr<Test> &up)
{
    
}
​
​
​
int main()
{
    Test *p1 = new Test("张三");
​
    unique_ptr<Test> up1(p1);            //使用原始指针实例化一个指针指针
​
​
    cout<<"name = "<<(*up1).name<<endl;       //智能指针访问
    cout<<"name = "<<up1->name<<endl;          //智能指针访问
    
    //调用函数传递智能指针的值
    fun(up1);                  //报错，会告诉没有拷贝构造函数
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

 8> 智能指针不支持：+、-、++、--

3.5 智能指针的更多技巧

        1> 将一个智能指针unique_ptr赋值给另一个指针时，可以赋值右值（移动构造存在），但是不能赋值左值（拷贝构造不存在）

        2> 使用nullptr给unique_ptr赋值时，会自动释放对象

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
​
​
​
int main()
{
    Test *p1 = new Test("张三");
​
    unique_ptr<Test> up1(p1);            //使用原始指针实例化一个指针指针
​
​
    cout<<"name = "<<(*up1).name<<endl;       //智能指针访问
    cout<<"name = "<<up1->name<<endl;          //智能指针访问
​
    up1 = nullptr;                     //用空指针给智能指针赋值时，会释放智能指针指向的对象
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

        3> 使用release（）函数，可以释放unique_ptr的指针，并且将原指针返回

        4> std::move函数，可以转移原始指针的控制权，本质上调用的时移动构造函数

 

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
//函数1需要一个指针，但是不对这个指针负责
void fun1(const Test *p)
{
    cout<<"fun1::"<<p->name<<endl;
}
​
//函数2需要一个指针，并且对这个指针负责
void fun2(Test *p)
{
    cout<<"fun2::"<<p->name<<endl;
​
    delete p;
}
​
//函数3需要一个智能指针，但是不对这个指针负责
void fun3(unique_ptr<Test> &up)
{
    cout<<"fun3::"<<up->name<<endl;
}
​
//函数4需要一个智能指针，并对这个指针负责
void fun4(unique_ptr<Test> up)
{
    cout<<"fun3::"<<up->name<<endl;
}
​
​
​
​
int main()
{
​
    unique_ptr<Test> up1(new Test("张飞"));     //在堆区空间实例化一个对象，托管到智能指针
​
    cout<<"函数调用开始"<<endl;
//    fun1(up1.get());              //调用功能1函数，不会对指针负责
//    fun2(up1.release());          //调用功能2函数，会对指针负责
//    fun3(up1);                    //需要使用智能指针的引用，函数内不会对指针负责
    fun4(move(up1));              //使用一个智能指针，函数内对指针负责
​
​
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

5> reset()函数释放对象

函数原型：void reset(pointer __p = pointer())

使用方法： up->reset(); //释放up对象指向的资源

                up->reset(nullptr); //释放up对象指向的资源

                up->reset(new Test("夏侯")); //释放up对原对象的资源，并指向新对象 

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
int main()
{
​
    unique_ptr<Test> up1(new Test("张飞"));     //在堆区空间实例化一个对象，托管到智能指针
​
    cout<<"函数调用开始"<<endl;
​
    //up1.reset();
    up1.reset(new Test("夏侯"));          //释放原来对象的空间，指向新的空间
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

6> swap()函数交换两个unique_ptr的使用权

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
int main()
{
​
    unique_ptr<Test> up1(new Test("张飞"));     //在堆区空间实例化一个对象，托管到智能指针
    unique_ptr<Test> up2(new Test("夏侯"));
​
    cout<<"函数调用开始"<<endl;
​
    up1.swap(up2);           //调用两个指针的使用权
    cout<<"up1->name = "<<up1->name<<endl;     //夏侯
    cout<<"up2->name = "<<up2->name<<endl;     //张飞
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

7> unique_ptr也可以有原始指针的特性，当指向一个继承体系内的基类对象时，也有多态的特性，如同原始指针管理基类对象和派生类对象一样

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
​
    virtual void show()
    {
        cout<<"我是父类"<<endl;
    }
};
​
​
class Demo:public Test
{
public:
    void show() override
    {
        cout<<"我是子类"<<endl;
    }
};
​
​
int main()
{
​
    unique_ptr<Test> up1(new Demo);           //父类指针指向子类对象
​
    cout<<"函数调用开始"<<endl;
​
    up1->show();                 //调用子类中重写的父类的虚函数
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

 8> 智能指针也不是绝对安全的，当程序内有exit（）退出程序时，全局智能指针会释放空间，但是局部智能指针不会

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
​
    virtual void show()
    {
        cout<<"我是父类"<<endl;
    }
};
​
​
​
​
int main()
{
​
    unique_ptr<Test> up1(new Test("张飞"));           //父类指针指向子类对象
​
    cout<<"函数调用开始"<<endl;
​
    exit(0);           //手动退出程序
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}
#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
​
    virtual void show()
    {
        cout<<"我是父类"<<endl;
    }
};
​
​
//全局定义智能指针
unique_ptr<Test> up1(new Test("张飞"));           //父类指针指向子类对象
​
int main()
{
​
​
​
    cout<<"函数调用开始"<<endl;
​
    exit(0);           //手动退出程序
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

 9> unique_ptr提供了支持数组的具体化版本数组版本的unique_ptr，重载了[]运算符，返回的是引用，可以作为左值使用

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
​
int main()
{
​
    //1、普通指针指向数组的使用
//    Test *p = new Test[2];
    Test *p = new Test[2]{string("张飞"), string("夏侯")};
//    p[0].name = "张飞";
//    p[1].name = "夏侯";
//    cout<<"p[0].name = "<<p[0].name<<"     p[1].name = "<<p[1].name<<endl;
//    delete [] p;
​
​
    //2、使用智能指针指向数组
    unique_ptr<Test[]> up(new Test[2]);      //类型后需要加一个空的中括号
    //unique_ptr<Test[]> up(new Test[2]{string("张飞"), string("夏侯")});
    up[0].name = "张飞";
    up[1].name = "夏侯";
    cout<<"up[0].name = "<<up[0].name<<"     up[1].name = "<<up[1].name<<endl;
​
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

四、shared_ptr（共享智能指针）

4.1 概述

         shared_ptr共享他指向的对象，多个共享指针可以指向（关联）相同的对象，在内部采用计数器机制来实现当新的shared_ptr与对象关联时，引用计数器增加1当shared_ptr超出作用域时，引用计数器减1，当引用计数器变为0时，则表示没有任何shared_ptr与对象关联，则释放该对象

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
​
int main()
{
    Test *p = new Test("张飞");          //使用原始指针指向一个对象
​
    shared_ptr<Test> sp1(p);          //构造一个共享智能指针
    cout<<"sp1.use_count = "<<sp1.use_count()<<endl;          //显式当前指针的引用计数器  1
​
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

 4.2 基本使用

        shared_ptr的构造函数也是explicit，但是没有删除拷贝构造函数和拷贝赋值函数

1> 初始化

方法一:
shared_ptr<AA> p0(new AA("西施"));// 分配内存并初始化。
方法二:
shared_ptr<AA> p0 = make_unique<AA>("西施"); // C++11标准,推荐使用，效率更高
方法三:
AA* p = new AA("西施");
shared_ptr<AA> p0(p); // 用已存在的地址初始化。
方法四：
shared_ptr<AA> p0(new AA("西施"));// 分配内存并初始化。
shared_ptr<AA> p1(p0);            //拷贝构造
shared_ptr<AA> p2 = p0;            //拷贝构造
#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
​
int main()
{
    Test *p = new Test("张飞");          //使用原始指针指向一个对象
​
    shared_ptr<Test> sp1(p);          //构造一个共享智能指针
    cout<<"sp1.use_count = "<<sp1.use_count()<<endl;          //显式当前指针的引用计数器  1
​
    shared_ptr<Test> sp2(sp1);        //拷贝构造
    shared_ptr<Test> sp3 = sp2;       //拷贝构造
    cout<<"sp1.use_count = "<<sp1.use_count()<<endl;          //显式当前指针的引用计数器  3
    cout<<"sp2.use_count = "<<sp2.use_count()<<endl;          //显式当前指针的引用计数器  3
    cout<<"sp3.use_count = "<<sp3.use_count()<<endl;          //显式当前指针的引用计数器  3
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

2> 使用方法

1、智能指针重载了*和->操作符，可以像使用原始指针一样使用shared_ptr

2、use_count()函数返回引用计数器的个数

3、unique（）函数，如果use_count()为1，返回true，否则返回false

4、支持普通的拷贝和赋值，左值的shared_ptr的计数器减1，右值的shared_ptr的计数器将加1

left = right;

5、get()函数返回原始指针

6、不要用同一个原始指针区初始化多个shared_ptr

7、不要使用shared_ptr管理不是new分配的空间内存

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
​
int main()
{
    shared_ptr<Test> spa1(new Test("张飞"));          //构造一个共享智能指针
    shared_ptr<Test> spa2(spa1);        //拷贝构造
    shared_ptr<Test> spa3 = spa2;       //拷贝构造
    cout<<"spa1.use_count = "<<spa1.use_count()<<endl;          //张飞的指针个数  3
​
​
    shared_ptr<Test> spb1(new Test("夏侯"));      //构造夏侯的指针
    shared_ptr<Test> spb2(spb1);
    cout<<"spb1.use_count = "<<spb1.use_count()<<endl;             //夏侯的引用计数器  2
​
    spa2 = spb2;         //夏侯的引用计数器将加1，张飞的引用计数器减1
​
    cout<<"spa1.use_count = "<<spa1.use_count()<<endl;          //张飞的指针个数  2
    cout<<"spb1.use_count = "<<spb1.use_count()<<endl;             //夏侯的引用计数器  3
​
​
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

3> 用于函数参数

        跟unique_ptr一样

4> 不支持指针的运算：+、-、++、--

4.3 更多细节

1> 使用nullptr给shared_ptr赋值时，将计数器减1，如果计数器为0，释放对象资源，空的shared_ptr = nullptr;

2> str::move() 可以转移对原始指针的控制权，还可以将unique_ptr转变成shared_ptr

3> reset()改变与资源的关联关系

pp.reset(); //解除与资源的关系，资源的引用计数器减1

pp.reset(new AA("bbb")); //解除与资源的关系，引用计数器减1，关联新资源

4> swap()函数交换两个shared_ptr的控制权

5> shared_ptr也可以像普通指针那样，完成多态的性质，使用方式跟原始指针一致

6> shared_ptr不是绝对安全的，如果程序中调用了exit()退出，全局的shared_ptr会自动释放，局部的shared_ptr无法释放

7> shared_ptr提供的智能指针数组的具体化版本，重载了[]，返回值是一个引用，可以作为左值使用

8> shared_ptr的线程安全性：

        shared_ptr的引用计数器是线程安全的（引用计数器是原子操作）

        多个线程同时读一个shared_ptr对象是线程安全的

        如果多个线程对同一个shared_ptr对象进行读和写，则需要加锁

        多线程读写shared_ptr所指向的同一个对象，不管是相同的shared_ptr对象，还是不同的shared_ptr对象，都要加锁进行保护

9> 实际开发过程中，unique_ptr能解决的问题，尽量不要使用shared_ptr，因为unique_ptr效率更高，所用资源更少

五、智能指针的删除器（了解）

        在默认情况下，智能指针过期的时候，用 delete 原始指针；

        释放管理的资源程序员也可以自定义删除器，改变智能指针释放资源的行为

        删除器可以是全局函数、仿函数以及Lambda表达式，形参为原始指针

#include <iostream>
#include<memory>
​
using namespace std;
class Test
{
public:
    string name;          //名字
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
//全局函数作为删除器
void deletefunc(Test *p)
{
    cout<<"自定义删除器：全局函数实现"<<endl;
    delete  p;
}
​
//定义仿函数作为删除器
class deleteclass
{
public:
    void operator()(Test *p)
    {
        cout<<"仿函数实现删除器"<<endl;
        delete p;
    }
};
​
//定义lambda作为删除器
auto deleteLamb = [](Test *p){
    cout<<"lambda表达式作为删除器"<<endl;
    delete  p;
};
​
​
​
int main()
{
    //shared_ptr<Test> spa1(new Test("张飞"));          //使用默认的删除器
​
    /*shared_ptr<Test> spa1(new Test("张飞"),deletefunc);*/     //使用全局函数作为删除器
//    shared_ptr<Test> spa1(new Test("张飞"),deleteclass());         //使用仿函数作为删除器
//     shared_ptr<Test> spa1(new Test("张飞"),deleteLamb);
​
​
    //独占智能指针的删除器的使用
//    unique_ptr<Test, decltype (deletefunc)*> up1(new Test("夏侯"), deletefunc);   //全局函数作为删除器
    unique_ptr<Test, void (*)(Test *)> up1(new Test("夏侯"), deletefunc);          //使用函数指针推导
//    unique_ptr<Test, deleteclass> up1(new Test("夏侯"), deleteclass());            //仿函数作为删除器
//    unique_ptr<Test, decltype (deleteLamb)> up1(new Test("夏侯"), deleteLamb);      //lambda表达式作为删除器
​
​
​
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

六、weak_ptr(弱智能指针)

6.1 引入目的

        shared_ptr内部维护了一个共享的引用计数器，多个shared_ptr可以指向同一个资源如果出现了循环引用的情况，引用计数器将永远无法归0，资源不会被释放

#include <iostream>
#include<memory>
​
using namespace std;
class Demo;
​
​
class Test
{
public:
    string name;          //名字
    shared_ptr<Demo> sp;   //共享智能指针
​
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
class Demo
{
public:
    string name;          //名字
    shared_ptr<Test> sp;    //共享智能指针
​
    Demo() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Demo(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Demo() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
​
int main()
{
    shared_ptr<Test> sp1(new Test("张飞"));
    shared_ptr<Demo> sp2(new Demo("夏侯"));
​
    //将他们的彼此的共享指针成员指向彼此
    sp1->sp = sp2;
    sp2->sp = sp1;
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}

6.2 weak_ptr是什么

1> weak_ ptr 是为了配合shared_ ptr 而引入的，它指向一个由shared_ ptr 管理的资源但不影响资源的生命周期。也就是说，将-个weak_ ptr 绑定到一个shared_ ptr 不会改变shared_ ptr 的引用计数。

2> 不论是否有weak_ ptr 指向，如果最后一个指向资源的shared_ ptr 被销毁，资源就会被释放。

3> weak_ ptr更像是shared_ ptr 的助手而不是智能指针。

6.3 如何使用weak_ptr

1> weak_ptr没有重载->和*运算符，不能直接访问资源

2> operator=(); 把shared_ptr或weak_ptr赋值给weak_ptr

3> expired(); 判断它指向的资源释放已经过期

4> lock(); 返回shared_ptr,如果资源已经过期，返回空的shared_ptr

5> reset(); 将当前的weak_ptr置空

6> swap(); 交换

7> weak_ptr不控制对象的生命周期，但是，它知道对象是否还活着

        用lock()函数可用把它提升为shared_ptr，如果对象还活着，返回有效的shared_ptr,如果对象已经死了，提升会失败，返回一个空的shared_ptr 提升的行为（lock）是线程安全的

6.4 weak_ptr的使用

1> 单线程可用，多线程不安全版本

#include <iostream>
#include<memory>
​
using namespace std;
class Demo;
​
​
class Test
{
public:
    string name;          //名字
    weak_ptr<Demo> sp;   //弱智能指针
​
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
class Demo
{
public:
    string name;          //名字
    weak_ptr<Test> sp;    //弱智能指针
​
    Demo() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Demo(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Demo() {cout<<name<<"：：析构函数"<<endl;
​
​
            }              //析构函数
};
​
​
​
int main()
{
    shared_ptr<Test> sp1 = make_shared<Test>("张飞");        //创建一个共享智能指针
​
    {
        shared_ptr<Demo> sp2 = make_shared<Demo>("夏侯");      //在局部空间创建一个新对象
​
        //两个类对象的弱指针成员指向对方
        sp1->sp = sp2;
        sp2->sp = sp1;
​
        if(sp1->sp.expired() == true)
        {
            cout<<"语句块内部：sp1->sp已经过期"<<endl;
        }else
        {
            cout<<"语句块内部：sp1->sp.lock()->name = "<<sp1->sp.lock()->name<<endl;
        }
    }
​
    if(sp1->sp.expired() == true)
    {
        cout<<"语句块外部：sp1->sp已经过期"<<endl;
    }else
    {
        cout<<"语句块外部：sp1->sp.lock()->name = "<<sp1->sp.lock()->name<<endl;
    }
​
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}
​

2> 多线程安全版本

#include <iostream>
#include<memory>
​
using namespace std;
class Demo;
​
​
class Test
{
public:
    string name;          //名字
    weak_ptr<Demo> sp;   //弱智能指针
​
    Test() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Test(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Test() {cout<<name<<"：：析构函数"<<endl;}              //析构函数
};
​
​
class Demo
{
public:
    string name;          //名字
    weak_ptr<Test> sp;    //弱智能指针
​
    Demo() {cout<<name<<"：：无参构造"<<endl;}            //无参构造
    Demo(string n):name(n) {cout<<name<<"：：有参构造"<<endl;}  //有参构造
    ~Demo() {cout<<name<<"：：析构函数"<<endl;
​
​
            }              //析构函数
};
​
​
​
int main()
{
    shared_ptr<Test> sp1 = make_shared<Test>("张飞");        //创建一个共享智能指针
​
    {
        shared_ptr<Demo> sp2 = make_shared<Demo>("夏侯");      //在局部空间创建一个新对象
​
        //两个类对象的弱指针成员指向对方
        sp1->sp = sp2;
        sp2->sp = sp1;
​
        //定义一个共享智能指针，接收提升后的weak_ptr
        shared_ptr<Demo> t = sp1->sp.lock();          //原子操作，线程安全
​
        if(t == nullptr)
        {
            cout<<"语句块内部：sp1->sp已经过期"<<endl;
        }else
        {
            cout<<"语句块内部：t->name = "<<t->name<<endl;
        }
    }
​
    //定义一个共享智能指针，接收提升后的weak_ptr
    shared_ptr<Demo> t = sp1->sp.lock();          //原子操作，线程安全
​
    if(t == nullptr)
    {
        cout<<"语句块外部：sp1->sp已经过期"<<endl;
    }else
    {
        cout<<"语句块外部：t->name = "<<t->name<<endl;
    }
​
​
    cout << "********程序到此结束!********" << endl;
    return 0;
}
​

没有百宝袋的哆啦A梦
关注
  • 27
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 11 智能指针使用详解
MusicScore的博客
07-08 427
智能指针是一种类模板，它在指针的基础上添加了额外的功能，可以自动管理指针的生命周期和内存释放。和。智能指针是 C++ 11 提供的重要特性，它们通过提供自动化的资源管理和所有权管理，显著提高了代码的安全性和可维护性。本文介绍了和的基本概念、使用方法以及与传统指针的比较。希望通过本文的介绍，读者能够更好地理解和使用 C++ 11 中的智能指针。如有任何问题或建议，欢迎在评论区留言交流。
C++智能指针基础用法详解
mahuifa的博客
04-21 1156
智能指针是C++中用于管理动态分配资源的强大工具，通过正确使用智能指针，可以显著减少内存泄漏的可能性，并提高代码的安全性和可维护性。
C++ STL 四种智能指针
热门推荐
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
c++11之智能指针
qq_56673429的博客
05-18 2万+
前言：面试的时候被问到智能指针了，答的很糟糕，这几天重新学习了智能指针。下面是我对c++智能指针的理解与总结，希望能帮到大家，同时提升自己。 一，什么是智能指针 在C++中没有垃圾回收机制，必须自己释放分配的内存，否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针（smart pointer）。智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。智能指针的核心实现技术是引用计数，每使用它一次，内部引用计数加1.
C++的智能指针
m0_67623521的博客
07-10 925
目录前言1、unique_ptr2、auto_ptr引入问题3、shared_ptr接口：4、weak_ptr参考文章：C++STL（Standard Template Library）一共提供了四种指针：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr，其中auto_ptr是c++98提供的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。独占的指针，只可以自己使用，它指向的对象只可以他一个人使用，可以使用move将使用权转移。...
【C++基础】智能指针详解
2201_75772333的博客
04-14 1009
自定义删除器的主要目的是在智能指针释放资源时执行特定的清理操作，这些操作可以是任意类型的，不一定是释放动态分配的内存。例如，自定义删除器可以是一个函数对象、Lambda 函数或者函数指针，它可以执行以下任何操作：1）调用delete来释放动态分配的内存。2）调用free函数释放动态分配的内存（用于 C 风格的内存管理）。3）调用关闭文件句柄的函数，如fclose。4）执行其他资源的清理操作，如释放线程、关闭数据库连接等。
C++基础知识 - 智能指针的使用陷阱
骆驼胡杨的博客
03-12 1404
1. 不要把一个原生指针给多个智能指针管理 int *x = new int(10); unique_ptr<int> up1(x); unique_ptr<int> up2(x); //警告! 以上代码使up1 up2指向同一个内存,非常危险 或以下形式： up1.reset(x); up2.reset(x);   2. 记得使用u.release()的返回值 在调用u.release()时是不会释放u所指的内存的，这时返回值就是对这块内存的唯一索引，如果没有使用这个返
C++ 八、智能指针
qq_55753565的博客
01-31 738
智能指针
C++基础篇：09 智能指针与异常处理
snowysc的博客
06-18 692
只能指针与异常处理
c++智能指针的实现
07-02
智能指针是用来实现指针指向的对象的共享的。其实现的基本思想： 每次创建类的新对象时，初始化指针并将引用计数置为1； 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数； 对一个...
RK3588开发板利用udp发送和接收数据
cumtchw
09-01 502
RK3588开发板利用udp发送和接收数据
【C++】深入理解C++模板：从基础到进阶
2403_86785171的博客
09-01 647
模板是C++中用于泛型编程的工具。它允许你编写可以处理任意类型的函数和类，而不必重复编写相似的代码。函数模板和类模板。
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1254
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
c++11新特性-智能指针
SuperYang_的博客
09-01 1129
智能指针RAII(Resource Acquisition Is Initialization)，是一种利用对象的生命周期来管理资源的技术。如果我们采用传统的new/delete来申请和释放资源，如果忘记调用delete，或者在调用delete之前程序抛出异常，都会导致内存泄漏问题，如代码1.1，Func函数中的new p2和Div都可能抛异常，导致后面的delete没有执行从而引发内存泄漏，采用智能指针对资源进行管理，能够杜绝这类问题。代码1.1：因异常引发的内存泄漏throw "除0错误";
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 4150
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++战列舰小游戏Lv. 1.2版本(半成品)
YYDS314的博客
08-31 1904
C++代码
【最新华为OD机试E卷】空栈压数(200分)-多语言题解-(Python/C/JavaScript/Java/Cpp)
春秋招笔试突围
08-31 510
🍭 大家好这里是，一枚热爱算法的程序员✨ 本系列打算持续跟新的三语言AC题解💻 ACM金牌🏅️团队| 多次AK大厂笔试 ｜ 编程一对一辅导。
C++(Qt)-GIS开发-QGraphicsView显示瓦片地图简单示例2
mahuifa的博客
08-30 2502
支持多线程加载显示本地离线瓦片地图(墨卡托投影)； 瓦片切片规则以左上角为原点（谷歌、高德、ArcGis等），不支持百度瓦片规则； 支持显示瓦片网格、编号信息。 支持鼠标滚轮缩放切换地图层级。 支持鼠标拖拽。 采用z/x/y层级瓦片存储格式。 在单文件中实现所有主要功能，简单便于理解。 以北纬85.05，西经-180为坐标原点【绝对像素坐标】。
【C++ 第二十章】模拟实现 shared_ptr（可以拷贝的智能指针）
最新发布
唯有忍受别人不能忍受的，才能享受别人不能享受的
09-04 343
【模拟实现C++库中的智能指针 shared_ptr 】：设计基本的智能指针、添加引用计数、赋值重载、拷贝构造、定制删除器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值