【C++11】使用C++11解决内存泄露--智能指针

发表于 2年以前 | 总阅读数：432 次

众所周知，C#和java中不需要开发人员自己释放内存，对象引用计数为零后.Net和Java虚拟机会对对象进行自动回收，从而防止内存泄露；但是C++语言中，在堆上分配的内存必须自己去管理，不用的时候要自己释放，如果管理不当就可能会出现内存泄露。

C++11提供了智能指针，使用智能指针后不需要用户自己释放内存空间，一旦使用时对象超出了自己的生命周期，就会进行自动释放，从而有效解决了内存泄露的问题。

在实际编程时，有三种智能指针可供使用，分别是：std::shared_ptr、std::unique_ptr和std::weak_ptr。

1 共享智能指针：std::shared_ptr

std::share_ptr指针的每一个拷贝都指向同一个对象，只有在引用计数为零时内存才会被释放。

指针声明原型为：

template <class T> class shared_ptr;

1.1 std::shared_ptr的用法

std::shared_ptr指针可以有三种方法进行初始化，分别是构造函数、辅助函数以及reset方法进行初始化化，代码如下所示：


int main () {
  std::shared_ptr<int> sp;
  sp.reset (new int);       //reset函数初始化
  *sp=10;
  std::cout << *sp << '\n';

  std::shared_ptr<int> p(new int(1));//构造函数初始化
  std::cout<< *p << std::endl;
  std::shared_ptr<int> foo = std::make_shared<int> (20);
  std::cout<< *foo << std::endl;
  return 0;
}

代码运行结果为：10 1 20

从上面代码可以看出，智能指针使用方法和普通指针使用方法类似，但是智能指针不需要自己管理内存。

1.2 获取原始指针

代码中可以使用get方法获取原始指针，如代码所示：

int main () {
  int* p = new int (10);
  std::shared_ptr<int> a (p);
  if (a.get()==p)
    std::cout << "a and p point to the same location\n";
  std::cout << *a.get() << "\n";
  std::cout << *a << "\n";
  std::cout << *p << "\n";
  return 0;
}

上面的代码试下了将一个普通指针赋值给智能指针，然后判断两个指针是否指向同一个内存地址。运行结果如下：

a and p point to the same location
10
10
10

1.3 指定指针删除器

智能指针在初始化时可以指定删除器，在指针计数为零时，自动调用指定的删除器从而释放指针指向的内存存，删除器可以是一个函数，也可以是一个lambda表达式，如代码所示：

void DeletePoint(int *p){
    delete p;
}
int main(){
   std::shared_ptr<int> p(new int,DeletePoint);//函数方法删除器
   std::shsred_pte<int> p1(new int,[](int *p){delete p;});//表达式
   return 0;
}

上面是一个普通的指针，如果想用智能指针管理动态数组该怎么处理呢？请看下面的代码：

std::shared_ptr<int> p(new int[100],std::default_delete<int []>);

上面的代码使用了std::default_delete,实际上default_delete的底层依然是调用delete来实现的。

1.4 使用std::shared_ptr 的注意事项

std::shared_ptr注意事项如下：

不能使用同一个原始指针初始化多个std::shared_ptr
不要在函数实参中创建智能对象指针，主要是因为不同的编译器可能存在不同的约定，因为调用顺序的不同可能引起内存泄露，因此在使用时应当先创建对象，在传入函数使用。
如果函数要返回this指针时，不要将this当做智能共享指针进行返回。因为如果使用同一个指针（this）构造了两个对象，析构时可能导致重复析构。正常的使用方法应该是继承std::enable_shared_from_this类，然后在返回基类的指针对象。
避免循环引用，循环引用会导致内存泄露。

2 独占的智能指针：std::unique_ptr

独占智能指针使用时有限制，如：不允许其它智能指针共享其内部指针；不允许通过赋值将一个独占指针给另外一个独占指针。如果想要将一个独占指针分配给另外一个独占指针，有两种方法，分别是：

通过函数返回值;
通过std::move方法转义指针对象的所有权.

代码如下所示：

  std::unique_ptr<T> p(new T);
  std::unique_ptr<T> p1 = std::move(p);

在C++ 11中，并没有提供make_unique函数来初始化独占指针，但是在C++14里面提供了类似的功能创建一个unique_ptr指针对象。当然我们也可以自己实现一个，实现方法如下：

template <class T,class ...Args> inline typename std::enable_if<!is_array<T>::value,
std::unique_ptr<T>>::type
make_unique(Args & ... args){
    return std::unique_ptr<T>(new T(std::foeward<Args>(args)...));
}

2.1 unique_ptr使用方法

下面的代码通过reset方法实现独占指针的赋值和使用:

int main () {
  std::unique_ptr<int> up;  
  up.reset (new int);      
  *up=5;
  std::cout << *up << '\n';
  up.reset (new int);      
  *up=10;
  std::cout << *up << '\n';
  up.reset();             
  return 0;
}

3 弱引用指针:std::weak_ptr

弱引用指针是共享指针的一个助手，它主要的功能是监视shared_ptr的生命周期，它也不能对资源进行管理，但是却可以通过shared_ptr对资源进行监控，弱引用指针本身的构造和析构都不会对引用计数进行修改，纯粹是作为一个助手监视shared_ptr管理的资源是否存在。

3.1 std::weak_ptr的基本用法

1) 通过use_count获取当前资源的引用计数，代码如下：

int main(){
  std::shared_ptr<int>p(new int[10]);
  std::weak_ptr<int> wp(p);
  std::cout<<wp.use_count()<<std::endl;
  return 0;
}

上面代码运行结果为：1

2）通过expired方法判断资源是否已经被释放

int main(){
  std::shared_ptr<int>p(new int[10]);
  std::weak_ptr<int> wp(p);
  p.reset();
  if(wp.expired()){
      std::cout<<"监测指针已经被释放"<<std::endl;
  }else{
       std::cout<<"监测指针有效"<<std::endl;
  }
  return 0;
}

上面的代码运行结果为：监测指针已经被释放。

有一点需要大家注意的是，智能共享指针可以使用reset函数进**行释放。**

3）通过lock方法获取监视的shared_ptr资源

std::weak_ptr<int> wp;
void fun(){
     if(wp.expired()){
      std::cout<<"监测指针已经被释放"<<std::endl;
  }else{
       auto p=wp.lock();
       std::cout<<*p<<std::endl;
  }
}

int main(){
  auto p = std::make_shared<int>(100);
  wp = p;
  fun();
  return 0;
}

上面代码输出为：100.

弱指针除了上面描述的功能外，在shared_ptr返回this指针的实现中也是使用了弱指针的方法才得以实现，同理，在解决循环引用的问题时，只需要将两个类中的任意一个类的成员使用弱指针，循环引用导致的内存泄露问题都可以顺利解决。

4 总结

智能指针成为C++进行内存管理工具解决内存泄露问题的一件利器，虽然对我们帮助很大，但是依然要在使用时保持高度的警惕，避免因为使用不当导致更多的问题。在选择使用智能指针时，可以参照如下标准：