从C语言到C++_36(智能指针RAII)auto_ptr+unique_ptr+shared_ptr+weak_ptr(上)

简介: 从C语言到C++_36(智能指针RAII)auto_ptr+unique_ptr+shared_ptr+weak_ptr

55a8395061124fd49ce1b7a678e4ff39.png 610a98569f5e465b90378c5e48745524.png 610a98569f5e465b90378c5e48745524.png 1. 智能指针的引入_内存泄漏

为什么需要智能指针?上一篇:

1.1 内存泄漏

上面是异常安全导致的内存泄漏问题,开空间没有释放也可能导致内存泄漏。

什么是内存泄漏?:


       内存泄漏指因为疏忽或错误(逻辑错误)造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对该段内存的控制(指针丢了),因而造成了内存的浪费。


       内存泄漏的危害:长期运行的程序出现内存泄漏,影响很大,如操作系统、后台服务等等,出现内存泄漏会导致响应越来越慢,最终卡死。

void MemoryLeaks()
{
  int* p1 = (int*)malloc(sizeof(int)); // 1.内存申请了忘记释放
  int* p2 = new int;
 
  int* p3 = new int[10]; // 2.异常安全问题
 
  Func(); // 这里如果Func函数抛异常n,会导致下一行 delete[] p3未执行,p3没被释放.
  delete[] p3;
}

内存泄漏分类(了解):

C/C++程序中一般我们关心两种方面的内存泄漏:

堆内存泄漏(Heap leak):

       堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存,用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放,那么以后这部分空间将无法再被使用,就会产生Heap Leak。

系统资源泄漏:

       指程序使用系统分配的资源,比方套接字、文件描述符、管道等没有使用对应的函数释放掉,导致系统资源的浪费,严重可导致系统效能减少,系统执行不稳定。

1.2 如何避免内存泄漏

1. 工程前期良好的设计规范,养成良好的编码规范,申请的内存空间记着匹配的去释放。ps:这个理想状态。但是如果碰上异常时,就算注意释放了,还是可能会出问题。需要下一条智能指针来管理才有保证。

2. 采用RAII思想或者智能指针来管理资源。

3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

4. 出问题了使用内存泄漏工具检测,如Valgrind和Sanitizer。ps:不过很多工具都不够靠谱,或者收费昂贵。

总结 :内存泄漏非常常见,解决方案分为两种:


1. 事前预防型。如智能指针等。


2. 事后查错型。如泄漏检测工具。

2. RAII思想

RAII:是英文Resource Acquisition Is Initialization(资源获取即初始化)的首字母,是一种利用对象生命周期来控制程序资源的简单技术。

这些资源可以是内存,文件句柄,网络连接,互斥量等等。

       RAII:在对象构造时获取资源,接着控制对资源的访问使之在对象的生命周期内始终保持有效,最后在对象析构的时候释放资源。借此,我们实际上把管理一份资源的责任托管给了一个对象。


这种做法有两大好处:

① 不需要显式地释放资源。

② 采用这种方式,对象所需的资源在其生命期内始终保持有效。

2.1 RAII解决异常安全问题

利用RAII思想设计delete资源的类:

#include <iostream>
using namespace std;
double Division(int a, int b)
{
  if (b == 0)
  {
    throw "Divide by Zero Error";
  }
  else
  {
    return ((double)a / (double)b);
  }
}
// 利用RAII思想设计delete资源的类
template<class T>
class SmartPtr
{
public:
  SmartPtr(T* ptr)
    :_ptr(ptr)
  {}
  ~SmartPtr()
  {
    cout << "delete: " << _ptr << endl;
    delete _ptr;
  }
protected:
  T* _ptr;
};
 
void Func()
{
  //1、如果p1这里new 抛异常会如何?
  //2、如果p2这里new 抛异常会如何?
  //3、如果div调用这里又会抛异常会如何?
  //int* p1 = new int;
  //int* p2 = new int;
  //cout << Division() << endl;
  //delete p1;
  //delete p2;
  //cout << "释放资源" << endl; 
 
  SmartPtr<int> sp1(new int);
  SmartPtr<int> sp2(new int);
 
  cout << Division(3, 0) << endl;
}
 
int main()
{
  try
  {
    Func();
  }
  catch (const char* errmsg)
  {
    cout << errmsg << endl;
  }
  catch (...)
  {
    cout << "unknown exception" << endl;
  }
  cout << "return 0;" << endl;
  return 0;
}

运行:

把 Division(3, 0) 改为 Division(3, 1):


2.2 智能指针原理

       上述的SmartPtr还不能将其称为智能指针,因为它还不具有指针的行为。指针可以解引用,也可以通过->去访问所指空间中的内容,因此:AutoPtr模板类中还得需要将* 、->重载下,才可让其像指针一样去使用。

// 1、利用RAII思想设计delete资源的类
// 2、重载operator*和opertaor->,具有像指针一样的行为。
// 3、浅拷贝问题(析构两次,下面讲
template<class T>
class SmartPtr
{
public:
  SmartPtr(T* ptr)
    :_ptr(ptr)
  {}
  ~SmartPtr()
  {
    cout << "delete: " << _ptr << endl;
    delete _ptr;
  }
 
  T& operator*()
  {
    return *_ptr;
  }
 
  T* operator->()
  {
    return _ptr;
  }
protected:
  T* _ptr;
};

       所谓RAII,就是将资源的生命周期和对象的生命周期绑定。从构造函数开始,到析构函数结束。智能指针就是使用了RAII技术,并且利用对象生命周期结束时,编译器会自动调用对象的析构函数来释放资源。


       智能指针的智能就在于资源会被自动释放,不需要显式地释放资源。采用智能指针,对象所需的资源在其生命周期内始终保持有效。


总结智能指针的原理:


1、利用RAII思想设计delete资源的类


2、重载operator*和opertaor->,具有像指针一样的行为。


3、拷贝问题(不同的智能指针的解决方式不一样)

3. auto_ptr

C++98就已经提供了这样的一个智能指针:(注意到上面写着deprecated不推荐使用了)


让上面写的SmartPtr使用编译器自动生成的拷贝构造函数:

#include <iostream>
using namespace std;
// 1、利用RAII思想设计delete资源的类
// 2、重载operator*和opertaor->,具有像指针一样的行为。
// 3、浅拷贝问题
template<class T>
class SmartPtr
{
public:
  SmartPtr(T* ptr)
    :_ptr(ptr)
  {}
  ~SmartPtr()
  {
    cout << "delete: " << _ptr << endl;
    delete _ptr;
  }
 
  T& operator*()
  {
    return *_ptr;
  }
 
  T* operator->()
  {
    return _ptr;
  }
protected:
  T* _ptr;
};
 
int main()
{
  SmartPtr<int> sp1(new int);
  SmartPtr<int> sp2(sp1);
 
  return 0;
}



image.png

上面代码在运行时报错。


       智能指针ap2拷贝复制了ap1,此时ap1和ap2都指向同一块动态内存空间。当程序执行结束以后,ap1对象和ap2对象都会销毁,并且会执行各自的析构函数,所以那份动态空间就会被释放两次,所以报错了。怎么解决?:

       显式定义一个拷贝构造函数,不能让两个智能指针指向同一份动态内存空间。(但是这样没有很好的解决问题,auto_ptr就是这样设计的)

//auto_ptr
#include <iostream>
using namespace std;
// 1、利用RAII思想设计delete资源的类
// 2、重载operator*和opertaor->,具有像指针一样的行为。
// 3、浅拷贝问题
template<class T>
class SmartPtr
{
public:
  SmartPtr(T* ptr)
    :_ptr(ptr)
  {}
  ~SmartPtr()
  {
    cout << "delete: " << _ptr << endl;
    delete _ptr;
  }
  SmartPtr(SmartPtr<T>& ptr)
    :_ptr(ptr._ptr)
  {
    ptr._ptr = nullptr;
  }
 
  T& operator*()
  {
    return *_ptr;
  }
 
  T* operator->()
  {
    return _ptr;
  }
protected:
  T* _ptr;
};
 
int main()
{
  SmartPtr<int> sp1(new int);
  SmartPtr<int> sp2(sp1);
 
  return 0;
}

921fcb1b710c4b1685c01a2f784ab7e3.png

增加一个名字叫A的类重复上面操作:

class A
{
public:
  ~A()
  {
    cout << "~A()" << endl;
  }
protected:
  int _a1 = 0;
  int _a2 = 0;
};
 
int main()
{
  SmartPtr<A> sp1(new A);
  SmartPtr<A> sp2(sp1);
 
  return 0;
}

使用一下库里的auto_ptr试一下:

class A
{
public:
  ~A()
  {
    cout << "~A()" << endl;
  }
protected:
  int _a1 = 0;
  int _a2 = 0;
};
 
int main()
{
  //SmartPtr<A> sp1(new A);
  //SmartPtr<A> sp2(sp1);
  auto_ptr<A> sp1(new A);
  auto_ptr<A> sp2(sp1);
 
  return 0;
}

c71e8d8372574b3c8d40141260186a9c.png

和显式定义一个拷贝构造函数的效果一样。auto_ptr到这种情况就崩了:

class A
{
public:
  ~A()
  {
    cout << "~A()" << endl;
  }
//protected:
  int _a1 = 0;
  int _a2 = 0;
};
 
int main()
{
  //SmartPtr<A> sp1(new A);
  //SmartPtr<A> sp2(sp1);
  auto_ptr<A> sp1(new A);
  auto_ptr<A> sp2(sp1);
  sp1->_a1++;
  sp1->_a2++;
 
  return 0;
}


image.png

从C语言到C++_36(智能指针RAII)auto_ptr+unique_ptr+shared_ptr+weak_ptr(中):https://developer.aliyun.com/article/1522496

目录
相关文章
|
26天前
|
C语言
指针进阶(C语言终)
指针进阶(C语言终)
|
11天前
|
存储 安全 编译器
【C++入门 四】学习C++内联函数 | auto关键字 | 基于范围的for循环(C++11) | 指针空值nullptr(C++11)
【C++入门 四】学习C++内联函数 | auto关键字 | 基于范围的for循环(C++11) | 指针空值nullptr(C++11)
|
11天前
|
编译器 C语言
【C语言初阶】指针篇—下
【C语言初阶】指针篇—下
|
11天前
|
存储 C语言
【C语言初阶】指针篇—上
【C语言初阶】指针篇—上
|
26天前
|
C++ 容器
【编程技巧】 C++11智能指针
C++11引入了智能指针以自动管理内存,防止内存泄漏和悬挂指针: - `shared_ptr`:引用计数,多所有权,适用于多个对象共享资源。 - `unique_ptr`:独占所有权,更轻量级,适用于单一对象所有者。 - `weak_ptr`:弱引用,不增加引用计数,解决`shared_ptr`循环引用问题。 ## shared_ptr - 支持引用计数,所有者共同负责资源释放。 - 创建方式:空指针、new操作、拷贝构造/移动构造,以及自定义删除器。 - 提供`operator*`和`operator-&gt;`,以及`reset`、`swap`等方法。 ## unique_ptr
228 1
|
22天前
|
搜索推荐 程序员 C语言
指针赋值与引用传递:C语言的基础知识与实践技巧
指针赋值与引用传递:C语言的基础知识与实践技巧
|
26天前
|
存储 C语言 C++
指针进阶(函数指针)(C语言)
指针进阶(函数指针)(C语言)
|
26天前
|
编译器 C语言
指针进阶(数组指针 )(C语言)
指针进阶(数组指针 )(C语言)
|
27天前
|
C++
C++职工管理系统(类继承、文件、指针操作、中文乱码解决)
C++职工管理系统(类继承、文件、指针操作、中文乱码解决)
22 0
C++职工管理系统(类继承、文件、指针操作、中文乱码解决)
|
11天前
|
安全 编译器 程序员
【C++11】智能指针
【C++11】智能指针
5 0