Pool内存池: 只能开辟常规内存，数据类型为int,float,double,string等。

#include <iostream>
#include <boost/pool/pool.hpp>
#include <boost/pool/object_pool.hpp>

using namespace std;
using namespace boost;

int main(int argc, char const *argv[])
{
	boost::pool<> pool(sizeof(int));                     // 定义整数内存池
	int *ptr[10] = { 0 };                                // 定义指针列表

	for (int x = 0; x < 10; x++)
	{
		ptr[x] = static_cast<int *>(pool.malloc());     // 开辟空间并转为指针
		if (ptr[x] == nullptr)
			cout << "分配空间失败" << endl;
	}

	// 分别对内存空间赋值
	for (int x = 0; x < 10; x++)
		*ptr[x] = x;

	// 输出数据
	for (int x = 0; x < 10; x++)
	{
		cout << "内存地址: " << &ptr[x] << " 数值: " << *ptr[x] << endl;
	}

	getchar();
	return 0;
}

objectPool 内存池： 该内存池支持对结构体，对象的分配与初始化。

#include <iostream>
#include <string>
#include <boost/pool/pool.hpp>
#include <boost/pool/object_pool.hpp>

using namespace std;
using namespace boost;

struct MyStruct
{
public:
	int uuid;
	string uname;
	int uage;
	string usex;

	MyStruct(int uuid_,string uname_,int uage_, string usex_)
	{
		uuid = uuid_; uname = uname_; uage = uage_; usex = usex_;
	}
};

// 定义可变参数模板,用来实现接受三个以上的参数
template<typename P, typename ... Args> inline typename P::element_type* construct(P& p, Args&& ... args)
{
	typename P::element_type* mem = p.malloc();
	new(mem) typename P::element_type( std::forward<Args>(args)...);
	return mem;
}

int main(int argc, char const *argv[])
{
	boost::object_pool<MyStruct> object;
	auto ptr = object.malloc();

	// 默认最多只能传递3个参数
	//ptr = object.construct(1001,"lyshark",25);       // 为构造函数传递参数
	//cout << "姓名: " << ptr->uname << endl;

	// 接收四个参数写法
	auto ref = construct(object, 1001, "lyshark", 24, "男");
	cout << "姓名: " << ref->uname << endl;
	
	object.free(ref);
	object.free(ptr);

	getchar();
	return 0;
}

shared_ptr 智能指针:

#include <iostream>
#include <string>
#include <boost/smart_ptr.hpp>

using namespace std;
using namespace boost;


int main(int argc, char const *argv[])
{
	// 基本的定义与赋值
	boost::shared_ptr<int> int_ptr(new int);
	*int_ptr = 1024;
	cout << "指针: " << &int_ptr << " 数值: " << *int_ptr << endl;

	boost::shared_ptr<string> string_ptr(new string);
	*string_ptr = "hello lyshark";
	cout << "指针: " << &string_ptr << " 长度: " << string_ptr->size() << endl;

	// 拷贝构造的使用
	boost::shared_ptr<int> shared_ptr(new int(10)); // 定义指向整数的shared
	cout << "持有者: " << shared_ptr.unique() << endl;

	boost::shared_ptr<int>shared_copy = shared_ptr;   // 实现拷贝
	cout << "引用数: " << shared_ptr.use_count() << endl;
	shared_ptr.reset();   // 关闭shared的使用

	getchar();
	return 0;
}

#include <iostream>
#include <string>
#include <boost/smart_ptr.hpp>

using namespace std;
using namespace boost;

class shared
{
private:
	boost::shared_ptr<int> ptr;
public:
	shared(boost::shared_ptr<int> p_) :ptr(p_){}
	void print()
	{
		cout << "内部 计数: " << ptr.use_count() << " 数值: " << *ptr << endl;
	}
};

// 自动拷贝一个对象,所以引用计数会+1
void print_func(boost::shared_ptr<int> ptr)
{
	cout << "外部 计数: " << ptr.use_count() << " 数值: " << *ptr << endl;
}

int main(int argc, char const *argv[])
{
	boost::shared_ptr<int> ptr(new int(100));   // 定义整数指针
	shared s1(ptr), s2(ptr);                    // 定义两个对象,并初始化

	s1.print();
	s2.print();

	*ptr = 200;
	print_func(ptr);

	s1.print();
	s2.print();

	getchar();
	return 0;
}

make_shared 工厂函数: 工厂函数常用于初始化特定的指针数据的。

#include <iostream>
#include <string>
#include <vector>
#include <boost/smart_ptr.hpp>

using namespace std;
using namespace boost;

int main(int argc, char const *argv[])
{
	// make_shared 工厂函数初始化
	boost::shared_ptr<string> string_ptr = boost::make_shared<string>("hello lyshark");
	cout << "初始化字符串: " << *string_ptr << endl;

	// 应用于标准容器中
	typedef std::vector<boost::shared_ptr<int>> vector_ptr;   // 定义标准容器类型
	vector_ptr vec(10);                                       // 定义拥有十个元素的容器

	int x = 0;
	for (auto pos = vec.begin(); pos != vec.end(); ++pos)
	{
		(*pos) = boost::make_shared<int>(++x);        // 工厂函数初始化
		cout << "输出值: " << *(*pos) << endl;        // 输出数据(两次解引用)
	}

	boost::shared_ptr<int> int_ptr = vec[9];  // 获取最后一个数值
	*int_ptr = 100;                           // 修改最后一个数值
	cout << "修改后: " << *vec[9] << endl;

	// 第二种输出方式(一次解引用完成)
	x = 0;
	for (auto& ptr : vec)
	{
		cout << "输出值: " << *ptr << endl;
	}

	getchar();
	return 0;
}

shared_ptr 桥接模式: 又称为PIMPI模式，仅对外部暴漏最小的细节，内部类实现用一个shared_ptr来保存指针。

#include <iostream>
#include <string>
#include <vector>
#include <boost/smart_ptr.hpp>

using namespace std;
using namespace boost;

class sample
{
private:
	class impl;
	boost::shared_ptr<impl> ptr;

public:
	sample();
	void print();
};

class sample::impl
{
public:
	void print()
	{
		cout << "impl print" << endl;
	}
};


sample::sample() :ptr(new impl){}

void sample::print()
{
	ptr->print();
}



int main(int argc, char const *argv[])
{
	sample lsp;

	lsp.print();


	getchar();
	return 0;
}

markshare 实现工厂模式

#include <iostream>
#include <string>
#include <vector>
#include <boost/smart_ptr.hpp>

using namespace std;
using namespace boost;

// 定义基类 全部为虚函数
class abstract
{
public:
	virtual void f() = 0;
	virtual void g() = 0;
protected:
	virtual ~abstract() = default;
};

// 派生类实现虚函数
class impl :public abstract
{
public:
	impl() = default;
	virtual ~impl() = default;

public:
	virtual void f()
	{
		cout << "class impl f" << endl;
	}

	virtual void g()
	{
		cout << "class impl g" << endl;
	}
};

// 工厂函数返回基类的shared_ptr;
boost::shared_ptr<abstract> create()
{
	return boost::make_shared<impl>();
}

int main(int argc, char const *argv[])
{

	auto ptr = create();
	ptr->f();
	ptr->g();

	abstract *q = ptr.get();
	q->f();
	q->g();

	getchar();
	return 0;
}

weak_ptr : 配合shared_ptr 作用在于协助shared_ptr 像旁观者一样观察资源的使用情况。

#include <iostream>
#include <string>
#include <vector>
#include <boost/smart_ptr.hpp>

using namespace std;
using namespace boost;

int main(int argc, char const *argv[])
{
	boost::shared_ptr<int> ptr(new int(10));
	boost::weak_ptr<int> weak(ptr);

	// 判断weak_ptr观察的对象是否失效
	if (!weak.expired())
	{
		// 获得一个shared_ptr
		boost::shared_ptr<int> new_ptr = weak.lock();
		*new_ptr = 100;
	}

	ptr.reset();
	getchar();
	return 0;
}