boost 系列五 assign和format

boost::assign是boost中一个对容器进行赋值的库，各种方法非常灵活使用。

先举一个例子，供参考：

[cpp]  view plain copy

1. /** 
2.   2 @author Amiber 
3.   3 @date 2012-12-15 
4.   4 **/  
5.   5   
6.   6 #include <iostream>  //for std::cout,std:;endl;  
7.   7 #include <iterator> //for ostream_iterator  
8.   8 #include <algorithm> //for std::copy  
9.   9 #include <vector> //for vector  
10.  10 #include <boost/assign.hpp> //for operator +=  
11.  11 #include <boost/assert.hpp> //for BOOST_ASSERT  
12.  12 #include <boost/assign/std/vector.hpp> //for operator+ vector  
13.  13 int main(int argc,char* argv[])  
14.  14 {  
15.  15   
16.  16         using namespace boost::assign;  
17.  17         std::vector<int> vct;  
18.  18         vct +=1,2,3,4,5,6;  
19.  19   
20.  20   
21.  21         std::copy(vct.begin(),vct.end(),std::ostream_iterator<int>(std::cout," "));  
22.  22         std::cout<<std::endl;  
23.  23   
24.  24         BOOST_ASSERT(vct.size() == 6);  
25.  25         BOOST_ASSERT(vct[0] == 1);  
26.  26         BOOST_ASSERT(vct[1] == 2);                                                                                                                         
27.  27   
28.  28         return 0;  
29.  29 }  
30.                                    

boost::list_inserter、boost::push_back、boost::push_front的用法

[cpp]  view plain copy

1. /** 
2.  2 @author Amiber 
3.  3 @date 2012-12-15**/  

[cpp]  view plain copy

1.  7 #include <iostream> //for std::cout  
2.  8 #include <map> //for map  
3.  9 #include <vector> //for vector  
4. 10 #include <deque> //for deque  
5. 11 #include <set> //for set  
6. 12 #include <map> //for map  
7. 13 #include <iterator> //for ostream_iterator  
8. 14 #include <algorithm> //for std::copy  
9. 15   
10. 16 #include <boost/assign/list_inserter.hpp> //for insert  
11. 17 #include <boost/assert.hpp> // for BOOST_ASSERT  
12. 18 #include <boost/foreach.hpp> // for BOOST_FOREACH  
13. 19 #include <boost/typeof/typeof.hpp> //for BOOST_TYPEOF  
14. 20   
15. 21 int main(int argc,char* argv[])  
16. 22 {  
17. 23           
18. 24   
19. 25         /** 
20. 26         boost::assign::push_back 
21. 27         **/  
22. 28   
23. 29         std::vector<int> vct;  
24. 30   
25. 31         boost::assign::push_back(vct) (0)(1)(2);  
26. 32   
27. 33         std::copy(vct.begin(),vct.end(),std::ostream_iterator<int>(std::cout," "));  
28. 34   
29. 35         std::cout<<std::endl;  
30. 36   
31. 37         /** 
32. 38         boost::assign::push_front 
33. 39         **/  
34. 40   
35. 41         std::deque<int> deq;  
36. 42   
37. 43         boost::assign::push_front(deq) (0)(1)(2);  
38. 44         std::copy(deq.begin(),deq.end(),std::ostream_iterator<int>(std::cout," "));  
39. 45         std::cout<<std::endl;  
40. 46   
41. 47   
42. 48         /** 
43. 49         boost::assgin::insert 
44. 50         **/  
45. 51   
46. 52         std::set<int> intSet;  
47. 53   
48. 54         boost::assign::insert(intSet) (0)(1)(2);  
49. 55         std::copy(deq.begin(),deq.end(),std::ostream_iterator<int>(std::cout," "));  
50. 56         std::cout<<std::endl;  
51. 57   
52. 58   
53. 59         std::map<int,int> intMap;  
54. 60   
55. 61         boost::assign::insert(intMap)(0,1)(2,3)(3,4);  
56. 62           
57. 63         BOOST_FOREACH(BOOST_TYPEOF(*intMap.begin()) elem,intMap)  
58. 64         {  
59. 65                 std::cout<<elem.first<<","<<elem.second<<std::endl;  
60. 66         }  
61. 67         std::cout<<std::endl;  
62. 68   
63. 69         return 0;  
64. 70 }  
65. 71                                                                                                                                                            
66.                                             

boost::list_of、boost::range、boost::repeat、boost::repeat_fun的用法:

[cpp]  view plain copy

1. /** 
2. @author Amiber 
3. @date 2012-12-15 
4. @brief boost::list_of 
5. **/  
6.   
7. #include <iostream> //for std::cout  
8. #include <stack> //for stack  
9. #include <vector> //for vector  
10. #include <map> //for map  
11. #include <iterator> //for ostream_iterator  
12. #include <cstdlib> //for rand  
13. #include <algorithm> //for std::copy  
14.   
15. #include <boost/assign/list_of.hpp> //for list_of  
16. #include <boost/assert.hpp> //for BOOST_ASSERT  
17. #include <boost/typeof/typeof.hpp> //for BOOST_TYPEOF  
18. #include <boost/foreach.hpp> //for BOOST_FOREACH  
19. #include <boost/tuple/tuple.hpp>  
20.   
21. int main(int argc,char* argv[])  
22. {  
23.   
24.         /** 
25.         boost::assign::list_of 
26.         **/  
27.   
28.         std::vector<int> vct;  
29.   
30.         vct = boost::assign::list_of(1)(2)(3);  
31.           
32.         std::copy(vct.begin(),vct.end(),std::ostream_iterator<int>(std::cout," "));  
33.         std::cout<<std::endl;  
34.   
35.         vct = (boost::assign::list_of(1),2,3);  
36.         std::copy(vct.begin(),vct.end(),std::ostream_iterator<int>(std::cout," "));  
37.         std::cout<<std::endl;  
38.   
39.         /** 
40.         boost::assign::map_list_of 
41.         **/  
42.   
43.         std::map<int,int> intMap;  
44.   
45.         intMap = boost::assign::map_list_of(1,2)(2,3)(3,4);  
46.   
47.         BOOST_FOREACH(BOOST_TYPEOF(*intMap.begin()) elem,intMap)  
48.         {  
49.                 std::cout<<elem.first<<","<<elem.second<<std::endl;  
50.         }  
51.   
52.         /** 
53.         boost::assign.to_adapter 
54.         **/  
55.   
56.         std::stack<int> stck;  
57.   
58.         stck = boost::assign::list_of(1)(2)(3).to_adapter();  
59.   
60.         std::cout<<stck.top()<<std::endl;  
61.         std::cout<<std::endl;  
62.   
63.         /** 
64.         boost::assign.repeat 
65.         **/  
66.   
67.         std::vector<int> vect;  
68.   
69.         vect = boost::assign::list_of(1)(2).repeat(2,3);  
70.   
71.         std::copy(vect.begin(),vect.end(),std::ostream_iterator<int>(std::cout," "));  
72.         std::cout<<std::endl;  
73.   
74.         /** 
75.         boost::assign.repeat_fun 
76.         **/  
77.   
78.         vect = boost::assign::list_of(1)(2).repeat_fun(2,rand);  
79.         std::copy(vect.begin(),vect.end(),std::ostream_iterator<int>(std::cout," "));  
80.         std::cout<<std::endl;  
81.   
82.         /** 
83.         boost::assign.range 
84.         **/  
85.   
86.         vect = boost::assign::list_of(1)(2).range(vct);  
87.         std::copy(vect.begin(),vect.end(),std::ostream_iterator<int>(std::cout," "));  
88.         std::cout<<std::endl;  
89.   
90.   
91.         /** 
92.         boost::tuple_list_of 
93.         **/  
94.         std::vector< boost::tuple<int,int> > tupl;  
95.         tupl = boost::assign::tuple_list_of(1,2)(2,3)(3,4);  
96.   
97.         std::cout<<boost::get<0>(tupl[1])<<std::endl;  
98.   
99.         return 0;  
100. }  

boost::ref_list_of /boost::cref_list_of

通过变量的引用来填充容器

[cpp]  view plain copy

1.  1 /** 
2.  2 @author Amiber 
3.  3 @date 2012-12-15 
4.  4 @brief boost::assing::ref_list_of 
5.  5 **/  
6.  6   
7.  7 #include <iostream> //for std::cout  
8.  8 #include <vector> //for vector  
9.  9 #include <iterator> // for ostream_iterator  
10. 10 #include <algorithm> //for std::copy  
11. 11   
12. 12 #include <boost/assign/list_of.hpp> //for ref_list_of  
13. 13 #include <boost/assert.hpp>  //for BOOST_ASSERT  
14. 14 #include <boost/typeof/typeof.hpp> //for BOOST_TYPEOF  
15. 15 #include <boost/foreach.hpp> //for BOOST_FOREACH  
16. 16 #include <boost/static_assert.hpp> //for BOOST_ASSERT  
17. 17   
18. 18   
19. 19 template <class Range>  
20. 20 typename Range::const_iterator max_element(const Range& r)  
21. 21 {  
22. 22         return std::max_element(r.begin(),r.end());  
23. 23 }  
24. 24   
25. 25 int main(int argc,char* argv[])  
26. 26 {  
27. 27         std::vector<int> vct;  
28. 28         int a = 1;  
29. 29         int b = 2;  
30. 30         int c = 3;  
31. 31   
32. 32         /** 
33. 33         std::assign::ref_list_of 
34. 34         **/  
35. 35   
36. 36         vct = boost::assign::ref_list_of<3>(a)(b)(c);  
37. 37   
38. 38         BOOST_FOREACH(BOOST_TYPEOF(*vct.begin()) elem,vct )  
39. 39         {  
40. 40                 std::cout<<elem<<" ";  
41. 41         }  
42. 42   
43. 43         std::cout<<std::endl;  
44. 44   
45. 45         int& tmp = vct[0];  
46. 46         tmp =11;  
47. 47         std::cout<<vct[0]<<","<<tmp<<","<<a<<std::endl;  
48. 48   
49. 49         std::cout<<std::endl;  
50. 50   
51. 51         int& max = *max_element(boost::assign::ref_list_of<3>(a)(b)(c));  
52. 52   
53. 53         BOOST_ASSERT(max == c);  
54. 54   
55. 55         std::cout<<max<<","<<c<<std::endl;  
56. 56         max = 10;  
57. 57   
58. 58         BOOST_ASSERT(max == c);  
59. 59         std::cout<<max<<","<<c<<std::endl;  
60. 60   
61. 61         /** 
62. 62         boost::assign::cref_list_of 
63. 63         **/  
64. 64         const std::vector<int> cVct(vct);  
65. 65         int  anoMax = *max_element(cVct);  
66. 66   
67. 67         BOOST_ASSERT(anoMax ==c);  
68. 68   
69. 69         anoMax = 11;  
70. 70         BOOST_ASSERT(anoMax ==c);                                                                                                                          
71. 71   
72. 72         return 0;  
73. 73 }  
74.                                                           

boost::ptr_list_inserter、boost::ptr_push_front、boost::ptr_push_back、boost::ptr_map_inserter用法

[cpp]  view plain copy

1. 1 /**                                                                                                                                                       
2.  2 @author Amiber 
3.  3 @date 2012-12-15 
4.  4 @brief boost::ptr_push_back\boost::ptr_push_front\boost::ptr_insert\boost::ptr_map_insert 
5.  5 **/  
6.  6   
7.  7   
8.  8 #include <iostream> //for std::cout  
9.  9   
10. 10   
11. 11 #include <boost/assign/ptr_list_inserter.hpp> //for ptr_push_back\ptr_list_inserter\ptr_push_front  
12. 12 #include <boost/assign/ptr_map_inserter.hpp> //for ptr_map_inserter  
13. 13 #include <boost/static_assert.hpp> //for BOOST_ASSERT  
14. 14 #include <boost/typeof/typeof.hpp> // for BOOST_TYPEOF  
15. 15 #include <boost/foreach.hpp> // for BOOST_FOREACH  
16. 16   
17. 17   
18. 18 #include <boost/ptr_container/ptr_deque.hpp> //for ptr_deque  
19. 19 #include <boost/ptr_container/ptr_set.hpp> //for ptr_set  
20. 20 #include <boost/ptr_container/ptr_map.hpp> //for ptr_map  
21. 21   
22. 22   
23. 23 class Person  
24. 24 {  
25. 25         public :  
26. 26             Person()  
27. 27             {  
28. 28                     std::cout<<"I am born,but I does not have a name"<<std::endl;  
29. 29             }  
30. 30   
31. 31             Person(const std::string& name)  
32. 32             {  
33. 33                     this->name = name;  
34. 34                     std::cout<<"I am born,My name is "<<name<<std::endl;  
35. 35             }  
36. 36   
37. 37             ~Person()  
38. 38             {  
39. 39             }  
40. 40   
41. 41         private :  
42. 42             std::string name;  
43. 43   
44. 44   
45. 45         public :  
46. 46             friend bool operator < (const Person& pt1,const Person& pt2)  
47. 47             {  
48. 48                     return pt1.name > pt2.name;  
49. 49             }  
50. 50 };     
51. 51       
52. 52   
53. 53 int main(int argc,char* argv[])  
54. 54 {   
55. 55         int a = 1;  
56. 56         int b = 2;  
57. 57         int c = 3;  
58. 58   
59. 59   
60. 60         /** 
61. 61         boost::assign::ptr_push_back 
62. 62         boost::assign::ptr_push_front 
63. 63         **/  
64. 64   
65. 65         boost::ptr_deque<int> deq;  
66. 6   
67. 67         boost::assign::ptr_push_front(deq) (a)(b)(c);  
68. 68   
69. 69         BOOST_ASSERT(deq.size() == 3u);  
70. 70   
71. 71         BOOST_FOREACH(BOOST_TYPEOF(*deq.begin()) elem , deq)  
72. 72         {  
73. 73                 std::cout<<elem<<" ";  
74. 74         }  
75. 75   
76. 76         std::cout<<std::endl;  
77. 77   
78. 78         boost::ptr_deque<Person> perDeq;  
79. 79         boost::assign::ptr_push_back(perDeq) ()();  
80. 80   
81. 81         boost::assign::ptr_push_back(perDeq) ("Amiber")("Bamboo");  
82. 82   
83. 83         /** 
84. 84         boost::assign::ptr_insert 
85. 85         boost::assign::pre_map_insert 
86. 86         **/  
87. 87   
88. 88         boost::ptr_set<Person> perSet;  
89. 89         boost::assign::ptr_insert(perSet) ()();  
90. 90   
91. 91         boost::assign::ptr_insert(perSet) ("Amiber")("Bamboo");  
92. 92   
93. 93   
94. 94         boost::ptr_map<int,Person> perMap;  
95. 95   
96. 96         boost::assign::ptr_map_insert(perMap) (1,"Amiber")(2,"Bamboo");  
97. 97         return 0;  
98. 98 }       
99. 
    

100. boost::format库提供对了输出的个数类型进行格式化的需求，这里仅作为一个参考，要想更加学会format, 可以自学boost文档。下面是一个例子：

     [cpp]  view plain copy

     1. /**                                                                                                                                                       
     2.   2 @author Amiber 
     3.   3 @date 2012-12-16 
     4.   4 @brief boost::format 
     5.   5 **/  
     6.   6   
     7.   7 #include <iostream> //for std::cout  
     8.   8 #include <exception>  
     9.   9   
     10.  10 #include <boost/format.hpp> //for format  
     11.  11 #include <boost/static_assert.hpp> // for BOOST_ASSERT  
     12.  12   
     13.  13 int main(int argc,char* argv[])  
     14.  14 {  
     15.  15   
     16.  16         int a = 10;  
     17.  17         int b = 11;  
     18.  18         double c = 23.2344;  
     19.  19   
     20.  20         /** 
     21.  21         format %N% %N% 
     22.  22         **/  
     23.  23         std::cout<<boost::format("%1%,%2%,%1%") % a % b<<std::endl;  
     24.  24   
     25.  25         /** 
     26.  26         format %d 
     27.  27         **/  
     28.  28   
     29.  29         std::cout<<boost::format("%d,%d") % a %b <<std::endl;  
     30.  30   
     31.  31   
     32.  32         /** 
     33.  33         format %1$ [flag] [...] 
     34.  34         **/  
     35.  35   
     36.  36         std::cout<<boost::format("%.3f") %c <<std::endl;  
     37.  37         std::cout<<boost::format("%1$+5.3f") %c <<std::endl;  
     38.  38   
     39.  39         std::cout<<boost::format("%1$p") % a <<std::endl;  
     40.  40   
     41.  41         /** 
     42.  42         format group() 
     43.  43         **/  
     44.  44   
     45.  45         std::string str="Amiber";  
     46.  46   
     47.  47         std::cout<<boost::format("My name is %1%,my money is %2%") % str % boost::io::group(std::hex,1430)<<std::endl;  
     48.  48        
     49.  49         /** 
     50.  50         boost::format::clear  
     51.  51         boost::format::parse 
     52.  52         **/  
     53.  53            
     54.  54         std::string formstr="%d<->%d";  
     55.  55         boost::format fmt(formstr);  
     56.  56   
     57.  57         std::cout<<fmt % a % b <<std::endl;   
     58.  58   
     59.  59         fmt.clear();  
     60.  60   
     61.  61         fmt.parse("%d>-<%d");  
     62.  62   
     63.  63   
     64.  64         std::cout<<fmt % a %b <<std::endl;  
     65.  65    
     66.  66         /** 
     67.  67         boost::format::size 
     68.  68         boost::format::str 
     69.  69         **/  
     70.  70   
     71.  71         BOOST_ASSERT(fmt.size() !=0);  
     72.  72   
     73.  73         std::cout<<fmt.str()<<std::endl;  
     74.  74   
     75.  75         /** 
     76.  76         boost::io::too_many_args 
     77.  77         boost::io::too_few_args 
     78.  78         boost::io::bad_format_string 
     79.  79         **/  
     80.  80   
     81.  81         try   
     82.  82         {  
     83.  83                 std::cout<<fmt % 1 % 2 %3 <<std::endl;  
     84.  84         }catch(const boost::io::too_many_args& e)  
     85.  85         {  
     86.  86                 std::cout<<"This exceptions is "<<e.what()<<std::endl;  
     87.  87         }     
     88.  88   
     89.  89   
     90.  90         try   
     91.  91         {  
     92.  92                 std::cout<<fmt % 1 <<std::endl;  
     93.  93         }catch(const boost::io::too_few_args& e)  
     94.  94         {  
     95.  95                 std::cout<<"Another exception is "<<e.what()<<std::endl;  
     96.  96         }  
     97.  97         return 0;  
     98.  98 }