boost智能指针 与 内存分配

1. boost::scoped_ptr

 这个智能指针只能在本作用域里使用，不能转让

写下原型是最好的：

template<class T>

class scoped_ptr

{

  private:

     T* ptr;

     scoped_ptr(scoped_ptr const & );

     scoped_ptr& operator=(scoped_ptr const&);

     void operator == (scoped_ptr const &) const;

     void operator != (scoped_ptr const& ) const;

 // 构造函数，赋值函数，比较函数 == ，!= 都写成私有的,禁止对智能的拷贝操作

 public:

    explicit scoped_ptr(T* p = 0);

    ~scoped_ptr();

    void reset(T* p =0 );

    T& operator* () const;

    T* operator->() const;

    T* grt() const; // 获取原始指针

    explicit operator bool() const;

   void swap(scoped_ptr& b); // 交换指针

  }；

 template<class T>

  inline bool operator == (scoped_ptr<T> const& p, boost::detaill::sp_nullptr_t);

上面说的有点多，简单说下：

用到的成员函数：get()，swap(), reset()

(2) 工厂函数

啥叫工厂函数，就是制造函数的工厂

c++11有unique_ptr智能指针，但是却是在boost库中封装的工厂函数make_unique

<boost/smart_ptr/make_unique.hpp>

template<class T, class...Args>

inline typename boost::detail::up_if_not_array<T>::type make_unique(Args&& ...args)

{ 

  return std::unique_ptr<T>(new T(...));

}

auto p = boost::make_unique<int>(10);

scoped_ptr 与 unique_ptr区别：

1.unique_ptr支持数组

  unique_ptr<int[]> up(new int[10]);

2.unique_ptr在创建的时候支持 指定删除器

2、boost::shared_ptr

   原型我就不写了，主要写支持哪些成员函数：get(), unique()是否唯一，use_count(),swap(), reset()

   unique()比use_count()要可靠，不要问我为什么，我不知道啊，规定！！！！！！！！！

  与c++11的差不多

应用的模式设计： 桥接模式（一个类里含有指向另一个类的指针），工厂模式（提供创建另一个类对象的接口）

3. boost::weak_ptr

成员函数：use_count(), expired()是否失效指针，lock()获取shared_ptr, reset(), swap(weak_ptr<T>& );

二、内存分配：

 pool 和 object_pool

1.pool

#define BOOST_SYSTEM_NO_DEPRECATED  // 避免链接boost.system库

#include <boost/pool/pool.hpp>

using namespace boost;

int main()

{

  pool<> pl(sizeof(int));  // 默认是32个Int的大小？？？？？？？？？？？？？？？？？？？？？？？？？

  int*p = static_cast<int*> (p1.malloc());  // 把void*类型转化为int*类型

  assert(p1.is_from(p));

  p1.free(p);

  for(int i = 0; i<0; ++i)

  {

    p1.ordered_malloc(10); 连续分配大量的内存

  }

}

因为pool在内存分配失败的时候不会抛出异常，所以实际编写的代码应该检查malloc()函数返回的指针，以防止空指针错误：

int* p = static_cast<int*>(p1.malloc());

if(p != nullptr)

{  ...}

malloc()是从内存池任意分配一个内存块

ordered_malloc()是在分配的同时合并空闲块链表；带参数的表示连续分配n块内存

release_memory() 让内存池释放所有未分配的内存，已分配的不受影响

purge_memory() 则强制释放pool持有所有内存，不管内存块是否使用

注：pool<>只能作为普通数据类型 int double等的内存池，不能用于复杂的类和对象，因为它不调用构造函数

2. object_pool

#include<boost/pool/object_pool.hpp>

using namespace boost;

struct demo_class

{

 public:

 int a, b, c;

 demo_class(int x =1, int y=2, int z=3): a(x), b(y), c(z) {}

 };

 int main()

{

 object_pool<demo_class>  p1;

 auto p = p1.malloc(); // p 的类型应该是demo_class*

 assert(p1.is_from(p));

 p = p1.construct(7,8,9);

assert(p->a == 7);

object_pool<string> pls;

 for(int i = 0; i< 10; i++)

 {

   string* p = pls.construct("hello object_pool"); // 也可以直接通过construct来调用内存分配

   cout << *p<<endl;

}

多参数构造函数：

template<typename P, typename...Args>

inline typename P::element_type* construct(P& p, Args&& ...args)

{

  typename P::element_type* mem = p.malloc();

  assert(mem != 0);

  new (mem) typename P::element_type(std::forward<Args>(args)...);

  return mem;

}

第一个参数是object_pool对象，其后是穿件对象所需参数；要创建的对象类型可以使用object_pool的内部类型定义element_type来获得；

先用malloc()来分配一块内存，再调用new来创建对象。

struct demo_class

{

 demo_class(int, int, int, int)

{

 cout<< "demo_class"<<endl;

}

~demo_class()

{

 cout<<"demo_class<<endl;

}

};

使用construct()创建对象：

object_pool<demo_class> p1;

auto d = construct(p1, 1, 2, 3, 4);