├── .gitignore
├── .travis.yml
├── CMakeLists.txt
├── LICENSE
├── README.md
├── any.cpp
├── function.cpp
├── make_shared.cpp
├── property_tree.cpp
├── smart_pointer.cpp
└── thread.cpp


/.gitignore:
--------------------------------------------------------------------------------
1 | release
2 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | # https://travis-ci.org
 2 | 
 3 | language: cpp
 4 | 
 5 | install:
 6 |   - sudo add-apt-repository --yes ppa:ubuntu-sdk-team/ppa
 7 |   - sudo add-apt-repository --yes ppa:lttng/daily
 8 |   - sudo apt-get update -qq
 9 |   - sudo apt-get install -qq libboost-all-dev
10 | script:
11 |   - mkdir release && cd release
12 |   - cmake ..
13 |   - make
14 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | project(boost_tutorial)
 2 | 
 3 | cmake_minimum_required(VERSION 2.8)
 4 | 
 5 | if(POLICY CMP0042)
 6 |     cmake_policy(SET CMP0042 NEW)
 7 | endif()
 8 | 
 9 | include_directories(/usr/local/include)
10 | 
11 | link_directories(/usr/local/lib)
12 | set(REQUIRED_LIB boost_thread boost_system)
13 | 
14 | macro (make_exec name)
15 |     add_executable(${name} ${name}.cpp)
16 |     target_link_libraries(${name} ${REQUIRED_LIB})
17 | endmacro (make_exec)
18 | 
19 | make_exec(any)
20 | make_exec(function)
21 | make_exec(make_shared)
22 | make_exec(property_tree)
23 | make_exec(smart_pointer)
24 | # make_exec(thread)
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 zddhub (zdd)
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | boost_tutorial [![Build Status](https://travis-ci.org/zddhub/boost_tutorial.svg?branch=master)](https://travis-ci.org/zddhub/boost_tutorial)
 2 | ==============
 3 | 
 4 | A simple tutorial of boost
 5 | 
 6 | includes:
 7 | =========
 8 | 
 9 | * smart pointer : boost::scoped_ptr boost::shared_ptr boost::weak_ptr
10 | * boost::property_tree : parser JSON file
11 | * boost::any
12 | * boost::make_shared
13 | * boost::function (callback)
14 | 
15 | How to run
16 | ==========
17 | 
18 | ```sh
19 | mkdir release && cd release
20 | cmake ..
21 | make
22 | ```
23 | 


--------------------------------------------------------------------------------
/any.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * boost::property_tree tutorial
 3 |  *
 4 |  * zdd / zddhub@gmail.com
 5 |  * https://github.com/zddhub/boost_tutorial
 6 |  */
 7 | 
 8 | #include <iostream>
 9 | #include <vector>
10 | using namespace std;
11 | 
12 | #include <boost/any.hpp>
13 | 
14 | class Customer {
15 | public:
16 |     Customer(const std::string& name) : _name(name) {}
17 |     std::string toString() {
18 |         return _name;
19 |     }
20 | private:
21 |     std::string _name;
22 | };
23 | 
24 | int main()
25 | {
26 |     cout << "boost::any: " << endl;
27 | 
28 |     //boost::any可以存放任意类型的对象
29 |     typedef std::vector<boost::any> vector_any;
30 |     vector_any va;
31 | 
32 |     va.push_back(100); //存放常数
33 |     va.push_back(std::string("zddhub.com")); //存放string，注意vector_any.push_back("zddhub.com")会被当成字符数组
34 |     va.push_back(new Customer("zdd"));//自定义类型
35 |     va.push_back(Customer("zddhub"));
36 | 
37 |     //根据类型进行显示
38 |     for(vector_any::iterator it = va.begin(); it != va.end(); ++it) {
39 |         if(it->type() == typeid(int)) {
40 |             cout << "int: " << boost::any_cast<int>(*it)<<endl;
41 |         } else if(it->type() == typeid(std::string)) {
42 |             cout << "string: " << boost::any_cast<std::string>(*it).c_str() <<endl;
43 |         } else if(it->type() == typeid(Customer*)) {
44 |             Customer *c = boost::any_cast<Customer*>(*it);
45 |             cout << "Custormer* : " << c->toString().c_str()<<endl;
46 |             delete c;
47 |         } else if(it->type() == typeid(Customer)) {
48 |             cout << "Custormer : " << boost::any_cast<Customer>(*it).toString().c_str()<<endl;
49 |         }
50 |     }
51 | 
52 |     return 0;
53 | }
54 | 
55 | 


--------------------------------------------------------------------------------
/function.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | using namespace std;
 4 | 
 5 | #include <boost/function.hpp>
 6 | #include <boost/bind.hpp>
 7 | 
 8 | typedef boost::function<void (int, int, const std::string&)> Callback;
 9 | 
10 | void test(int n, Callback callback = Callback()) {
11 |     for(int i = 0; i < n; i++) {
12 |         //cout << "i*i = " << i*i <<endl;
13 | 
14 |         if(callback)
15 |             callback(i, n, "");
16 |     }
17 | }
18 | 
19 | void print(int index, int total, const std::string& info) {
20 |     if(index +1 != total)
21 |         cout << info.c_str() << index+1 << "/" << total <<"\r"<<std::flush;
22 |     else
23 |         cout << info.c_str() << index+1 << "/" << total <<"."<<std::endl;
24 | }
25 | 
26 | int main()
27 | {
28 |     cout << "Boost::function callbank_fun" << endl;
29 | 
30 |     test(1000, print);
31 | 
32 |     test(1000, boost::bind(&print, _1, _2, "compute i*i "));
33 | 
34 |     return 0;
35 | }
36 | 
37 | 


--------------------------------------------------------------------------------
/make_shared.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * boost::make_shared tutorial
 3 |  *
 4 |  * zdd / zddhub@gmail.com
 5 |  * https://github.com/zddhub/boost_tutorial
 6 |  */
 7 | #include <iostream>
 8 | #include <string>
 9 | using namespace std;
10 | 
11 | #include <boost/shared_ptr.hpp>
12 | #include <boost/make_shared.hpp>
13 | 
14 | class Base {
15 | public:
16 |     Base(const std::string& name ): _name(name) {
17 |         cout << _name.c_str() << " : Base()" <<endl;
18 |     }
19 | 
20 |     virtual ~Base() {
21 |         cout << _name.c_str() << " : ~Base()" <<endl;
22 |     }
23 | 
24 |     virtual void toString() const {
25 |         cout << _name.c_str() <<endl;
26 |     }
27 | protected:
28 |     std::string _name;
29 | };
30 | 
31 | class SubClass : public Base {
32 | public:
33 |     SubClass(const std::string& name, uint x = 0): Base(name) {
34 |         cout << _name.c_str() << " : SubClass()" <<endl;
35 |         cout << "x = " << x << endl;
36 |     }
37 | 
38 |     virtual ~SubClass() {
39 |         cout << _name.c_str() << " : ~SubClass()" <<endl;
40 |     }
41 | 
42 |     void toString() const {
43 |         cout << _name.c_str() <<endl;
44 |     }
45 | };
46 | 
47 | int main()
48 | {
49 |     cout << "make_shared : " << endl;
50 | 
51 |     //shared_ptr很好的消除了显式的delete调用
52 |     //boost提供了一个自由工厂函数make_shared<T>()，用来显式的消除new调用
53 |     //make_shared 和 shared_ptr配合使用，你的代码中将不再需要new和delete
54 |     boost::shared_ptr<Base> sp = boost::make_shared<Base>("Base 1");
55 |     sp->toString();
56 | 
57 |     boost::shared_ptr<Base> sp1 = boost::make_shared<SubClass>("SubClass 1");
58 |     sp1->toString();
59 | 
60 |     //make_shared 比直接创建shared_ptr快，它仅仅分配一次内存，消除了shared_ptr构造时的开销
61 |     //time: sp2 > sp3
62 |     boost::shared_ptr<SubClass> sp2 = boost::shared_ptr<SubClass>(new SubClass("SubClass 2"));
63 |     boost::shared_ptr<SubClass> sp3 = boost::make_shared<SubClass>("SubClass 3");
64 | 
65 |     //make_shared limited your to a maximux of 9 arguments
66 |     boost::shared_ptr<SubClass> sp4 = boost::make_shared<SubClass>("SubClass 4", 4);
67 | 
68 |     sp2->toString();
69 |     sp3->toString();
70 | 
71 | 
72 |     return 0;
73 | }
74 | 
75 | 


--------------------------------------------------------------------------------
/property_tree.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * boost::property_tree tutorial
 3 |  *
 4 |  * zdd / zddhub@gmail.com
 5 |  * https://github.com/zddhub/boost_tutorial
 6 |  */
 7 | 
 8 | #include <iostream>
 9 | #include <string>
10 | using namespace std;
11 | 
12 | #include <boost/property_tree/ptree.hpp>
13 | #include <boost/property_tree/json_parser.hpp>
14 | 
15 | typedef boost::property_tree::ptree ptree;
16 | 
17 | //create JSON file
18 | void write_json(const string& filename) {
19 | 
20 |     ptree boost_tutorial;
21 |     boost_tutorial.put("name", "boost_tutorial");
22 | 
23 |     ptree author;
24 |     author.put("name", "zdd");
25 |     author.put("email", "zddhub@gmail.com");
26 |     author.put("website", "zddhub.com");
27 |     boost_tutorial.put_child("author", author);
28 | 
29 |     ptree content;
30 |     content.push_back(std::make_pair("chapter1", "boost::thread"));
31 |     content.push_back(std::make_pair("chapter2", "smart pointer"));
32 |     content.push_back(std::make_pair("chapter3", "boost::property_tree"));
33 | 
34 |     //if key == null, is array, else is object
35 |     ptree array;
36 |     array.push_back(std::make_pair("", "boost::scoped_ptr"));
37 |     array.push_back(std::make_pair("", "boost::shared_ptr"));
38 |     array.push_back(std::make_pair("", "boost::weak_ptr"));
39 |     content.put_child("chapter2", array);
40 | 
41 |     boost_tutorial.put_child("content", content);
42 | 
43 |     ostringstream os;
44 |     boost::property_tree::write_json(os, boost_tutorial);
45 |     cout << "JSON file: " <<endl;
46 |     cout << os.str() <<endl;
47 | 
48 |     //write to file
49 |     boost::property_tree::write_json(filename, boost_tutorial);
50 | }
51 | 
52 | //parser JSON file
53 | void read_json(const string& filename) {
54 | 
55 |     ptree boost_tutorial;
56 |     boost::property_tree::read_json(filename, boost_tutorial);
57 | 
58 |     cout << "name:" << boost_tutorial.get<string>("name")<<endl;
59 | 
60 |     ptree author = boost_tutorial.get_child("author");
61 |     cout << "name:" << author.get<string>("name")<<endl;
62 |     cout << "email:" << author.get<string>("email")<<endl;
63 |     cout << "website:" << author.get<string>("website")<<endl;
64 | 
65 |     ptree content = boost_tutorial.get_child("content");
66 |     cout << "chapter1:" << content.get<string>("chapter1")<<endl;
67 |     cout << "chapter2:" << content.get<string>("chapter2")<<endl;
68 | 
69 |     ptree array = content.get_child("chapter2");
70 |     for(ptree::iterator it = array.begin(); it != array.end(); ++it) {
71 |         //key: it->first.data(), value: it->second.data().
72 |         //cout << " " << it->first.data()<<endl; //first is ""
73 |         cout << "  " << it->second.get<string>("")<<endl;
74 |         // cout << "\t" << it->second.data()<<endl; // ==
75 |     }
76 | 
77 |     cout << "chapter3:" << content.get<string>("chapter3")<<endl;
78 | }
79 | 
80 | int main()
81 | {
82 |     cout << "property tree: " << endl;
83 |     cout << "parser JSON file as a example." <<endl;
84 | 
85 |     string filename = "boost_toturial.json";
86 |     write_json(filename);
87 | 
88 |     read_json(filename);
89 | 
90 |     return 0;
91 | }
92 | 
93 | 


--------------------------------------------------------------------------------
/smart_pointer.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * boost smart pointer tutorial
 3 |  *
 4 |  * zdd / zddhub@gmail.com
 5 |  * https://github.com/zddhub/boost_tutorial
 6 |  */
 7 | 
 8 | #include <string>
 9 | #include <iostream>
10 | using namespace std;
11 | 
12 | #include <boost/scoped_ptr.hpp>
13 | #include <boost/shared_ptr.hpp>
14 | #include <boost/weak_ptr.hpp>
15 | 
16 | class Object {
17 | public:
18 |     Object() {
19 |         cout << "Object constructor" <<endl;
20 |     }
21 | 
22 |     ~Object() {
23 |         cout << "Object destroy" <<endl;
24 |     }
25 | 
26 |     void do_something() {
27 |         cout << "do something ... " <<endl;
28 |     }
29 | };
30 | 
31 | int main()
32 | {
33 |     cout << "smart pointer:"
34 |             "\n\t(boost::weak_ptr, boost::shared_ptr, boost::scoped_ptr)" << endl;
35 |     /*
36 |      * Boost智能指针: 使用引用计数器实现
37 |      */
38 | 
39 |     //#: scoped_ptr: 在离开作用域后对象会被自动释放
40 |     //  scoped_ptr使用的限制：
41 |     //    1、不能转换所有权，不能作为函数返回值
42 |     //    2、不能共享所有权，不能用于stl容器
43 |     //    3、不能管理数组
44 |     {
45 |         boost::scoped_ptr<Object> s_ptr(new Object());
46 |         s_ptr->do_something();
47 |     }
48 | 
49 |     //#: shared_ptr: (强引用)可以共享所有权
50 |     /*
51 |      * boost::shared_ptr的使用规则：
52 |      * 1、避免对shared_ptr所管理的对象直接了进行内存管理操作
53 |      * 2、不能自动管理循环引用
54 |      * 3、不要构造一个临时的shared_ptr作为函数的参数
55 |      *    如：错误的用法: fun(boost:;shared_ptr<Object>(new Object()), g());
56 |      *    正确的用法如下：
57 |      *     boost:;shared_ptr<Object> sp(new Object());
58 |      *     fun(sp, g());
59 |      */
60 |     boost::shared_ptr<Object> sp1(new Object());
61 |     cout << "Ref count: " << sp1.use_count() <<endl;
62 | 
63 |     boost::shared_ptr<Object> sp2 = sp1;
64 |     cout << "Ref count: " << sp2.use_count() <<endl;
65 | 
66 |     sp1.reset();
67 |     cout << "Ref count: " << sp1.use_count() <<endl;
68 |     cout << "Ref count: " << sp2.use_count() <<endl;
69 | 
70 |     sp2.reset();
71 |     cout << "Ref count: " << sp1.use_count() <<endl;
72 |     cout << "Ref count: " << sp2.use_count() <<endl;
73 | 
74 |     //#: weak_ptr: (弱引用) 不改变计数器
75 |     boost::shared_ptr<Object> sp(new Object());
76 |     boost::weak_ptr<Object> wp(sp);
77 |     cout << "Ref count: " << sp.use_count() <<endl;
78 |     cout << "Ref count: " << wp.use_count() <<endl;
79 |     return 0;
80 | }
81 | 
82 | 


--------------------------------------------------------------------------------
/thread.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * boost::thread tutorial
  3 |  *
  4 |  * zdd / zddhub@gmail.com
  5 |  * https://github.com/zddhub/boost_tutorial
  6 |  */
  7 | 
  8 | #include <iostream>
  9 | #include <string>
 10 | 
 11 | using namespace std;
 12 | 
 13 | #include <boost/thread.hpp>
 14 | 
 15 | //#1
 16 | void run()
 17 | {
 18 |     cout << "Method #1" <<endl;
 19 | }
 20 | 
 21 | //#2
 22 | boost::mutex mutex;
 23 | class Count {
 24 |     int _id;
 25 | public:
 26 |     Count(int id):_id(id) {}
 27 |     void operator ()() {
 28 |         for(int i = 0; i < 10; i++) {
 29 |             boost::mutex::scoped_lock lock(mutex);
 30 |             cout << "Count id:" << _id << " " << i <<endl;
 31 |         }
 32 |     }
 33 | };
 34 | 
 35 | //#3
 36 | class InnerThread {
 37 | public:
 38 |     static void run() {
 39 |         cout << "class inner thread: run and start must be static." <<endl;
 40 |     }
 41 | 
 42 |     static void start() {
 43 |         boost::thread thread(run);
 44 |         thread.join();
 45 |     }
 46 | };
 47 | 
 48 | class InnerThread2 {
 49 | public:
 50 |     void run() {
 51 |         cout << "class inner thread: use boost::bind" <<endl;
 52 |     }
 53 | 
 54 |     void start() {
 55 |         boost::function0<void> f = boost::bind(&InnerThread2::run, this);
 56 |         boost::thread thread(f);
 57 |         thread.join();
 58 |     }
 59 | };
 60 | 
 61 | //#4
 62 | class SingletonThread {
 63 | public:
 64 |     void run() {
 65 |         cout << "Singleton thread" <<endl;
 66 |     }
 67 | 
 68 |     void start() {
 69 |         boost::function0<void> f = boost::bind(&SingletonThread::run, SingletonThread::getInstance());
 70 |         boost::thread thread(f);
 71 |         thread.join();
 72 |     }
 73 | 
 74 |     static SingletonThread* getInstance() {
 75 |         if(!_instance) {
 76 |             _instance = new SingletonThread;
 77 |         }
 78 |         return _instance;
 79 |     }
 80 | private:
 81 |     SingletonThread() {}
 82 |     static SingletonThread* _instance;
 83 | };
 84 | SingletonThread* SingletonThread::_instance = 0;
 85 | 
 86 | //#5
 87 | class Class {
 88 | public:
 89 |     void run(const std::string& str) {
 90 |         cout <<str <<endl;
 91 |     }
 92 | 
 93 |     int add(int x, int y) {
 94 |         cout << "x+y=" <<x+y<<endl;
 95 |         return x+y;
 96 |     }
 97 | };
 98 | 
 99 | //#6
100 | int add(int x, int y) {
101 |     return x+y;
102 | }
103 | 
104 | int main()
105 | {
106 |     cout << "boost::thread: " << endl;
107 | 
108 |     //#1: Simple method
109 |     boost::thread th1(&run);
110 |     cout << "main thread " <<endl;
111 |     th1.join();
112 | 
113 |     //#2: Through class operator() method
114 |     boost::thread th21(Count(1));
115 |     boost::thread th22(Count(2));
116 |     th21.join();
117 |     th22.join();
118 | 
119 |     //#3: Class inner thread : static method
120 |     InnerThread ith;
121 |     ith.start();
122 |     InnerThread::start();
123 | 
124 |     InnerThread2 ith2;
125 |     ith2.start();
126 | 
127 |     //#4: Singleton thread
128 |     SingletonThread *st = SingletonThread::getInstance();
129 |     st->start();
130 | 
131 |     //#5: Outer class thread
132 |     Class cls;
133 |     boost::thread outer_thread(boost::bind(&Class::run, &cls, "Outer thread"));
134 |     outer_thread.join();
135 | 
136 |     //#6: Complex method: with return value
137 |     boost::function2<int, int, int> f = &add;
138 |     boost::packaged_task<int> pt(boost::bind<int>(f, 1, 2));
139 |     boost::unique_future<int> fi = pt.get_future();
140 |     boost::thread th2(boost::move(pt));
141 |     fi.wait();
142 |     th2.join();
143 |     cout <<"x+y="<<fi.get()<<endl;
144 | 
145 |     boost::packaged_task<int> pt_cls(boost::bind<int>(&Class::add, &cls, 1, 2));
146 |     boost::unique_future<int> fi_cls = pt_cls.get_future();
147 |     boost::thread th2_cls(boost::move(pt_cls));
148 |     fi_cls.wait();
149 |     th2_cls.join();
150 |     cout <<"x+y="<<fi_cls.get()<<endl;
151 | 
152 |     /*
153 |      *related functions
154 |      *  boost::thread
155 |      *  boost::function
156 |      *  boost::bind
157 |      */
158 | 
159 |     //some usages:
160 |     int x = 1, y =2;
161 |     cout << "x+y=" <<boost::bind<int>(f, _1, _2)(x,y)<<endl;
162 | 
163 | 
164 |     return 0;
165 | }
166 | 
167 | 


--------------------------------------------------------------------------------