1 Boost的安装及配置
1.1 在C/C++中添加include路径
如上图所示，本地include路径为P:\SVN-corbadevelop\ext\include，将路径填入附加包含目录项。
1.2 在链接器中添加lib路径
如上图所示，本地lib路径为P:\SVN-corbadevelop\ext\lib\vc9，将路径填入附加库目录。
2 Boost库知识学习
2.1 时间和日期
Timer类是一个小型的计时器，可以测量时间流逝。提供毫秒级的计时精度和操作函数。
头文件：<boost/timer.hpp> 命名空间：usingnamespace boost;
class timer
{
public:
timer() { _start_time = std::clock(); } //以clock()为起点
void restart() { _start_time = std::clock(); }
double elapsed() const
{ return double(std::clock() -_start_time) / CLOCKS_PER_SEC; }
double elapsed_max() const
{
return(double((std::numeric_limits<std::clock_t>::max)()) -double(_start_time)) / double(CLOCKS_PER_SEC);
}
double elapsed_min() const
{ return double(1)/double(CLOCKS_PER_SEC); }
private:
std::clock_t _start_time;//进程启动时的clock数
};
Timer及时使用了标准库头文件<ctime>里的std::clock()函数，返回自进程启动以来的clock数，每秒clock数由宏CLOCKS_PER_SEC定义。
注意：
1.在timer没有定义析构函数， 这样做是正确和安全的。因为它仅有一个类型为clock_t的成员变量_start_time，故没有必要实现析构函数来特意“释放资源”（也无资源可释放）。
2.timer接口简单，轻巧好用，适用于大部分的程序计时任务。但使用时，我们必须理解elapsed_min()和elapsed_max（）这两个计时精度函数的定义，它们表明了timer的能力。timer不适合高精度的时间测量任务，它的精度依赖于操作系统和编译器，难以做到跨平台。
3.timer也不适合大跨度时间段的测量，可提供的最大时间跨度只有几百个小时，如果需要天，月等的时间跨度，则应使用date_time库。
Progress_timer类是一个计时器，继承自timer，会在析构函数时自动输出时间，实现自动计时。(在函数结束时调用析构)
头文件:<boost/progress.hpp>
Progress_timer类可以在控制台上显示程序的执行进度。
头文件:<boost/progress.hpp>
使用方法：process_display pd(vector::size());
注意：由于给类也使用标准输出(cout)进行输出，与程序输出使用同一输出，如果程序也有输出操作，将会扰乱Progress_timer的输出。
2.2date_time库
使用date_time库，需加宏定义:
#define BOOST_DATA_TIME_NO_LIB或#define BOOST_ALL_NO_LIB
包含头文件：#include<boost/date_time/gregorian/gregorian.hpp>
命名空间:using namespace boost::gregorian
注：如果不希望date的缺省构造出无效日期，可以在头文件前定义宏DATE_TIME_NO_DEFAULT_CONSTRUCTOR，禁止缺省构造函数。
//progress_timer demo测试
bool p_timer_test()
{
vector<int> v(100,1);//100个1
progress_timer t;
progress_display pd(v.size());
vector<int>::iterator pos;
for(pos = v.begin();pos !=v.end();++pos)
{
//cout<<*pos<<endl;//注意！！打印输出时，会干扰process_display输出
++pd;//使用重载++来刷新进度
}
return true;
}
date_time 库使用枚举special_values定义特殊的时间概念位于命名空间：
pos_infin ---表示正无限
neg_infin------表示负无限
not_a_date_time-------无效时间
min_data_time------表示的最小日期1400-01-01
max_data_time--------最大日期9999-12-31
日期的处理：
date是date_time库处理的核心类使用32位整数作为内部存储，可拷贝传值，比较操作
流输入输出
date d1;///一个无效的日期对象
date d2(2010,1,1)数字构造日期
date d3(2000,Jan,1)//英文指定月份
dated4=from_string("1999-12-31")
date d4(from_string(2005/1/1))//支持拷贝构造工程函数通过/或-分割
dated3=from_undelimted_string("20011112")//支持无分割符的纯字符串
day_lock是无级别时钟他是一个工程类调用他的静态成员函数local_day()
universal_day()会返回当天日期对象分别是本地时期和utc日期
date 的5个is_xxx()函数用于检测日期是否是个特殊日期
is_infinity()是否是个无限日期
is_neg_infinity()是否是个负无限日期
is_pos_infinity().......正无限日期
is_not_a_date......无效日期
is_special()......特殊日期
date很方便的转化成字符串提供三个自由函数
to_simple_string(date d)转换成yyy-mmm-dd mmm三字符英语月份
to_iso_string(date d) YYYMMDD
to_iso_extended_string(date d)转换成yyy-mm-dd
与tm结构的转换：
to_tm(date)
date_from_tm:tm 转化为date
日期长度
日期长度是以天为单位的时长，是度量时间长度的一个标量
基本的日期长度类是date_duration 支持全序比较操作(== != > >=)也支持递增和递减
作也支持除法运算但是不能除date_duration类型，乘法取余取模则不支持
date_time 库为date_duration 定义了一个常用的typedef：day 说明了其含义一个天数的计量，为了方便计算时间长度 date_time 库还提供了monthsyears weeks 等另外三个时长类。
2.3boost智能指针
智能指针能够在推出作用域时—不管是正常流程离开还是异常离开，总调用delete来析构堆上动态分配的对象。
头文件：#include <boost/smart_ptr.hpp>
usingnamespace boost;
boost主要提供以下六种智能指针：
shared_ptr<T>
内部维护一个引用计数器来判断此指针是不是需要被释放。是boost中最常用的智能指针了。
scoped_ptr<t>
当这个指针的作用域消失之后自动释放
intrusive_ptr<T>
也维护一个引用计数器，比shared_ptr有更好的性能。但是要求T自己提供这个计数器。
weak_ptr<T>
弱指针，要和shared_ptr 结合使用
shared_array<T>
和shared_ptr相似，但是访问的是数组
scoped_array<T>
和scoped_ptr相似，但是访问的是数组
2.3.1 shared_ptr
shared_ptr包装了new操作符在堆上分配的动态对象，但它实现的是引用计数型的智能指针，可以被自由的靠背和赋值，当没有代码使用（引用计数为0时），它才删除被包装的动态分配对象。Shared_ptr可以应用到标准容器中，弥补了auto_ptr和scoped_ptr的不足。
测试demo：
bool Shared_ptr_test()//智能指针shared_ptr测试
{
shared_ptr<test>T2(new test);
cout<<"nowT2 has "<<T2.use_count()<<" object"<<endl;
shared_ptr<test>T3 = T2;
cout<<"nowT3 has "<<T3.use_count()<<" object"<<endl;
T2.reset();//T2清空
cout<<"nowT3 has "<<T3.use_count()<<" object"<<endl;
cout<<"nowT3 unique is "<<T3.unique()<<endl;//此时T3只有1个对象，unique返回true
T3.reset();//T3对象清空
cout<<"nowT3 has "<<T3.use_count()<<" object"<<endl;
cout<<"nowT3 unique is "<<T3.unique()<<endl;//此时T3只有0个对象，unique返回false
returntrue;
}
注意事项：
1，不要构造临时shared_ptr变量，可能会造成内存泄露：
function (shared_ptr<int>(new int), g( ) ); //有缺陷
可能的过程是先new int，然后调g( )，g( )发生异常，shared_ptr<int>没有创建，int内存泄露。
解决：
shared_ptr<int>p(new int());
f(p, g()); //Boost推荐写法
2，不要把一个原生指针给多个shared_ptr管理：
int* ptr = new int;
shared_ptr<int>p1(ptr);
shared_ptr<int>p2(ptr); //logic error
ptr对象被删除了2次
3，不要把this指针交给shared_ptr管理：
class Test{
public:
void Do(){ m_sp = shared_ptr<Test>(this); }
private:
shared_ptr<Test> m_member_sp;
};
Test* t = new Test;
shared_ptr<Test>local_sp(t);
p->Do();
其中test构造了t，local_sp管理t；而t又交给m_sp管理。因此在释放时删除了两遍。
2.3.2 scoped_ptr
boost::scoped_ptr和auto_ptr类似，使用简单，能保证在离开作用域后能自动释放。
头文件：#include <boost/scoped_ptr.hpp>
scoped_ptr的特点：
1.不能转换所有权
boost::scoped_ptr所管理的对象生命周期仅仅局限于一个区间（该指针所在的"{}"之间），无法传到区间之外，这就意味着boost::scoped_ptr对象是不能作为函数的返回值的（std::auto_ptr可以）。
2.不能共享所有权
这点和std::auto_ptr类似。这个特点一方面使得该指针简单易用。另一方面也造成了功能的薄弱—不能用于stl的容器中。
3.不能用于管理数组对象
由于boost::scoped_ptr是通过delete来删除所管理对象的，而数组对象必须通过deletep[]来删除，因此boost::scoped_ptr是不能管理数组对象的，如果要管理数组对象需要使用boost::scoped_array类。
Demo测试：
class test
{
public:
~test(){cout<<"iam done"<<endl;}
voiddo_something(){cout<<"begin..."<<endl;}
};
bool Smart_ptr_test()//智能指针scoped_ptr测试
{
scoped_ptr<test>T1(new test);
T1->do_something();
returntrue;
}
输出结果：
当T1离开作用域后，自动调用析构函数释放。
2.3.3 intrusive_ptr<T>
是一种侵入式的引用计数型指针。但并不常用，因为shared_ptr可满足绝大部分需求。
2.3.4 weak_ptr<T>
weak_ptr是为shared_ptr而引入的一种智能指针，可理解为shared_ptr的助手，作为观察者，当shared_ptr失效，它也随之失效。
weak_ptr没有共享资源，它的构造不会引起指针计数器的增加，析构也不会引起指针计数器的减少。
boost::weak_ptr必须从一个boost::share_ptr或另一个boost::weak_ptr转换而来，这也说明，进行该对象的内存管理的是那个强引用的boost::share_ptr。
boost::weak_ptr只是提供了对管理对象的一个访问手段。
boost::weak_ptr除了对所管理对象的基本访问功能（通过get()函数）外，还有两个常用的功能函数：
1. expired() 用于检测所管理的对象是否已经释放；
2. lock() 用于获取所管理的对象的强引用指针。
注：weak的重要作用：
1，配合share_ptr解决不能管理循环引用的问题
class children
{
public:
~children() { std::cout<<"destroying children\n"; }
public:
boost::weak_ptr<parent>parent;
};
由于weak_ptr不更改引用计数，类似普通指针，只要把循环引用的一方使用weak_ptr，即可解除循环引用。
2.3.5 shared_array<T>
shared_array类似shared_ptr，他包装了new[]操作符在堆上分配动态数组，直到没有任何饮用后才释放内存。
shared_array与shared_ptr的区别如下：
1：构造函数接受的指针p必须是new[]的结果，而不能是new表达式。
2：提供operator[]操作符重载，可以像普通数组一样用下标访问元素。
3：没有*、->操作符重载，因为shared_array持有的不是一个普通指针。
4：析构函数使用delete[]释放资源，而不是delete。
2.3.6 scoped_array<T>
scoped_array与scoped_ptr区别基本不大，主要特点如下：
1，构造函数接受的指针p必须是new[]的结果，而不是new表达式的结果；
2，没有*、->操作符重载，scoped_array持有的不是一个普通指针；
3，析构函数使用delete[]，而不是delete；
4，提供operator[]重载，可以像普通数组一样使用下标访问元素；
5，没有begin(),end()等类似容器迭代器操作函数。
该方法不推荐，因为scoped_array<T>功能有限，可以有vector等代替，不支持容器操作。
2.4 Pool库
Boost库的pool提供了一个内存池分配器，用于管理在一个独立的、大的分配空间里的动态内存分配。Boost库的pool主要适用于快速分配同样大小的内存块，尤其是反复分配和释放同样大小的内存块的情况。使用pool内存池主要有以下两个优点：
1. 能够有效地管理许多小型对象的分配和释放工作，避免了自己去管理内存而产生的内存碎片和效率低下问题。
2. pool库会在内部对内存自动进行管理，避免了程序员一不小心而造成的内存泄漏问题。
pool库主要提供了四种内存池接口，分别是pool、object_pool、singleton_pool和pool_allocator（fast_pool_allocator）。
头文件：<boost/pool/pool.hpp>
2.4.1 Pool
Pool 可以像malloc()一样分配内存，退出时，除非需要，否则不必调用free()；
is_from(p);检查是否已经分配内存
release_memory()释放空闲的内存，不影响已分配的内存。
purge_memory()强制释放pool内所有内存
2.4.2 object_pool
用于类实例的内存池，退出时会调用析构函数。
头文件：头文件：<boost/pool/object_pool.hpp>
Class object_pool:protectedpool;//由于是保护继承，因此object_pool的对象不能访问pool。
Demo测试：
#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> pl; //对象内存池
demo_class *p = pl.malloc(); //分配一个原始内存块
assert(pl.is_from(p)); //p指向的内存未经过初始化
assert(p->a!=1 || p->b != 2 || p->c !=3);
p = pl.construct(7, 8, 9); //构造一个对象,可以传递参数
assert(p->a == 7);
object_pool<string> pls; //定义一个分配string对象的内存池
for (int i = 0; i < 10 ; ++i) //连续分配大量string对象
{
string *ps = pls.construct("helloobject_pool");
cout << *ps << endl;
}
} //所有创建的对象在这里都被正确析构、释放内存
2.4.3 singleton_pool
singleton_pool的接口与pool完全一致，但成员函数均是静态的，因此不需要声明singleton_pool的实例 ，直接用域操作符::来调用静态成员函数。因为singleton_pool是单件，所以它的生命周期与整个程序同样长，除非手动调用release_memory()或purge_memory()，否则singleton_pool不会自动释放所占用的内存。除了这两点，singleton_pool的用法与pool完全相同。
singleton_pool<pool_tag, sizeof(int)>// 第一个Tag仅仅是用于标记不同的单件，可以是空类，甚至是声明。第二个参数RequestedSize等同于pool构造函数中的整数requested_ size，指示pool分配内存块的大小。
singleton_pool在使用时最好使用typedef来简化名称，否则会使得类型名过于冗长而难以使用。
2.4.4 pool_allocator
头文件<boost/pool/pool_alloc.hpp>
vector<int,pool_allocator<int>> v;
v.push_back(10);
cout<<v.size()<<endl;
2.5 thread
Thread库是高度可移植，支持广泛的windows和POSIX线程，不需要修改就能在操作系统上运行。
头文件：<boost/thread.hpp>
Thread需要date_time支持，因此需要加上
#defineBOOST_DATE_TIME_SOURCE
#defineBOOST_THREAD_NO_LIB
或者
#defineBOOST_ALL_NO_LIB
注：阻止link错误的方法：extern “C”void tss_cleanup_implemented(void){},该定义实现了自动tss（线程本地存储）清理功能。
vs2008线程库的配置
在附加依赖项中添加boost_tread-vc90-mt-gd-1_47.lib库，并将boost_tread-vc90-mt-gd-1_47.dll放入工程文件夹debug下。
2.5.1互斥量
Boost线程库支持两大类互斥体，包括简单互斥体（simple mutex)和递归互斥体（recursive mutex)。如果同一个线程对互斥体上了两次锁，就会发生死锁（deadlock），也就是说所有的等待解锁的线程将一直等下去。有了递归互斥体，单个 线程就可以对互斥体多次上锁，当然也必须解锁同样次数来保证其他线程可以对这个互斥体上锁。
boost::mutex：独占式互斥量，是最简单最常用的一种互斥量类型
boost::try_mutex：它是mutex的同义词，为了兼容以前的版本而提供
boost::timed_mutex：他也是独占式的互斥量，但提供超时锁定功能
boost::recursive_mutex：递归式互斥量，可以多次锁定，相应的也要多次解锁
boost::recursive_try_mutex：它是recrusive_mutex的同义词，为兼容以前版本提供
boost::recursive_timed_mutex： 递归式互斥量，基本功能与recrusive_mutex相同，但提供超时锁定功能
boost::shared_mutex：读写锁
（1）scopde_lock
测试demo：
boost::mutex io_mutex;
struct count
{
count(int id) : id(id) { }
void operator()()//重载()，当对象使用()时，会执行程序功能
{
for (int i = 0;i < 5; ++i)
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << id << ": "<< i<< std::endl;
}
}
int id;
};
int main(int argc,char* argv[])
{
boost::thread thrd1(count(1));
boost::thread thrd2(count(2));
thrd1.join();
thrd2.join();
return 0;
}
结果：
可以看到，在thrd1执行时，thrd2在等待。等到thrd1执行完后，开始thrd2。
（2）Bind
测试demo：
boost::mutex io_mutex;
void count(int id)
{
for (int i = 0;i < 10; ++i)
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << id << ": " <<i<< std::endl;
}
}
int main(int argc,char* argv[])
{
boost::thread thrd1(boost::bind(&count,1));
boost::thread thrd2(boost::bind(&count,2));
thrd1.join();
thrd2.join();
return 0;
}
（3）thread_specific_ptr
Boost线程库提供了智能指针boost::thread_specific_ptr来访问本地存储线程。每一个线程第一次使用这个智能指针的实 例时，它的初值是NULL，所以必须要先检查这个它的只是否为空，并且为它赋值。Boost线程库保证本地存储线程中保存的数据会在线程结束后被清除。
测试demo：
using namespace boost;
using namespace std;
mutex io_mu;
thread_specific_ptr<int> ptr;
struct counts1
{
counts1(int id):id(id){}
void operator()()
{
if(ptr.get() == 0)
ptr.reset(new int(0));
for (int i = 0;i<5;i++)
{
(*ptr)++;
mutex::scoped_lock lock_s(io_mu);
cout<<id<<":"<<*ptr<<endl;
}
}
int id;
};
void mutex_test()
{
thread t1(counts1(1));
thread t2(counts1(2));
t1.join();
t2.join();
}
结果：
3 函数与回调
3.1 bind
头文件：#include<boost/bind.hpp>
bind最多有十个参数，第一个可调用的对象，之后可以接最多九个参数，参数量必须与可调用对象的参数相同。点位符为_1 _2等等，位置可以随意放。点位符可以出现，也可以不出现。
成员函数：第一个参数为成员函数地址，第二个参数为对象。
成员变量：第一个参数为成员变量的地址，第二个参数为对象。
注：绑定成员函数时：
1，因为成员函数的指针不能直接调用operator()，因此，它必须被绑定到一个对象或者指针。然后才能得到this指针进而调用成员函数。在bind时，需要用一个占位符的位置，提供一个类的实例、引用或者指针，通过对象作为第一个参数来调用成员函数。
2，必须在成员函数前加取地址符&，表明这是一个函数指针。绑定变量时也一样。
3.2 function
头文件：#include<boost/function.hpp>
测试demo：bind与function合用
using namespace boost;
using namespace std;
struct demo
{
int print(int a){return a;}
int operator()(int a){return a;}
};
int f(int a)
{return a;}
void function_bind()
{
function<int(int)> fuc;
fuc = f;
cout<<fuc(3)<<endl;
demo dm;
function<int(int)> fuc2;
fuc2 = bind(&demo::print,&dm,_1);//成员函数前必须加去地址符&，dm是提供的类的对象的引用。
cout<<fuc2(34)<<endl;
function<int(demo&,int)> fuc3;//在定义时，形参定义demo类的指针，在绑定时，可用占位符代替
fuc3 = bind(&demo::print,_1,_2);//也可以预留占位符_1,在调用fun3时，将类的对象、实例或引用填入
cout<<fuc3(dm,56)<<endl;
}
结果：
3.3 signals2
头文件：#include<boost/signals2.hpp>
connect() disconnect()连接或断开信号与插槽。
empty() num_slots()返回是否为空，返回插槽数量。
disconnect_all_slots()断开所有信号与插槽的连接。
combiner() set_combiner()用于获取和设置合并器对象
1 Boost的安装及配置
1.1 在C/C++中添加include路径
如上图所示，本地include路径为P:\SVN-corbadevelop\ext\include，将路径填入附加包含目录项。
1.2 在链接器中添加lib路径
如上图所示，本地lib路径为P:\SVN-corbadevelop\ext\lib\vc9，将路径填入附加库目录。
2 Boost库知识学习
2.1 时间和日期
Timer类是一个小型的计时器，可以测量时间流逝。提供毫秒级的计时精度和操作函数。
头文件：<boost/timer.hpp> 命名空间：usingnamespace boost;
class timer
{
public:
timer() { _start_time = std::clock(); } //以clock()为起点
void restart() { _start_time = std::clock(); }
double elapsed() const
{ return double(std::clock() -_start_time) / CLOCKS_PER_SEC; }
double elapsed_max() const
{
return(double((std::numeric_limits<std::clock_t>::max)()) -double(_start_time)) / double(CLOCKS_PER_SEC);
}
double elapsed_min() const
{ return double(1)/double(CLOCKS_PER_SEC); }
private:
std::clock_t _start_time;//进程启动时的clock数
};
Timer及时使用了标准库头文件<ctime>里的std::clock()函数，返回自进程启动以来的clock数，每秒clock数由宏CLOCKS_PER_SEC定义。
注意：
1.在timer没有定义析构函数， 这样做是正确和安全的。因为它仅有一个类型为clock_t的成员变量_start_time，故没有必要实现析构函数来特意“释放资源”（也无资源可释放）。
2.timer接口简单，轻巧好用，适用于大部分的程序计时任务。但使用时，我们必须理解elapsed_min()和elapsed_max（）这两个计时精度函数的定义，它们表明了timer的能力。timer不适合高精度的时间测量任务，它的精度依赖于操作系统和编译器，难以做到跨平台。
3.timer也不适合大跨度时间段的测量，可提供的最大时间跨度只有几百个小时，如果需要天，月等的时间跨度，则应使用date_time库。
Progress_timer类是一个计时器，继承自timer，会在析构函数时自动输出时间，实现自动计时。(在函数结束时调用析构)
头文件:<boost/progress.hpp>
Progress_timer类可以在控制台上显示程序的执行进度。
头文件:<boost/progress.hpp>
使用方法：process_display pd(vector::size());
注意：由于给类也使用标准输出(cout)进行输出，与程序输出使用同一输出，如果程序也有输出操作，将会扰乱Progress_timer的输出。
2.2date_time库
使用date_time库，需加宏定义:
#define BOOST_DATA_TIME_NO_LIB或#define BOOST_ALL_NO_LIB
包含头文件：#include<boost/date_time/gregorian/gregorian.hpp>
命名空间:using namespace boost::gregorian
注：如果不希望date的缺省构造出无效日期，可以在头文件前定义宏DATE_TIME_NO_DEFAULT_CONSTRUCTOR，禁止缺省构造函数。
//progress_timer demo测试
bool p_timer_test()
{
vector<int> v(100,1);//100个1
progress_timer t;
progress_display pd(v.size());
vector<int>::iterator pos;
for(pos = v.begin();pos !=v.end();++pos)
{
//cout<<*pos<<endl;//注意！！打印输出时，会干扰process_display输出
++pd;//使用重载++来刷新进度
}
return true;
}
date_time 库使用枚举special_values定义特殊的时间概念位于命名空间：
pos_infin ---表示正无限
neg_infin------表示负无限
not_a_date_time-------无效时间
min_data_time------表示的最小日期1400-01-01
max_data_time--------最大日期9999-12-31
日期的处理：
date是date_time库处理的核心类使用32位整数作为内部存储，可拷贝传值，比较操作
流输入输出
date d1;///一个无效的日期对象
date d2(2010,1,1)数字构造日期
date d3(2000,Jan,1)//英文指定月份
dated4=from_string("1999-12-31")
date d4(from_string(2005/1/1))//支持拷贝构造工程函数通过/或-分割
dated3=from_undelimted_string("20011112")//支持无分割符的纯字符串
day_lock是无级别时钟他是一个工程类调用他的静态成员函数local_day()
universal_day()会返回当天日期对象分别是本地时期和utc日期
date 的5个is_xxx()函数用于检测日期是否是个特殊日期
is_infinity()是否是个无限日期
is_neg_infinity()是否是个负无限日期
is_pos_infinity().......正无限日期
is_not_a_date......无效日期
is_special()......特殊日期
date很方便的转化成字符串提供三个自由函数
to_simple_string(date d)转换成yyy-mmm-dd mmm三字符英语月份
to_iso_string(date d) YYYMMDD
to_iso_extended_string(date d)转换成yyy-mm-dd
与tm结构的转换：
to_tm(date)
date_from_tm:tm 转化为date
日期长度
日期长度是以天为单位的时长，是度量时间长度的一个标量
基本的日期长度类是date_duration 支持全序比较操作(== != > >=)也支持递增和递减
作也支持除法运算但是不能除date_duration类型，乘法取余取模则不支持
date_time 库为date_duration 定义了一个常用的typedef：day 说明了其含义一个天数的计量，为了方便计算时间长度 date_time 库还提供了monthsyears weeks 等另外三个时长类。
2.3boost智能指针
智能指针能够在推出作用域时—不管是正常流程离开还是异常离开，总调用delete来析构堆上动态分配的对象。
头文件：#include <boost/smart_ptr.hpp>
usingnamespace boost;
boost主要提供以下六种智能指针：
shared_ptr<T>
内部维护一个引用计数器来判断此指针是不是需要被释放。是boost中最常用的智能指针了。
scoped_ptr<t>
当这个指针的作用域消失之后自动释放
intrusive_ptr<T>
也维护一个引用计数器，比shared_ptr有更好的性能。但是要求T自己提供这个计数器。
weak_ptr<T>
弱指针，要和shared_ptr 结合使用
shared_array<T>
和shared_ptr相似，但是访问的是数组
scoped_array<T>
和scoped_ptr相似，但是访问的是数组
2.3.1 shared_ptr
shared_ptr包装了new操作符在堆上分配的动态对象，但它实现的是引用计数型的智能指针，可以被自由的靠背和赋值，当没有代码使用（引用计数为0时），它才删除被包装的动态分配对象。Shared_ptr可以应用到标准容器中，弥补了auto_ptr和scoped_ptr的不足。
测试demo：
bool Shared_ptr_test()//智能指针shared_ptr测试
{
shared_ptr<test>T2(new test);
cout<<"nowT2 has "<<T2.use_count()<<" object"<<endl;
shared_ptr<test>T3 = T2;
cout<<"nowT3 has "<<T3.use_count()<<" object"<<endl;
T2.reset();//T2清空
cout<<"nowT3 has "<<T3.use_count()<<" object"<<endl;
cout<<"nowT3 unique is "<<T3.unique()<<endl;//此时T3只有1个对象，unique返回true
T3.reset();//T3对象清空
cout<<"nowT3 has "<<T3.use_count()<<" object"<<endl;
cout<<"nowT3 unique is "<<T3.unique()<<endl;//此时T3只有0个对象，unique返回false
returntrue;
}
注意事项：
1，不要构造临时shared_ptr变量，可能会造成内存泄露：
function (shared_ptr<int>(new int), g( ) ); //有缺陷
可能的过程是先new int，然后调g( )，g( )发生异常，shared_ptr<int>没有创建，int内存泄露。
解决：
shared_ptr<int>p(new int());
f(p, g()); //Boost推荐写法
2，不要把一个原生指针给多个shared_ptr管理：
int* ptr = new int;
shared_ptr<int>p1(ptr);
shared_ptr<int>p2(ptr); //logic error
ptr对象被删除了2次
3，不要把this指针交给shared_ptr管理：
class Test{
public:
void Do(){ m_sp = shared_ptr<Test>(this); }
private:
shared_ptr<Test> m_member_sp;
};
Test* t = new Test;
shared_ptr<Test>local_sp(t);
p->Do();
其中test构造了t，local_sp管理t；而t又交给m_sp管理。因此在释放时删除了两遍。
2.3.2 scoped_ptr
boost::scoped_ptr和auto_ptr类似，使用简单，能保证在离开作用域后能自动释放。
头文件：#include <boost/scoped_ptr.hpp>
scoped_ptr的特点：
1.不能转换所有权
boost::scoped_ptr所管理的对象生命周期仅仅局限于一个区间（该指针所在的"{}"之间），无法传到区间之外，这就意味着boost::scoped_ptr对象是不能作为函数的返回值的（std::auto_ptr可以）。
2.不能共享所有权
这点和std::auto_ptr类似。这个特点一方面使得该指针简单易用。另一方面也造成了功能的薄弱—不能用于stl的容器中。
3.不能用于管理数组对象
由于boost::scoped_ptr是通过delete来删除所管理对象的，而数组对象必须通过deletep[]来删除，因此boost::scoped_ptr是不能管理数组对象的，如果要管理数组对象需要使用boost::scoped_array类。
Demo测试：
class test
{
public:
~test(){cout<<"iam done"<<endl;}
voiddo_something(){cout<<"begin..."<<endl;}
};
bool Smart_ptr_test()//智能指针scoped_ptr测试
{
scoped_ptr<test>T1(new test);
T1->do_something();
returntrue;
}
输出结果：
当T1离开作用域后，自动调用析构函数释放。
2.3.3 intrusive_ptr<T>
是一种侵入式的引用计数型指针。但并不常用，因为shared_ptr可满足绝大部分需求。
2.3.4 weak_ptr<T>
weak_ptr是为shared_ptr而引入的一种智能指针，可理解为shared_ptr的助手，作为观察者，当shared_ptr失效，它也随之失效。
weak_ptr没有共享资源，它的构造不会引起指针计数器的增加，析构也不会引起指针计数器的减少。
boost::weak_ptr必须从一个boost::share_ptr或另一个boost::weak_ptr转换而来，这也说明，进行该对象的内存管理的是那个强引用的boost::share_ptr。
boost::weak_ptr只是提供了对管理对象的一个访问手段。
boost::weak_ptr除了对所管理对象的基本访问功能（通过get()函数）外，还有两个常用的功能函数：
1. expired() 用于检测所管理的对象是否已经释放；
2. lock() 用于获取所管理的对象的强引用指针。
注：weak的重要作用：
1，配合share_ptr解决不能管理循环引用的问题
class children
{
public:
~children() { std::cout<<"destroying children\n"; }
public:
boost::weak_ptr<parent>parent;
};
由于weak_ptr不更改引用计数，类似普通指针，只要把循环引用的一方使用weak_ptr，即可解除循环引用。
2.3.5 shared_array<T>
shared_array类似shared_ptr，他包装了new[]操作符在堆上分配动态数组，直到没有任何饮用后才释放内存。
shared_array与shared_ptr的区别如下：
1：构造函数接受的指针p必须是new[]的结果，而不能是new表达式。
2：提供operator[]操作符重载，可以像普通数组一样用下标访问元素。
3：没有*、->操作符重载，因为shared_array持有的不是一个普通指针。
4：析构函数使用delete[]释放资源，而不是delete。
2.3.6 scoped_array<T>
scoped_array与scoped_ptr区别基本不大，主要特点如下：
1，构造函数接受的指针p必须是new[]的结果，而不是new表达式的结果；
2，没有*、->操作符重载，scoped_array持有的不是一个普通指针；
3，析构函数使用delete[]，而不是delete；
4，提供operator[]重载，可以像普通数组一样使用下标访问元素；
5，没有begin(),end()等类似容器迭代器操作函数。
该方法不推荐，因为scoped_array<T>功能有限，可以有vector等代替，不支持容器操作。
2.4 Pool库
Boost库的pool提供了一个内存池分配器，用于管理在一个独立的、大的分配空间里的动态内存分配。Boost库的pool主要适用于快速分配同样大小的内存块，尤其是反复分配和释放同样大小的内存块的情况。使用pool内存池主要有以下两个优点：
1. 能够有效地管理许多小型对象的分配和释放工作，避免了自己去管理内存而产生的内存碎片和效率低下问题。
2. pool库会在内部对内存自动进行管理，避免了程序员一不小心而造成的内存泄漏问题。
pool库主要提供了四种内存池接口，分别是pool、object_pool、singleton_pool和pool_allocator（fast_pool_allocator）。
头文件：<boost/pool/pool.hpp>
2.4.1 Pool
Pool 可以像malloc()一样分配内存，退出时，除非需要，否则不必调用free()；
is_from(p);检查是否已经分配内存
release_memory()释放空闲的内存，不影响已分配的内存。
purge_memory()强制释放pool内所有内存
2.4.2 object_pool
用于类实例的内存池，退出时会调用析构函数。
头文件：头文件：<boost/pool/object_pool.hpp>
Class object_pool:protectedpool;//由于是保护继承，因此object_pool的对象不能访问pool。
Demo测试：
#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> pl; //对象内存池
demo_class *p = pl.malloc(); //分配一个原始内存块
assert(pl.is_from(p)); //p指向的内存未经过初始化
assert(p->a!=1 || p->b != 2 || p->c !=3);
p = pl.construct(7, 8, 9); //构造一个对象,可以传递参数
assert(p->a == 7);
object_pool<string> pls; //定义一个分配string对象的内存池
for (int i = 0; i < 10 ; ++i) //连续分配大量string对象
{
string *ps = pls.construct("helloobject_pool");
cout << *ps << endl;
}
} //所有创建的对象在这里都被正确析构、释放内存
2.4.3 singleton_pool
singleton_pool的接口与pool完全一致，但成员函数均是静态的，因此不需要声明singleton_pool的实例 ，直接用域操作符::来调用静态成员函数。因为singleton_pool是单件，所以它的生命周期与整个程序同样长，除非手动调用release_memory()或purge_memory()，否则singleton_pool不会自动释放所占用的内存。除了这两点，singleton_pool的用法与pool完全相同。
singleton_pool<pool_tag, sizeof(int)>// 第一个Tag仅仅是用于标记不同的单件，可以是空类，甚至是声明。第二个参数RequestedSize等同于pool构造函数中的整数requested_ size，指示pool分配内存块的大小。
singleton_pool在使用时最好使用typedef来简化名称，否则会使得类型名过于冗长而难以使用。
2.4.4 pool_allocator
头文件<boost/pool/pool_alloc.hpp>
vector<int,pool_allocator<int>> v;
v.push_back(10);
cout<<v.size()<<endl;
2.5 thread
Thread库是高度可移植，支持广泛的windows和POSIX线程，不需要修改就能在操作系统上运行。
头文件：<boost/thread.hpp>
Thread需要date_time支持，因此需要加上
#defineBOOST_DATE_TIME_SOURCE
#defineBOOST_THREAD_NO_LIB
或者
#defineBOOST_ALL_NO_LIB
注：阻止link错误的方法：extern “C”void tss_cleanup_implemented(void){},该定义实现了自动tss（线程本地存储）清理功能。
vs2008线程库的配置
在附加依赖项中添加boost_tread-vc90-mt-gd-1_47.lib库，并将boost_tread-vc90-mt-gd-1_47.dll放入工程文件夹debug下。
2.5.1互斥量
Boost线程库支持两大类互斥体，包括简单互斥体（simple mutex)和递归互斥体（recursive mutex)。如果同一个线程对互斥体上了两次锁，就会发生死锁（deadlock），也就是说所有的等待解锁的线程将一直等下去。有了递归互斥体，单个 线程就可以对互斥体多次上锁，当然也必须解锁同样次数来保证其他线程可以对这个互斥体上锁。
boost::mutex：独占式互斥量，是最简单最常用的一种互斥量类型
boost::try_mutex：它是mutex的同义词，为了兼容以前的版本而提供
boost::timed_mutex：他也是独占式的互斥量，但提供超时锁定功能
boost::recursive_mutex：递归式互斥量，可以多次锁定，相应的也要多次解锁
boost::recursive_try_mutex：它是recrusive_mutex的同义词，为兼容以前版本提供
boost::recursive_timed_mutex： 递归式互斥量，基本功能与recrusive_mutex相同，但提供超时锁定功能
boost::shared_mutex：读写锁
（1）scopde_lock
测试demo：
boost::mutex io_mutex;
struct count
{
count(int id) : id(id) { }
void operator()()//重载()，当对象使用()时，会执行程序功能
{
for (int i = 0;i < 5; ++i)
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << id << ": "<< i<< std::endl;
}
}
int id;
};
int main(int argc,char* argv[])
{
boost::thread thrd1(count(1));
boost::thread thrd2(count(2));
thrd1.join();
thrd2.join();
return 0;
}
结果：
可以看到，在thrd1执行时，thrd2在等待。等到thrd1执行完后，开始thrd2。
（2）Bind
测试demo：
boost::mutex io_mutex;
void count(int id)
{
for (int i = 0;i < 10; ++i)
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << id << ": " <<i<< std::endl;
}
}
int main(int argc,char* argv[])
{
boost::thread thrd1(boost::bind(&count,1));
boost::thread thrd2(boost::bind(&count,2));
thrd1.join();
thrd2.join();
return 0;
}
（3）thread_specific_ptr
Boost线程库提供了智能指针boost::thread_specific_ptr来访问本地存储线程。每一个线程第一次使用这个智能指针的实 例时，它的初值是NULL，所以必须要先检查这个它的只是否为空，并且为它赋值。Boost线程库保证本地存储线程中保存的数据会在线程结束后被清除。
测试demo：
using namespace boost;
using namespace std;
mutex io_mu;
thread_specific_ptr<int> ptr;
struct counts1
{
counts1(int id):id(id){}
void operator()()
{
if(ptr.get() == 0)
ptr.reset(new int(0));
for (int i = 0;i<5;i++)
{
(*ptr)++;
mutex::scoped_lock lock_s(io_mu);
cout<<id<<":"<<*ptr<<endl;
}
}
int id;
};
void mutex_test()
{
thread t1(counts1(1));
thread t2(counts1(2));
t1.join();
t2.join();
}
结果：
3 函数与回调
3.1 bind
头文件：#include<boost/bind.hpp>
bind最多有十个参数，第一个可调用的对象，之后可以接最多九个参数，参数量必须与可调用对象的参数相同。点位符为_1 _2等等，位置可以随意放。点位符可以出现，也可以不出现。
成员函数：第一个参数为成员函数地址，第二个参数为对象。
成员变量：第一个参数为成员变量的地址，第二个参数为对象。
注：绑定成员函数时：
1，因为成员函数的指针不能直接调用operator()，因此，它必须被绑定到一个对象或者指针。然后才能得到this指针进而调用成员函数。在bind时，需要用一个占位符的位置，提供一个类的实例、引用或者指针，通过对象作为第一个参数来调用成员函数。
2，必须在成员函数前加取地址符&，表明这是一个函数指针。绑定变量时也一样。
3.2 function
头文件：#include<boost/function.hpp>
测试demo：bind与function合用
using namespace boost;
using namespace std;
struct demo
{
int print(int a){return a;}
int operator()(int a){return a;}
};
int f(int a)
{return a;}
void function_bind()
{
function<int(int)> fuc;
fuc = f;
cout<<fuc(3)<<endl;
demo dm;
function<int(int)> fuc2;
fuc2 = bind(&demo::print,&dm,_1);//成员函数前必须加去地址符&，dm是提供的类的对象的引用。
cout<<fuc2(34)<<endl;
function<int(demo&,int)> fuc3;//在定义时，形参定义demo类的指针，在绑定时，可用占位符代替
fuc3 = bind(&demo::print,_1,_2);//也可以预留占位符_1,在调用fun3时，将类的对象、实例或引用填入
cout<<fuc3(dm,56)<<endl;
}
结果：
3.3 signals2
头文件：#include<boost/signals2.hpp>
connect() disconnect()连接或断开信号与插槽。
empty() num_slots()返回是否为空，返回插槽数量。
disconnect_all_slots()断开所有信号与插槽的连接。
combiner() set_combiner()用于获取和设置合并器对象
