[内存管理]智能指针shared_ptr与工厂函数相结合

 

shared_ptr很好地消除了显式的delete调用，如果掌握了它的用法，那么可以说，以后delete将会彻底消失在你的编程词典中。

但这还不够，因为shared_ptr的构造还需要new调用，这导致了代码中的某种不对称性。虽然shared_ptr 对于new表达式的支持相当优秀，但过多的显式new操作符也是个问题，这种情况下就可以用工厂模式来解决。

shared_ptr在头文件<boost/make_shared.hpp>中提供了一个自由工厂函数make_shared<T>()，来消除显式的new调用，它的名字模仿了标准库的make_pair()，声明如下：

template<class T,class...Args>

   shared_ptr<T> make_shared(Args &&& ... args);

make_shared()函数可以接受最多10个参数，然后把它们传递给类型T的构造函数，创建一个shared_ptr<T>的对象并返回。make_shared()函数比直接创建shared_ptr对象的方式快且高效，因为它内部仅分配了一次内存，消除了shared_ptr构造时的开销。

使用示例：

#include <iostream>
#include <boost/smart_ptr.hpp>
#include <boost/make_shared.hpp>
#include <vector>
using  namespace std;
using namespace boost;
int main(){
	//create a shared pointer for string
    shared_ptr<string> sp = 
                       make_shared<string>("make shared");
    cout << *sp << endl;
    //create a shared pointer for vector<int>
    shared_ptr<vector<int> > spv = 
                       make_shared<vector<int> > (10,2);
    assert(spv->size() == 10);
    cout << "No problem." << endl;
}

运行结果：

make shared
No problem.

 

应用于标准容器

有两种方式可以将shared_ptr应用于标准容器（或者容器适配器等其他容器中）。

一种用法是将容器作为shared_ptr的管理对象，如share_ptr<List<T> >，使容器可以被安全地共享，用法与普通shared_ptr没有区别。

另一种方法是将shared_ptr作为容器的元素，如vector<shared_ptr<T> >，因为shared_ptr支持拷贝语义和比较操作，符合标准容器对元素的要求，所以可以实现在容器中安全地容纳元素的指针而不是拷贝。

标准容器不能容纳auto_ptr和scoped_ptr，但可以容纳原始指针，但这就丧失了容器的许多好处，因为标准容器无法自动管理类型为指针的元素，必须编写大量的代码来保证指针最后被正确删除。很麻烦并且很难实现。

存储shared_ptr的容器与存储原始指针的容器功能几乎一样，但shared_ptr为程序员做了指针的管理工作，可以任意使用shared_ptr而不是担心资源泄漏。

使用示例：

//将shared_ptr应用于标准容器的用法 
int main(){
	//一个持有shared_ptr的标准容器类型 
   typedef vector<shared_ptr<int> > vs;
   //声明一个拥有10个元素的容器，元素被初始化为空指针 
   vs v(10);                        
   
   int i = 0;
   for(vs::iterator pos = v.begin(); pos != v.end(); ++pos){
   	//使用工厂函数赋值 
     (*pos) = make_shared<int>(++i);
     //输出值 
     cout << *(*pos) << " ";
   }
   
     cout << endl;
}

运行结果：

1 2 3 4 5 6 7 8 9 10
100

这段代码需要注意的是迭代器和operator[]的用法，因为容器内存储的是shared_ptr，必须对迭代器pos使用一次解引用操作符*以获得shared_ptr，然后再对shared_ptr使用解引用操作符*才能操作真正的值。*(*pos)也可以直接写成**pos，但前者更清楚。vector的operator[]用法与迭代器类似，也需要使用*获取真正的值。

应用于工厂模式

工厂模式是一种创建型设计模式，这个模式包装了new操作符的使用，使对象的创建工作集中在工厂类或者工厂函数中，从而更容易适应变化，make_shared()就是工厂模式的一个好例子。

但由于C++不能高效地返回一个对象，在程序中编写自己的工厂类或者工厂函数时通常需要在堆上使用new动态分配一个对象，然后返回对象的指针，这种做法很不安全，因为用户很容易忘记对指针调用delete，存在资源泄漏的隐患。

使用shared_ptr可以解决这个问题，只需要修改工厂方法的接口，不再返回一个原始指针，而是返回一个被shared_ptr包装的智能指针，这样可以很好地保护系统资源，而且会更好地控制对接口的使用。

使用示例：

//纯虚基类 
class abstract{
public:
virtual void f() = 0;
virtual void g() = 0;
protected:
//析构函数为保护模式，意味着它除了
//自己和子类以外任何对象都无权调用delete来删除它 
virtual ~abstract(){}
};

class impl:public abstract{
public:
   virtual void f()
   {cout << "class impl f" << endl;}
   virtual void g(){
   cout << "class impl g" << endl;
   }
};
//工厂函数返回基类的shared_ptr 
shared_ptr<abstract> create(){
  return shared_ptr<abstract>(new impl);
} 
int main(){
	//工厂函数创建对象 
   shared_ptr<abstract> p = create();
   //可以像普通指针一样使用 
   //不必担心资源泄漏 
   p->f();
   p->g();
   
   //粗鲁的删除对象方式 
   //impl *q = (impl*)(p.get());
   //delete q;
   //最好不要这么做
   //智能指针已经接管 
}

运行结果：

class impl f
class impl g

定制删除器

shared_ptr的另外一个重要概念：删除器

shared_ptr(Y  *p, D d)的第一个参数是要被管理的指针，它的含义与其他构造函数和参数相同。而第二个删除器参数d则告诉shared_ptr在析构时不是使用delete来操作指针p,而要用d来操作，即把delete p 换成d(p)。

在这里删除器d可以是一个函数对象，也可以是一个函数指针，只要它能够像函数那样被调用使得d(p)成立即可。对删除器的要求是它必须支持拷贝，行为必须像delete那样，不能抛出异常。

为了配合删除器的工作，shared_ptr提供一个自由函数get_deleter(shared_ptr<T> const & p)，它能够返回删除器的指针。

我们可以用shared_ptr实现管理任意资源，只要这种资源提供了它自己的释放操作，shared_ptr就能够保证自动释放。

假设我们有一组socket的函数，使用一个socket_t类：

class socket_t{...}

socket_t * open_socket(){
cout << "open_socket" <endl;

return new socket_t;
}

void close_socket(socket_t *s){

cout <<< "close socket" << endl;

//其他操作，释放资源
}

 

那么socket资源对应的释放操作就是函数close_soket()，它符合shared_ptr对删除器的定义

socket_t *s = open_socket();

shared_ptr<socket_t> p(s,close_socket);//传入删除器

在这里删除器close_socket()是一个自由函数，因此只需要把函数名传递给shared_ptr就可以了，在前面也可以加上取地址符$，效果等价。

shared_ptr<socket_t> p(s, & close_socket) ;

这样我们可以利用shared_ptr配合定制的删除器管理了socket资源，当离开作用域时，shared_ptr会自动调用close_socket()函数关闭socket.再也不会有资源泄漏的担心。

再如，对于传统使用的struct FILE的C文件操作，也可以使用shared_ptr配合定制删除器自动管理，像这样：

shared_ptr<FILE> fp(fopen("./txt","r"),fclose);

当离开作用域时，shared_ptr会自动调用fclose()函数关闭文件。

shared_ptr的删除器在处理某些特殊资源时非常有用，它使用用户可以定制、扩展shared_ptr的行为，使shared_ptr不仅能够管理内存资源，而且成为一个“万能”

的管理工具。

 

关于shared_ptr的一些高级议题：

shared_ptr<void>能够存储void*型指针，而void*型指针可以指向任意类型，因此shared_ptr<void>就像一个泛型的指针容器，拥有容纳任意类型的能力。

但将指针存储为void*的同时也丧失了原来的类型信息，为了在需要的时候正常使用，可以用static_pointer_cast<T>等转型函数重新转为原来的指针，但这涉及运行时动态类型转换，它使代码不够安全，建议不要这样使用。

 

删除器的高级用法：

基于shared_ptr<void>和定制删除器，shared_ptr可以有更惊人的用法。由于空指针可以是任意指针类型，因此shared_ptr<void>还可以实现退出作用域时调用任意函数。

使用示例：

void doSomething(void *p){ //一个可执行任何功能的函数
cout << "some operate" << endl;	
}
int main(){ //容纳空指针，定制删除器
    shared_ptr<void> p((void*)0,&doSomething);	//退出作用域时将执行doSomething
}

shared_ptr<void>存储了一个空指针，并指定了删除器是操作void*的一个函数，因此它析构时会自动调用函数doSomething(),从而执行任意我们想做的工作。