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);