Boost

1：array库
库 array 在 boost/array.hpp 中定义了一个模板类 boost::array 。 通过使用这个类，可以创建一个跟 C++ 里传统的数组有着相同属性的容器。

template<typename T, std::size_t N> 
    class array{...}

例：

#include <stdio.h>
#include <boost/array.hpp>
int main() 
{
    // 定义长度为3的整形数组,数据结构上等同 int a[3];
    boost::array<int, 3> a;
    // 数组元素赋值
    a[0] = 1;
    a.at(1) = 2;
    *a.rbegin() = 3;
    // 数组指针
    int* p = a.data();
    // 遍历数组
    for (int i = 0; i < a.size(); i++)
    {
        printf("%d %d\n", a[i], p[i]);
    }
    return 0;
} 

2：bind库
库 bind 在 boost/bind.hpp 中定义了一个模板函数 boost::bind 。 通过使用这个函数，可以将多个函数参数绑定到一起，形成一个仿函数对象，并可以选择保存成boost::function对象。
它可用来替换c++标准库中著名的 std::bind1st() 和 std::bind2nd()，简化代码。
例：

#include <boost/bind.hpp> 
#include <iostream> 
#include <vector> 
#include <algorithm> 
void add(int i, int j) 
{ 
    std::cout << i + j << std::endl; 
} 
int main() 
{ 
std::vector<int> v; 
v.push_back(1); 
v.push_back(3); 
v.push_back(2); 
std::for_each(v.begin(),v.end(), boost::bind(add, 10, _1)); 
}
//输出：11,13,12

3：smartpointers库
智能指针的原理基于一个常见的习语叫做 RAII ：资源申请即初始化。

 class Resource{};  
  class RAII{  
  public:  
      RAII(Resource* aResource):r_(aResource){} //获取资源  
      ~RAII() {delete r_;} //释放资源  
      Resource* get()    {return r_ ;} //访问资源  
  private:  
      Resource* r_;  
  };

（1）作用域指针
它独占一个动态分配的对象， 对应的类名为 boost::scoped_ptr，定义在 boost/scoped_ptr.hpp 中。作用域指针不能传递它所包含的对象的所有权到另一个作用域指针。一旦用一个地址来初始化，这个动态分配的对象将在析构阶段释放。因为一个作用域指针只是简单保存和独占一个内存地址。

#include <boost/scoped_ptr.hpp>
int main()
{
boost::scoped_ptr<int> i(new int);
*i = 1;
*i.get() = 2;
i.reset(new int);
return 0;
}

（2）作用域数组
作用域数组的析构函数使用 delete[] 操作符来释放所包含的对象。

#include <boost/scoped_array.hpp>
int main()
{
boost::scoped_array<int> i(new int[2]);
*i.get() = 1;
i[1] = 2;
i.reset(new int[3]);
}

（3）共享指针
智能指针 boost::shared_ptr 基本上类似于 boost::scoped_ptr。 关键不同之处在于 boost::shared_ptr 不一定要独占一个对象。 它可以和其他 boost::shared_ptr 类型的智能指针共享所有权。 在这种情况下，当引用对象的最后一个智能指针销毁后，对象才会被释放。

#include <vector>
#include <algorithm>
#include <boost/shared_ptr.hpp>
void print(boost::shared_ptr<int> i)
{
    printf("%d\n", *i);
}
int main()
{
std::vector<boost::shared_ptr<int> > v;
    {
    boost::shared_ptr<int>i1(new int(1));
    boost::shared_ptr<int>i2(new int(2));
    v.push_back(i1);
    v.push_back(i2);
    }
    std::for_each(v.begin(),v.end(),print);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <boost/shared_ptr.hpp>
class Test {
public:
Test(int i):_i(i)printf("construct:%d\n", _i);}
~Test() {printf("~destroyed: %d\n", _i);}
void print() {printf("Test value: %d\n", _i);}
private:
    int _i;
};
int main()
{
    boost::shared_ptr<Test> i1(new Test(1));
    boost::shared_ptr<Test> i2(i1);
    boost::shared_ptr<Test> i3(i1);
    i1.reset(new Test(2));
    i1->print();
    i2->print();
    i3->print();
    return 0;
} 

（4）共享数组
共享数组对应的类型是 boost::shared_array，它的定义在boost/shared_array.hpp 里。

#include <iostream>
#include <boost/shared_array.hpp>
int main()
{
    boost::shared_array<int> i1(new int[2]);
    boost::shared_array<int> i2(i1);
    i1[0] = 1;
    std::cout << i2[0] << std::endl;
    return 0;
}