智能指针详解

最新推荐文章于 2023-06-29 08:57:41 发布
最新推荐文章于 2023-06-29 08:57:41 发布
阅读量1.0k 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54355176/article/details/125556265
版权

0.指针的危害

  • 指针未初始化
  • 野指针
  • 内存泄漏

1.智能指针分类

智能指针进入C++标准的版本头文件boost头文件说明
auto_ptrC++03memory<boost/auto_ptr.hpp>尽量避免使用
unique_ptrC++11memory<boost/unique_ptr.hpp>管理单个堆内存对象，独享所有权，不允许赋值和拷贝，不能用于管理数组对象
shared_ptrC++11memory<boost/shared_ptr.hpp>引用计数智能指针，共享所有权
weak_ptrC++11memory<boost/weak_ptr.hpp>shared_ptr的观察者，只进行引用而不改变引用计数，用来解决shared_ptr的循环引用问题
scoped_ptr--<boost/scoped_ptr.hpp>作用域智能指针，功能与unique_ptr相似。
  • 本质：

将指针封装为类对象成员，并在析构函数里删除指针指向的内存。

  • 不同：
  1. auto_ptr、unique_ptr、scoped_ptr马上删除。
  2. shared_ptr计数为0删除。
  3. weak_ptr不删除。

智能指针是来解决指针危害的。

1. auto_ptr

  • 作用

    对作用域内的动态分配对象的自动释放

  • 基本类型

#include <iostream>
#include <memory>
using namespace std;
int main(){
    int* pn = new int(10);
    auto_ptr<int> ap(pn);
    cout << *ap << endl;
}
  • 类类型
#include <iostream>
#include <memory>
using namespace std;
class Test{
public:
    Test(){cout << __func__ << endl;}
    ~Test(){cout << __func__ << endl;}
    void Func(){cout << __func__ << endl;}
};
int main(){
    Test* pt = new Test;
    auto_ptr<Test> apt(pt);
    apt->Func();
}

通过valgrind可以看到没有内存泄露，指针可以被正常释放。

  • 缺陷
  1. 两个auto_ptr不能同时拥有同一个对象
#include <memory>
using namespace std;
int main(){
    int* pn = new int(10);
    auto_ptr<int> ap1(pn);
    auto_ptr<int> ap2(pn);
}
  1. auto_ptr不能管理数组指针
#include <memory>
using namespace std;
int main(){
    int*pa=new int[10];
    auto_ptr<int>ap(pa);
}
  1. auto_ptr被拷贝或被赋值后，失去对原指针的管理.这种情况被称为指针所有权传递。

赋值的情况

#include <iostream>
#include <memory>
using namespace std;
int main(){
    int*p = new int(10);
    auto_ptr<int> ap1(p);
    cout<< *ap1 <<endl;
    auto_ptr<int> ap2=ap1;
    cout<< *ap1 <<endl;
}

拷贝的情况

#include <iostream>
#include <memory>
using namespace std;
void Func(auto_ptr<int> ap){
    cout << *ap << endl;
}
int main(){
    int*p = new int(10);
    auto_ptr<int> ap(p);
    cout<< *ap <<endl;
    Func(ap);
    cout<< *ap <<endl;
}

在这里插入图片描述

  1. auto_ptr不能作为容器对象，因为STL容器中的元素经常要支持拷贝，赋值等操作。
#include <iostream>
#include <memory>
#include <vector>
using namespace std;
int main(){
    int*p = new int(10);
    auto_ptr<int> ap(p);
    vector<auto_ptr<int> > vec;
    vec.push_back(ap);
}

2. unique_ptr

  • 作用
    代替auto_ptr，不复制与赋值。

3. scoped_ptr

  • 作用
    与unique_ptr相似，在本作用域中使用，不能复制与赋值。
    在这里插入图片描述

4. shared_ptr

循环引用问题

#include <string>  
#include <iostream>  
#include <boost/shared_ptr.hpp>  
#include <boost/weak_ptr.hpp>  
  
class parent;  
class children;  
  
class parent {  
public:  
    ~parent() { std::cout <<"destroying parent\n"; }  
public:  
    boost::shared_ptr<children> children;  
};  
  
class children {  
public:  
    ~children() { std::cout <<"destroying children\n"; }  
public:  
    boost::shared_ptr<parent> parent;  
};  
void test(){  
    boost::shared_ptr<parent> father(new parent());  
    boost::shared_ptr<children> son(new children);  
    father->children = son;  
    son->parent = father;  
}  
void main(){  
    std::cout<<"begin test...\n";  
    test();  
    std::cout<<"end test.\n";  
}

5. weak_ptr

解决shared_ptr循环引用问题

#include <string>  
#include <iostream>  
#include <boost/shared_ptr.hpp>  
#include <boost/weak_ptr.hpp>  

using namespace boost; 

class parent;  
class children;  
class parent {  
public:  
    ~parent() { std::cout <<"destroying parent\n"; }  
public:  
    shared_ptr<children> children;  
};
class children {  
public:  
    ~children() { std::cout <<"destroying children\n"; }
public:  
    weak_ptr<parent> parent;  
};
void test(){  
    shared_ptr<parent> father(new parent());  
    shared_ptr<children> son(new children);  
    father->children = son;  
    son->parent = father;  
}
void main(){  
    std::cout<<"begin test...\n";  
    test();  
    std::cout<<"end test.\n";  
}

智能指针weak_ptr主要用来协助shared_ptr。不参与引用计数，但是有以下好处：

  1. 打破递归的依赖关系
  2. 使用一个共享的资源但是不要所有权，不添加引用计数
  3. 避免悬空指针。
  • 方法一
boost::shared_ptr<std::string> sp(new std::string("method1");
// 从shared_ptr构建出来
boost::weak_ptr<std::string>wp(sp);
// 再从shared_ptr获取回去
boost::shared_ptr<std::string> p = wp.lock();
  • 方法二
boost::shared_ptr<std::string> sp(new std::string("method1");
// 从shared_ptr构建出来
boost::weak_ptr<std::string>wp(sp);
// 再从shared_ptr获取回去
boost::shared_ptr<std::string> p(wp);

总结

智能指针的特性

智能指针管理同一个对象可拷贝可复制所有权成为容器元素管理数组指针
auto_ptrNGOKOK传递NGNG
unique_ptrNGNGNG独享NGNG
scoped_ptrNGNGNG独享 NGNG
shared_ptrNGOKOK共享OKNG
weak_ptrNGOKOK共享OKNG

虽然通过弱引用指针可以有效的解除循环引用，但这种方式必须在程序员能预见会出现循环引用的情况下才能使用，也可以是说这个仅仅是一种编译期的解决方案。
如果程序在运行过程中出现了循环引用，还是会造成内存泄漏的。
因此，不要认为只要使用了智能指针便能杜绝内存泄漏。

内存管理技术

在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实践

有关智能指针的使用规则

  • Effective C++
    条款17：以独立语句将newed对象置于智能 -指针
  • Effective STL
    条款8：永不建立auto_ptr的容器
  • Exceptional C++
    条款37：auto_ptr
  • More Exceptional C++
    条款21：未管理指针存在的问题，之二：使用 auto_ptr？
    条款29：使用 auto_ptr
    条款30：智能指针成员，之一：auto_ptr 存在的问题
  • Effective Modern C++
    条款18: 使用std::unique_ptr来管理独占所有权的资源
    条款19: 使用std::shared_ptr来管理共享所有权的资源
    条款20: 使用std::weak_ptr替换会造成指针悬挂的类std::shared_ptr指针
    条款21: 比起直接使用new优先使用std::make_unique和std::make_shared

简单实现智能指针

// #include <memory>
#include <iostream>
using namespace std;

// auto_ptr C++03 C++11以后被废弃
// unique_ptr C++11 ~ scope_ptr boost 
// shared_ptr C++11/boost
// weak_ptr C++11/boost

namespace miniSTL{
template<typename T>
class auto_ptr{
public:
    typedef T value_type;
    typedef value_type* pointer;
    typedef value_type& reference;
    typedef const reference const_reference;
private:
    pointer ptr;
public:
    auto_ptr(pointer p):ptr(p){}
    auto_ptr(const auto_ptr& p):ptr(p.ptr){
       const_cast<auto_ptr&>(p).ptr = NULL; // 
    }
    auto_ptr& operator=(const auto_ptr& p){
        if(this == &p) return *this;
        delete ptr;
        ptr = p.ptr;
        const_cast<auto_ptr&>(p).ptr = NULL; // 
    }
    ~auto_ptr(){delete ptr;}
    reference operator*(){return *ptr;} 
    const_reference operator*()const{return *ptr;} 
    pointer operator->(){return ptr;}
    const pointer operator->()const{return ptr;}
};

template<typename T>
class unique_ptr{
public:
    typedef T value_type;
    typedef value_type* pointer;
    typedef value_type& reference;
    typedef const reference const_reference;
private:
    pointer ptr;
public:
    unique_ptr(pointer p):ptr(p){}
    unique_ptr(const unique_ptr& p) = delete;
    unique_ptr& operator=(const unique_ptr& p) = delete;
    ~unique_ptr(){delete ptr;}
    reference operator*(){return *ptr;} 
    const_reference operator*()const{return *ptr;} 
    pointer operator->(){return ptr;}
    const pointer operator->()const{return ptr;}
};


template<class T>
class shared_ptr{
   struct Data{
       T* ptr;
       size_t count;
       Data(T* ptr,size_t count):ptr(ptr),count(count){}
   };
   Data* data;
public:
   // explicit 取消单参构造函数等号初始化，不允许隐式转换到该对象
   explicit shared_ptr(T* ptr):data(new Data(ptr,1)){}
   ~shared_ptr(){
      data->count--;
      if(data->count == 0){
          delete data->ptr;
          delete data;
      }
   }
   shared_ptr(const shared_ptr& ptr){
       data = ptr.data;
       data->count++;
   }

   shared_ptr& operator=(const shared_ptr& ptr){
       if(this == &ptr || data == ptr.data) return *this;
       data->count--;
       if(data->count == 0){
           delete data->ptr;
           delete data;
       }
       data = ptr.data;
       data->count++;
   }
   T& operator*(){
      return *data->ptr;
   }
   T* operator->(){
      return data->ptr;
   }
   bool operator==(const shared_ptr& ptr)const{
       return data->ptr == ptr.data->ptr;
   }
   bool operator!=(const shared_ptr& ptr)const{
       return data->ptr != ptr.data->ptr;
   }
};

};

using namespace miniSTL;

void Func(auto_ptr<int> ap){
    cout << *ap << endl;
}
void Func(unique_ptr<int> up){
    cout << *up << endl;
}
void Func(shared_ptr<int> sp){
    cout << *sp << endl;
}

class IntegerPtr{
    shared_ptr<int> ptr;
public:
    IntegerPtr(int n):ptr(new int(n)){}
    void Print(){
        cout << *ptr << endl;
    }
};

int main(){
    auto_ptr<int> ap(new int(100));
//    Func(ap);
//    auto_ptr<int> ap2 = ap;
    cout << *ap << endl;

    unique_ptr<int> up(new int(100));
    // Func(up);
    // unique_ptr<int> up2 = up;
    cout << *up << endl;
    
    shared_ptr<int> sp(new int(110));
    Func(sp);
    shared_ptr<int> sp2 = sp;
    cout << *sp2 << endl;
    cout << *sp << endl;

    // 空指针解引用
    // int* p = NULL;
    // cout << *p << endl;
    IntegerPtr ptr(200);
    ptr.Print();
    IntegerPtr ptr2 = ptr;
    ptr2.Print();
}
小果曼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
智能指针、Vector、结构体数据的结合使用
程序猿老樊的博客
05-18 586
不管是单独使用，还是结合使用，都是可以的，利用每种的特点灵活使用能够让我们的代码更简洁易读，也更高效。
智能指针（Newbie Note）
最新发布
qq_45445740的博客
11-22 3740
智能指针：在构造的时候分配内存，当离开作用域的时候，自动释放分配的内存，这样的话开发人员就可以从手动动态管理内存的繁杂内容中解放出来。
智能指针（Smart pointers）
weixin_42492218的博客
06-29 1056
std::unique_ptr确保在其生命周期结束时，自动释放所管理的对象，并确保只有一个std::unique_ptr可以拥有对该对象的所有权。std::shared_ptr可以拥有多个std::shared_ptr对象共享对同一对象的所有权，通过引用计数来跟踪对象的使用情况。std::shared_ptr会在最后一个拥有所有权的std::shared_ptr析构时，自动释放所管理的对象。std::shared_ptr是一种共享所有权的智能指针，用于管理共享资源的动态分配内存。
智能指针详细解析(智能指针的使用，原理解析)
qq_61988957的博客
12-01 4512
智能指针的使用跟普通指针类似，可以使用运算符“ * " 和 ” -> "去获得指向的对象，因此，我们就需要在类中重载" * " 和" -> "函数。当程序结束时，此时ptr1和ptr2指针被销毁时，对象ptr1和ptr2会自动调用析构函数去释放所指向的资源，这是智能指针特点。由于我的类中没有定义拷贝构造函数和赋值重载函数，那么我们只能调用类中原生的拷贝构造函数和赋值重载函数。那么就会程序就会出现崩溃的问题，如下:ptr2和ptr1指向的同一块空间。
【C++】智能指针详解
热门推荐
如风逝去
07-31 22万+
参考资料：《C++ Primer中文版 第五版》 我们知道除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。 在C++中，动态内存的管理是用一对运算符完成的：new和delete，new:在动态内存中为对象分配一块空间并返回一个指向该对象的指针，delet...
Ｃ＋＋　ｃｏｎｓｔ用法
LISIMANHAHA的博客
03-26 188
１、const指针位于＊的左边 const 修饰指针指向的内容， 则内容为不可变量但指针可变； const int * p; //指向整形常量的指针，它所指向（的变量）的值不可以更改 int const * p; ２、const指针位于 * 的右边 const 修饰指针， 则指针为不可变量； 可以改变值， 但不能改变地址 int const p; //指向整形的常量指针 ，它不能再指向别的变量(p...
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针详解abc
08-24
C++智能指针详解 标题解释 "C++智能指针详解abc"这一标题表明，本文将详细介绍C++中的智能指针机制，包括其概述、原理、使用方法和结论等方面。 描述解释 "C++智能指针详解abc"这一描述表明，本文将对C++中的智能...
智能指针与弱引用详解
01-05
智能指针是c++ 中的一个概念，因为c++ 本身不具备垃圾回收机制，而且指针也不具备构造函数和析构函数，所以为了实现内存( 动态存储区) 的安全回收，必须对指针进行一层封装，而这个封装就是智能指针，其实说白了，...
C++智能指针详解.pdf
02-27
C++智能指针是C++标准库中用于自动管理动态分配内存的对象，它们的主要目标是解决C++中手动内存管理的挑战，特别是防止内存泄漏。智能指针在生命周期结束时会自动调用删除器（deleter）来释放其所指向的对象，确保...
C++_智能指针详解
04-20
C++ 智能指针详解 std::auto_ptr
智能指针（新版）
06-05
智能指针（新版）
vector 与 智能指针使用注意事项
tianyexing2008的博客
08-22 2815
很明显在调用了 vc.resize(5);后，vc容器元素个数为 5 个，但其中有两个是空的。因为如果n大于当前容器的大小，则在末尾插入尽可能多的元素，使容器的大小达到 n。而插入的新元素，会调用元素的默认构造函数，而智能指针默认是构造一个空的智能指针，所以后两个是 0x0。然后再调用的话就会出现问题。那为什么会出现段错误呢？看以下代码，执行时会有什么问题？
智能指针+拷贝构造+vector容器+多态引起的bug
weixin_45119096的博客
06-27 1262
error C2280: 尝试引用已删除的函数 error C2259: “CMeterProto”: 不能实例化抽象类 error C2512: “T485CommCtrlPara”: 没有合适的默认构造函数可用 一个系统的C++程序bug分析
C++ 使用智能指针shared_ptr/unique_ptr管理数组
Marvek的博客
03-16 9884
关于shared_ptr/unique_ptr的基础，我不在本篇博客中赘述。本篇博客主要关注如何安全地使用智能指针来管数组。 零、要管理的类 Connection是一个管理连接的类。 class Connection{ public: explicit Connection(string name):_name(name){ } string get_name() cons...
C++11 新特性
neninee的博客
11-11 566
1、指针、智能指针(nullptr、shared_ptr、std::weak_ptr) (1)nullptr 作用: C++11 引入了 nullptr 关键字，专门用来区分空指针、0 原有问题:传统 C++ 会把 NULL、0 视为同一种东西，这取决于编译器如何定义 NULL 实现:nullptr 的类型为 nullptr_t，能够隐式的转换为任何指针或成员指针的类型，也能和他们进行相等或者不等的比较。当需要使用 NULL 时候，养成直接使用 nullptr的习惯 NULL的定义 #ifdef __c
C++ 智能指针详解
轻松学C语言
07-02 560
点击蓝字关注我们参考资料：《C++ Primer中文版 第五版》我们知道除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。在C++中，动态内存的管理是用一对运算符完成的：new和delete，new:在动态内存中为对象分配一块空间...
C++智能指针实现
ConstCpp的博客
06-03 976
上一篇介绍内存池的文章中提到一个基于内存池的智能指针。C++没有GC机制，需要程序员自己管理内存，而智能指针则是C++程序员管理内存的利器。智能指针的原理早已广为人知，通俗来讲就是用类来表示指针（用类来表示对象是OPP思想的核心），成员函数里构建一个指向对象的指针，在构造函数，赋值函数，复制构造函数，析构函数等会改变对象个数的地方增加或减少引用计数，当引用计数为0时，释放指针指向的内存，从而避免了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值