boost 库实用工具singleton

singleton

singleton即单件模式,单件模式的类在程序生命周期中只会存在一个且仅有一个实例。

Boost库没有专门的单件库,仅在其它库中有不完善的实现。

singlton_default的单件实现

singlton_default泛型单件类。

1
2
#include <boost/container/detail/singleton.hpp>
using boost::container::container_detail::singleton_default;

类摘要

1
2
3
4
5
6
template <typename T>
struct singlton_default
{
typedef T object_type;
static object_type & instance();
};

singlton_default把模版参数T实现为一个单件类,唯一实例只能通过静态成员函数instance()访问。在main()运行前创建单件。对类型T要求有缺省(无参)构造函数,构造和析构不能抛出异常,因为单件在main()前后构造和析构,发生异常无法捕获。

用法

把想要成为单件的类作为singlton_default的模版参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using boost::container::container_detail::singleton_default;
class TestSingletonDefault
{
public:
TestSingletonDefault()
{
cout<<"ctor"<<endl;
}
~TestSingletonDefault()
{
cout<<"dtor"<<endl;
}
void print()
{
cout<<"singleton"<<endl;
}
};

//singleton
void TestSingleton()
{
typedef singleton_default<TestSingletonDefault> origin;
origin::instance().print();
return ;
}

boost.serialzation的单件实现

序列化库serialzation中单件实现类singleton。

1
2
#include <boost/serialization/singleton.hpp>
using boost::serialization::singleton;

类摘要

1
2
3
4
5
6
7
template <typename T>
class singleton : public boost::noncopyable
{
public:
static const T& get_const_instance();
static T& get_mutable_instance();
};

singleton对模版参数要求有缺省构造函数,构造析构不抛异常。访问单件分为常对象和可变对象,常对象单件总是线程安全的,因为它不会改变内部状态,而可变对象则不是线程安全的,可能发生线程竞争问题。

用法

  • 使用模版参数的方式。
  • 通过继承的方法,把singleton作为单件类的基类,并把单件类作为singleton的模版参数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using boost::serialization::singleton;
//singleton1
void TestSingleton1()
{
typedef singleton<TestSingletonDefault> origin;
origin::get_const_instance().print();
//origin::get_mutable_instance().print();
return ;
}

class TestSingletonClass: public singleton<TestSingletonClass>
{
public:
TestSingletonClass()
{
cout<<"ctor c"<<endl;
}
~TestSingletonClass()
{
cout<<"dtor c"<<endl;
}
void print() const
{
cout<<"singleton"<<endl;
}
};

//singleton2
void TestSingleton2()
{
TestSingletonClass::get_const_instance().print();
//TestSingletonClass::get_mutable_instance().print();

return ;
}

继承方式比模版方式实现单件更加彻底,使单件化的类成为真正的单件类,模版参数方式包装了被单件化的类,对原始类没任何影响。