boost-工具类1

1.noncopyable类

位置：#include <boost/noncopyable.hpp> 或者#include <boost/utility.hpp>

c++类中，如果不明确定义拷贝构造函数好拷贝赋值操作符，编译器会为我们合成一个，为了避免这种“浅赋值”(会很危险)，我们可以通过继承noncopyable类。

即可以通过隐式private继承，也可以public继承。noncopyable类的实现也很简单，只要私有化拷贝构造函数和赋值操作符。

2.typeof类

位置：#include <boost/typeof/typeof.hpp>为了减轻书写烦琐的变量类型声明的工作，简化代码。

例如：stl迭代器的声明：std::map<std::string, std::string>::iterator pos =s.begin(); 我们使用宏BOOST_TYPEOF可以在编译期间自动推导表达式的类型。

这样就不用写这么长的声明了。

例如：

#include <iostream>
#include <vector>
#include <utility>//pair类
#include <string>
#include <boost/typeof/typeof.hpp>

using namespace boost;
using std::cout;
using std::endl;
using std::string;

int main() 
{
BOOST_TYPEOF(2.1*3) x = 2.1*3;//定义x变量，typeof自动推导x的类型。
cout<<x<<endl;//6.3
//std::pair p = std::make_pair(1, "string");
BOOST_AUTO(p, std::make_pair(1, "string"));//用法类似typeof,自动推导p，类型为pair类型。
cout<<p.first<<endl;//1.
cout<<p.second<<endl;//string.
}

3.assign.

库的命名空间：boost::assign。头文件 #include <boost/assign.hpp>

作用：因为STL容器仅提供了容纳这些数据的方法，但是填充初始化的步骤却相当麻烦，必须调用insert()或者push_back()等成员函数，

但是boost.assign提供了填入大量数据的方法。

应用实例：

#include <vector>
#include <string>
#include <iterator>
#include <algorithm>
#include <iostream>
#include <utility>
#include <boost/assign.hpp>

using std::cout;
using std::endl;
using std::map;
using std::string;
using std::vector;
using std::list;
using std::set;
using std::deque;

int main()
{
    using namespace boost::assign;
    //第一种方法：
    //使用assign中的+=操作符初始化，非常方便；
    //但是它仅限于标准容器(vector,list,set,map等)
    vector<int> v;
    v += 1,2,3,4,5,6*6;
    
    vector<int>::iterator it;
    for(it=v.begin(); it!=v.end(); ++it)
        cout<<*it<<endl;

    std::set<std::string> s;
    s += "cpp", "java", "c#", "python";

    //第二种方法：
    //使用assign的()操作符向容器增加元素。
    //不能直接使用operator(),而应当使用assign库提供的三个辅助函数
    //insert(),push_front(), push_back();
    vector<int> iv;
    push_back(iv) (1) (2) (3) (4) (5);
    for(it=iv.begin(); it!=iv.end(); ++it)
        cout<<*it<<endl;

    list<string> l;
    push_front(l) ("cpp")("java")("c#")("python");

    set<double> ds;
    insert(ds) (3.14)(0.618)(1.732);

    map<int, string> m;
    insert(m) (1, "one")(2,"two");

    //第三种方法：在容器构造的时候就完成初始化。
    //assign库使用list_of(),map_list_of()/pair_list_of()
    //和tuple_list_of();三个函数解决了问题。

    vector<int> v2 = list_of(1)(2)(3)(4)(5);   
    //v = [1, 2, 3, 4, 5];

    deque<string> d2 = list_of("power")("bomb")("suit");//注意括号
    //d = [power, bomb suit];

    set<int> s2 = (list_of (10), (20), (30), (40), (50));//注意括号

    map<int, string> m2 = (list_of(std::make_pair(1, "one")));

    map<int, int> m3 = map_list_of(1,2)(3,4)(5,6);//map_list_of的用法。

    //使用repeat()方法减少重复输入    
    vector<int> v3 = list_of(1).repeat(3,2)(3)(4)(5);
    //v3 = 1,2,2,2,3,4,5;

    set<int> ms;
    //第一个参数时重复次数，第二个参数是一个函数对象，返回填入的值，
    //这里使用rand随机函数。
    insert(ms).repeat_fun(5,&rand).repeat(2,1), 10;

    deque<int> di;
    //range()函数将v3容器中的前五个元素插入到di中。
    push_front(di).range(v3.begin(), v3.begin()+6);
    //4,3,2,2,2,1 由于deque底层采用大顶堆实现，所以是降序输出。
    
    return 0;   
}

4.swap，是std::swap的增强和泛化。 位置：#include <boost/swap.hpp>

 std::swap的实现：
template<typename T>//要求T类型必须可以拷贝构造和拷贝赋值。(重载operator=)
void swap(T& a, T& b)
{
	T tmp(a);//需要创建临时对象。如果对象较大，代价会很高。
	a = b;
	b = tmp;
}

 boost::swap()实现：
 声明：template<class T1, class T2>
 void swap(T1& left, T2& right);
区别：std::swap使用了标准的交换操作，而boost::swap通过ADL规则找到了全局名字空间的特化交换函数。
尽量使用boost::swap,它提供了比std::swap更好的优化策略。

int main()
{
    int a1[10];
    int a2[10];//如果长度不相同，则不能交换，编译错误。

    std::fill_n(a1, 10, 5);
    std::fill_n(a2, 10, 20);

    //实现就是用for循环，对数组中的每个元素进行交换得到的。  
    boost::swap(a1, a2);

    cout<<a1[1]<<endl;//20
    cout<<a2[1]<<endl;//5

    vector<int> v1(5, 10);
    vector<int> v2(5, 20);
    boost::swap(v1, v2);
    cout<<v1[1]<<endl;
    cout<<v2[1]<<endl;

    return 0;   
}

5. tribool 类似bool类型，
但是它有三种状态：true(真),和false(假),还有indeterminate(未知、不确定)
位置：#include <boost/logic/tribool.hpp>
类摘要：
class tribool
{
tribool(bool value);//默认值是false
enum value_t {false_value, ture_value, indeterminate_value } value;
}
三态布尔逻辑：
1.任何与indeterminate的比较操作结果都是indeterminate；
2.与indeterminate的逻辑||操作，只有与true运算结果为true，其余均为indeterminate。
3.与indeterminate的逻辑&&操作，只有与false运算结果为false，其余均为indeterminate；
4.indeterminate的非操作！结果仍为indeterminate；
ps:可以使用BOOST_TRIBOOL_THIRD_STATE(unknow);给indeterminate更换名称。
tribool的输入输出：

另外包含#include <boost/logic/tribool_io.hpp>

#include <boost/swap.hpp>
#include <boost/logic/tribool.hpp>
#include <boost/logic/tribool_io.hpp>

using std::cout;
using std::endl;
using std::vector;

using namespace boost;


//BOOST_TRIBOOL_THIRD_STATE(unknow);

int main()
{
    tribool tb1(true);
    tribool tb2 = indeterminate;

    if(tb1)
        cout<<"true"<<endl;


    tb2 = indeterminate;
    tribool tb3 = false;
    cout<<tb1<<endl;//1
    cout<<tb2<<endl;//2
    cout<<tb3<<endl;//0

    if(tb2 == indeterminate)
        cout<<"indeterminate"<<endl;

    cout<<(tb2 || true)<<endl;//true
    cout<<(tb2 && false)<<endl;//false 

    return 0;   
}

  看了这么久，感觉boost的内容很多，许多东西只需要了解即可，有些东西确实很实用需要掌握，但是有些内容感觉就是过度编程，使用价值很小，需要适可而止。