boost常用库案例

我会带着你远行 2022-06-14 07:41 167阅读 0赞

转载地址：http://www.cnblogs.com/wangkangluo1/archive/2011/07/19/2110746.html

1.boost::any

boost::any是一种通用的数据类型，可以将各种类型包装后统一放入容器内，最重要的它是类型安全的。有点象COM里面的variant。

使用方法：

any::type() 返回包装的类型

any\_cast可用于any到其他类型的转化

1.  \#include <boost/any.hpp>
2.  **void** test\_any()
3.  \{ 
4.      **typedef** std::vector<boost::any> many;
5.      many a;
6.      a.push\_back(2);
7.      a.push\_back(string("test"));
8.      **for**(unsigned int i=0;i<a.size();++i)
9.      \{ 
10.         cout<<a\[i\].type().name()<<endl;
11.         **try**
12.         \{ 
13.             int result = any\_cast<int>(a\[i\]);
14.             cout<<result<<endl;
15.         \}
16.         **catch**(boost::bad\_any\_cast & ex)
17.         \{ 
18.             cout<<"cast error:"<<ex.what()<<endl;
19.         \}
20.     \}
21. \}

2.boost::array

boost::array仅仅是对数组一层薄薄的封装，提供跟各种算法配合的iterator,使用方法很简单。注意：可以使用\{\}来初始化array,因为array所有的成员变量都是public的。

1.  \#include <boost/array.hpp>
2.  **void** test\_array()
3.  \{ 
4.      array<int,10> ai = \{1,2,3\};
5.      **for**(size\_t i=0;i<ai.size();++i)
6.      \{ 
7.          cout<<ai\[i\]<<endl;
8.      \}
9.  \}

3.boost::lexical\_cast

lexical\_cast用于将字符串转换成各种数字类型(int,float,short etc.)。

1.  \#include <boost/lexical\_cast.hpp>
2.  **void** test\_lexical\_cast()
3.  \{ 
4.      int i = boost::lexical\_cast<int>("123");
5.      cout << i << endl;
6.  \}

4.boost::format

boost::format是用于替代c里面的sprintf，优点是类型安全，不会因为类型和参数不匹配而导致程序崩溃了，而且还可以重复使用参数。

1.  \#include <boost/format.hpp>
2.  **void** test\_format()
3.  \{ 
4.      cout << 
5.          boost::format("writing %1%,  x=%2% : %3%-th try")
6.          % "toto"
7.          % 40.23
8.          % 50
9.          <<endl;
10.     format f("a=%1%,b=%2%,c=%3%,a=%1%");
11.     f % "string" % 2 % 10.0;
12.     cout << f.str() << endl;
13. \}

5.boost::tokenizer

boost::tokenizer是用于切割字符串的，类似于Java里面的StringTokenizer。

1.  \#include <boost/tokenizer.hpp>
2.  **void** test\_tokenizer()
3.  \{ 
4.      string s("This is  , a ,test!");
5.      boost::tokenizer<> tok(s);
6.      **for**(tokenizer<>::iterator beg=tok.begin(); beg!=tok.end();++beg)
7.      \{ 
8.          cout << \*beg << " ";
9.      \}
10. \}

6.boost::thread

boost::thread是为了提供跨平台的thread机制。利用boost::function来完成委托。

1.  \#include <boost/thread.hpp>
2.  **void** mythread()
3.  \{ 
4.      cout<<"hello,thread!"<<endl;
5.  \}
6.  **void** test\_thread()
7.  \{ 
8.      boost::function< **void** () > f(mythread);
9.      boost::**thread** t(f);
10.     t.join();
11.     cout<<"thread is over!"<<endl;
12. \}

7.boost::serialization

boost::serialization提供object的序列化功能。而且提供好几种序列化的格式，比如text,binary,xml。

1.  \#include <boost/archive/text\_oarchive.hpp>
2.  \#include <boost/archive/text\_iarchive.hpp>
3.  \#include <boost/archive/xml\_oarchive.hpp>
4.  **void** test\_serialization()
5.  \{ 
6.      boost::archive::text\_oarchive to(cout , boost::archive::no\_header);
7.      int i = 10;
8.      string s = "This is a test ";
9.      to & i;
10.     to & s;
11.     ofstream f("test.xml");
12.     boost::archive::xml\_oarchive xo(f);
13.     xo & BOOST\_SERIALIZATION\_NVP(i) & BOOST\_SERIALIZATION\_NVP(s);
14.     boost::archive::text\_iarchive ti(cin , boost::archive::no\_header);
15.     ti & i & s;
16.     cout <<"i="<< i << endl;
17.     cout <<"s="<< s << endl;
18. \}

8.boost::function

boost::function就是所谓的泛函数，能够对普通函数指针，成员函数指针，functor进行委托，达到迟调用的效果。

1.  \#include <boost/function.hpp>
2.  int foo(int x,int y)
3.  \{ 
4.      cout<< "(foo invoking)x = "<<x << " y = "<< y <<endl;
5.      **return** x+y;
6.  \}
7.  **struct** test
8.  \{ 
9.      int foo(int x,int y)
10.     \{ 
11.         cout<< "(test::foo invoking)x = "<<x << " y = "<< y <<endl;
12.         **return** x+y;
13.     \}
14. \};
15. **void** test\_function()
16. \{ 
17.     boost::function<int (int,int)> f;
18.     f = foo;
19.     cout << "f(2,3)="<<f(2,3)<<endl;
20.     test x;
21.     /\*f = std::bind1st(std::mem\_fun(&test::foo), &x);\*/
22.     boost::function<int (test\*,int,int)> f2;
23.     f2 = &test::foo;
24.  
25.     cout << "f2(5,3)="<<f2(&x,5,3)<<endl;
26. \}

9.boost::shared\_ptr

boost::shared\_ptr就是智能指针的实现，不象std::auto\_ptr，它是可以stl的容器一起使用的，非常的方便。

1.  \#include <boost/shared\_ptr.hpp>
2.  **class** Shared
3.  \{ 
4.      **public**:
5.          Shared()
6.          \{ 
7.              cout << "ctor() called"<<endl;
8.          \}
9.          Shared(**const** Shared & other)
10.         \{ 
11.             cout << "copy ctor() called"<<endl;
12.         \}
13.         ~Shared()
14.         \{ 
15.             cout << "dtor() called"<<endl;
16.         \}
17.         Shared & operator = (**const** Shared & other)
18.         \{ 
19.             cout << "operator =  called"<<endl;
20.         \}
21. \};
22. **void** test\_shared\_ptr()
23. \{ 
24.     **typedef** boost::shared\_ptr<Shared> SharedSP;
25.     **typedef** vector<SharedSP> VShared;
26.     VShared v;
27.     v.push\_back(SharedSP(**new** Shared()));
28.     v.push\_back(SharedSP(**new** Shared()));
29. \}

完