BOOST学习笔记

BOOST学习笔记

1 tool

#pragma once
#include <vector>

#include "boost/noncopyable.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/serialization/singleton.hpp"

#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
using namespace boost;
using namespace std;
using namespace boost::serialization;
class CNo_copy_class : public noncopyable
{
public:
    CNo_copy_class() : a(11){}
    int a;
};

void no_copy_test()
{
    CNo_copy_class c1;
    //CNo_copy_class c2(c1);
}

vector<int> func()
{
    return vector<int>(10, 2);
}

void typeof_auto_test()
{
    //decltype(20*3.0) x1 = 20*3.0;
    BOOST_TYPEOF(20*3.0) x2 = 20*3.0;

    BOOST_AUTO(&a, new double[20]);
    BOOST_AUTO(p, make_pair(1, "string"));

    BOOST_AUTO(v ,func());

    //注册自定义类型
    BOOST_TYPEOF_REGISTER_TYPE(CNo_copy_class)
    BOOST_AUTO( pdef, new CNo_copy_class());
    cout<< typeid(pdef).name() << endl;
}

typedef singleton<CNo_copy_class> origin;

void singleton_test()
{
    cout << origin::get_const_instance().a << endl;
    //origin::get_const_instance().a = 5;
    cout << origin::get_mutable_instance().a << endl;
    origin::get_mutable_instance().a = 6;
    cout << origin::get_const_instance().a << endl;
}

 

2 file

#pragma once
#include "boost/filesystem.hpp"

using namespace boost;
using namespace std;

void path_string_opt_test()
{
    filesystem::path p1;
    assert(p1.empty());

    filesystem::path p2("c:/user/local/include/xx.js");
    cout << p2.string() << endl;

    if (p2.has_stem())        //xx,文件名，无后缀
    {
        cout << p2.stem() << endl;
    }
    if (p2.has_extension())    //.js,文件名后缀
    {
        cout << p2.extension() << endl;
    }
    if (p2.has_filename())    //xx.js，文件全名，有后缀
    {
        cout << p2.filename() << endl;
    }
    if (p2.has_parent_path())    //c:/user/local/include，除去文件名的路径
    {
        cout << p2.parent_path() << endl;
    }

    if (p2.has_root_name())        //windows路径为c:
    {
        cout << p2.root_name() << endl;
    }
    if (p2.has_root_directory())    //windows路径为/
    {
        cout << p2.root_directory() << endl;
    }
    if (p2.has_root_path())        //windows路径为c:/
    {
        cout << p2.root_path() << endl;
    }

    //修改文件路径
    cout << p2.replace_extension("hxx") << endl;        //修改扩展名，修改后为c:/user/local/include/xx
    cout << p2.replace_extension() << endl;        //修改扩展名，修改后为c:/user/local/include/xx
    cout << p2.remove_filename() << endl;        //移除文件名，修改后为c:/user/local/include
}

void GetModulePath()
{
    char szPath[MAX_PATH];
    GetModuleFileName( NULL, szPath, MAX_PATH );
    cout << szPath << endl;
    //输出：p:\workspace\proj\test\boost_test\build\src\Debug\BOOST_TEST.exe

    cout << boost::filesystem::initial_path<filesystem::path>().string() <<endl;
    //输出：p:\workspace\proj\test\boost_test\build\src
    
    //
    cout << boost::filesystem::current_path().string() << endl;
}

void directory_test()
{
    boost::filesystem::path p1(boost::filesystem::current_path());
    p1.append("123\\456");
    //循环创建目录
    if (!boost::filesystem::exists(p1))
    {
        boost::filesystem::create_directories(p1);
    }
    //递归删除最底层目录
    if (boost::filesystem::exists(p1))
    {
        boost::filesystem::remove_all(p1);
    }
}

 

3 container

#pragma once
#include <map>
#include <vector>
#include "boost/array.hpp"
#include "boost/any.hpp"
#include "boost/foreach.hpp"

using namespace boost;
using namespace std;

void array_test()
{
    array<int, 10> ar = {0,1};
    array<string, 10> ars = {"123"};
    for (int i=0; i<10; i++)
    {
        cout << ars[i] << endl;
    }
}

void any_test()
{
    any a(10);
    int n = any_cast<int>(a);

    any_cast<int&>(a) = 20;
}

void foreach_test()
{
    int a[] = {0, 1, 2, 3, 4, 5};
    vector<int> vec(a , a + 6);
    BOOST_FOREACH(int x, vec)
    {
        cout << x << endl;
    }
    BOOST_REVERSE_FOREACH(int x, vec)
    {
        cout << x << endl;
    }
}

 

4 smart_ptr

#pragma once
#include<iostream>
#include <vector>
#include "boost/smart_ptr.hpp"
using namespace boost;
using namespace std;

// 
void scoped_ptr_test()
{
    scoped_ptr<int> p(new int);
    if (p)
    {
        *p = 100;
        cout << *p << endl;
    }
    p.reset();
}

void scoped_array_test()
{
    scoped_array<int> p(new int[100]);
    fill_n(&p[0], 100, 5);
    p[10] = p[20] + p[30];
}

void shared_ptr_test()
{
    shared_ptr<int> p(new int(100));
    *p = 5;
    //shared_ptr< vector<int> > mp = make_shared< vector<int> >(100,5);

    //shardptr可以指定析构函数

}

void shared_array_test()
{
    shared_array<int> p(new int[100]);
    shared_array<int> p2 = p;
    p[0] = 10;
    assert( p2[0] == 10);
}

void weak_ptr_test()
{
    shared_ptr<int> sp(new int(100));
    assert(sp.use_count() == 1);

    weak_ptr<int> wp(sp);
    assert(wp.use_count() == 1);

    if (!wp.expired())
    {
        shared_ptr<int> sp2 = wp.lock();
        *sp2 = 100;
        assert(wp.use_count() == 2 );
    }
    assert(wp.use_count() == 1);
    sp.reset();
    assert(wp.expired());
    assert(!wp.lock());
}

 

5 function

#pragma once
#include "boost/utility/result_of.hpp"
#include "boost/any.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"

using namespace boost;
using namespace std;

template<typename T, typename T1>
typename result_of<T(T1)>::type call_func(T t, T1 t1)
{
    return t(t1);
}

void result_of_test()
{
    typedef double (*Func)(double);
    Func func = sqrt;

    result_of<Func(double)>::type x = func(5.0);
    cout << typeid(x).name() << endl;

    any x2 = call_func(func, 5.0);
    cout << typeid(boost::any_cast<double>(x2)).name() << endl;
}

int f(int a, int b)
{
    return a + b;
}

int g(int a, int b, int c)
{
    return a + b*c;
}

void bind_test()
{
    cout << bind(f, 1, 2)() << endl;
    int x = 1, y = 2, z = 3;
    cout << bind(f, _1, 9)(x) << endl;    //使用占位符
    cout << bind(g, _3, _2, _2)(x, y, z) << endl;    //使用占位符，乱序
    
    //绑定成员函数
    class demo
    {
    public:
        int f(int a, int b)
        {
            cout << a << " "<< b << endl;
            return a + b;
        }
    } a;
    demo& b = a;
    demo* p = &a;
    cout << bind(&demo::f, a, _1, 10)(10) << endl;
    cout << bind(&demo::f, b, _2, _1)(10, 20) << endl;
    cout << bind(&demo::f, p, _1, _2)(10, 20) << endl;

    //算法容器
    class point
    {
    public:
        int x,y;
        point() : x(0), y(1) {}
        void print()
        {
            cout << x << " " << y << endl;
        }
    };
    std::vector<point> v(10);
    for_each(v.begin(), v.end(), bind(&point::print, _1));    //成员函数_1表示函数指针
}

void function_test()
{
    boost::function<int(int, int)> func = f;
    if (func)
    {
        cout << func(10, 20) << endl;
    }
    func.clear();

    boost::function<int(int)> func1 = boost::bind(f, _1, 20);
    if (func1)
    {
        cout << func1(10) << endl;
    }
}

 

6 pool

#pragma once
#include <vector>
#include "boost/pool/pool.hpp"
#include "boost/pool/object_pool.hpp"
#include "boost/pool/singleton_pool.hpp"
#include "boost/pool/pool_alloc.hpp"
using namespace boost;
using namespace std;

class demo_class
{
public:
    int a,b,c;
    demo_class(int x =1 ,int y=2, int z=3):a(x), b(y), c(z)
    {
    }
};
typedef singleton_pool<demo_class , sizeof(demo_class)> spl;

void pool_test()
{
    pool<> pl(sizeof(int));
    int* p = static_cast<int*>(pl.ordered_malloc());
    assert(pl.is_from(p));

    pl.ordered_free(p);

    for (int i=0; i<10; i++)
    {
        pl.ordered_malloc(10);
    }
}


void object_pool_test()
{
    object_pool<demo_class> pl;
    demo_class *p = pl.malloc();
    assert(pl.is_from(p));

    assert(p->a != 1 || p->b != 2 || p->c != 3);
    
    p =pl.construct(7, 8, 9);
    assert(p->a == 7);

    object_pool<std::string> pls;
    for (int i=0; i<10 ;i++)
    {
        std::string *ps = pls.construct("hello");
        cout<< ps->c_str() << endl;
    }
}

void singleton_pool_test()
{
    demo_class* p = (demo_class*)spl::malloc();
    assert(spl::is_from(p));
    spl::release_memory();
}

void pool_alloc_test()
{
    std::vector<int, pool_allocator<int> > v;
    v.push_back(10);
}

 

7 thread

#pragma once
#include <stack>
#include <vector>
#include "boost/thread.hpp"
#include "boost/foreach.hpp"

using namespace boost;
using namespace std;

boost::mutex io_mu_1;
void time_test()
{
    this_thread::sleep_for(chrono::seconds(20));

    this_thread::sleep_until(chrono::system_clock::now() + chrono::seconds(4));
}

void to_interrupt(int& x, const string& str)
try
{
    for (int i=0; i<5; i++)
    {
        boost::mutex::scoped_lock(io_mu_1);
        cout << str << ++x << std::endl;
        //this_thread::sleep_for(chrono::seconds(1));
        {
            //自动中断点

        }
        this_thread::interruption_point();
    }
}
catch(...)
{
    cout << "thread_interrupted" << std::endl;
};

void thread_test()
{
    int x = 0;
    boost::thread t(to_interrupt, boost::ref(x), "hello");
    this_thread::sleep_for(chrono::seconds(3));

    t.interrupt();
    assert(t.interruption_requested());

    t.join();
}

//测试条件变量
class buffer
{
public:
    buffer(int n) : un_read(0),capacity(n)
    {
    }
    void put(int x)
    {
        {
            boost::mutex::scoped_lock lock(mu);
            while (if_full())
            {
                {
                    //boost::mutex::scoped_lock lock2(io_mu_1);
                    cout<< "full waiting\n";
                }
                cond_put.wait(mu);
            }
        }
        stk.push(x);
        ++un_read;
        cond_get.notify_one();
    }
    void get(int* x)
    {
        {
            boost::mutex::scoped_lock lock(mu);
            while (is_empty())
            {
                {
                    //boost::mutex::scoped_lock lock2(io_mu_1);
                    cout<< "empty waiting\n";
                }
                cond_get.wait(mu);
            }
        }
        --un_read;
        *x = stk.top();
        stk.pop();
        cond_put.notify_one();
    }
private:
    boost::mutex mu;
    boost::condition_variable_any cond_put;
    boost::condition_variable_any cond_get;
    std::stack<int> stk;
    int un_read,capacity;
    bool if_full()
    {
        return un_read == capacity;
    }
    bool is_empty()
    {
        return un_read == 0;
    }
}    buf(5);

void producer(int n)
{
    for (int i=0; i< n; i++)
    {
        {
            //boost::mutex::scoped_lock lock(io_mu_1);
            cout << "put " << i << std::endl;
        }
        buf.put(i);
    }
}

void consumer(int n)
{
    int x;
    for (int i=0; i< n; i++)
    {
        buf.get(&x);
        //boost::mutex::scoped_lock lock(io_mu_1);
        cout << "get " << x << std::endl;
    }
}

void condition_test()
{
    boost::thread t1(producer, 20);
    boost::thread t2(consumer, 10);
    boost::thread t3(consumer, 10);

    t1.join();
    t2.join();
    t3.join();

    boost::this_thread::sleep_for(boost::chrono::seconds(30));
}

//共享互斥量
class rw_data
{
public:
    rw_data() : m_x(0) {}
    void write()
    {
        unique_lock<shared_mutex> ul(rw_mu);
        ++m_x;
    }
    void read(int* x)
    {
        shared_lock<shared_mutex> sl(rw_mu);
        *x = m_x;
    }
private:
    int m_x;
    shared_mutex rw_mu;
};

void writer(rw_data& d)
{
    for (int i=0; i< 20; i++)
    {
        this_thread::sleep_for(chrono::milliseconds(10));
        d.write();
    }
}

void reader(rw_data& d)
{
    int x;
    for (int i=0; i< 20; i++)
    {
        this_thread::sleep_for(chrono::milliseconds(5));
        d.read(&x);
        cout << this_thread::get_id()<< " read: "<<x<<std::endl;
    }
}

void shared_mutex_test()
{
    rw_data d;
    boost::thread_group pool;
    pool.create_thread(bind(writer, boost::ref(d)));
    pool.create_thread(bind(writer, boost::ref(d)));

    pool.create_thread(bind(reader, boost::ref(d)));
    pool.create_thread(bind(reader, boost::ref(d)));
    pool.create_thread(bind(reader, boost::ref(d)));
    pool.create_thread(bind(reader, boost::ref(d)));

    pool.join_all();
    this_thread::sleep_for(chrono::seconds(3000));
}

//future,线程返回执行结果
int fab(int n)
{
    if (n == 0 || n == 1)
    {
        return 1;
    }
    return fab(n-1) + fab(n-2);
}

void future_test()
{
    //单个future
    boost::packaged_task<int> pt(bind(fab, 10));
    boost::BOOST_THREAD_FUTURE<int> f = pt.get_future();

    boost::thread(boost::move(pt));
    f.wait();

    cout << f.get() << endl;
    this_thread::sleep_for(chrono::seconds());

    //多个future协调，wait for all/any
    typedef boost::packaged_task<int> pti_t;
    typedef boost::BOOST_THREAD_FUTURE<int> fi_t;

    boost::array<pti_t, 5> ap;
    boost::array<fi_t, 5> af;

    for (int i = 0; i<5;i++)
    {
        ap[i] = pti_t(bind(fab, i+ 10));
        af[i] = ap[i].get_future();
        boost::thread(boost::move(ap[i]));
    }

    boost::wait_for_all(af.begin(), af.end());
    BOOST_FOREACH(fi_t& f, af)
    {
        cout << f.get() << endl;
    }

    for (int i = 0; i<5;i++)
    {
        boost::thread(boost::move(ap[i]));
    }

    boost::wait_for_any(af.begin(), af.end());
    BOOST_FOREACH(fi_t& f, af)
    {
        if (f.is_ready() && f.has_value())
        {
            cout << f.get() << endl;
        }
    }

    this_thread::sleep_for(chrono::seconds(3000));
}

//线程本地存储
boost::thread_specific_ptr<int> pi;        //本地线程存储一个int

void printing()
{
    pi.reset(new int(1));

    ++(*pi);
    cout << this_thread::get_id() << " thread, value = " << *pi << endl;
}
void tls_test()
{
    (boost::thread(bind(printing)));
    (boost::thread(bind(printing)));

    this_thread::sleep_for(chrono::seconds(2000));
}

 

8 asio

8.1 server

#pragma once
#include <vector>

#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/smart_ptr.hpp"

using namespace boost;
using namespace boost::asio;
using namespace std;

boost::asio::io_service g_ios;    //所有的asio都要有个ios

//同步定时器
void deadlime_timer_sync_test()
{
    boost::asio::deadline_timer t(g_ios, posix_time::seconds(2));
    cout << t.expires_at() << endl;        //终止绝对时间
    t.wait();
}

//异步定时器
//异步定时器回调标准格式
void print(system::error_code x)
{
    cout << "deadline time\n";
}

void deadlime_timer_async_test()
{
    boost::asio::deadline_timer t(g_ios, posix_time::seconds(20));
    cout << t.expires_at() << endl;        //终止绝对时间
    t.async_wait(print);
    cout << "deadline time\n";
    g_ios.run();
}

//tcp
void tcp_address_test()
{
    boost::asio::ip::address addr;
    //addr = addr.from_string("ab.12.23.34");
    //assert(addr.is_v6());
    addr = addr.from_string("127.0.0.1");
    assert(addr.is_v4());
    cout << addr.to_string() << endl;
    ip::tcp::endpoint ep(addr, 8866);
    assert(ep.address() == addr);
    assert(ep.port() == 8866);
}

//服务端
void server_test()
{
    ip::tcp::acceptor acceptor(g_ios, 
        ip::tcp::endpoint(ip::tcp::v4(), 8866));

    while (1)
    {
        ip::tcp::socket sock(g_ios);
        acceptor.accept(sock);

        cout << "recv client: " << sock.remote_endpoint().address() << endl;
        sock.write_some(boost::asio::buffer(std::string("hello")));        //发送数据
    }
}

//异步
typedef boost::shared_ptr<ip::tcp::socket> sock_ptr;
class server
{
public:
    server() : acceptor(g_ios, 
        ip::tcp::endpoint(ip::tcp::v4(), 8866))
    {
        start();
    }
    void start()
    {
        sock_ptr sock(new ip::tcp::socket(g_ios));
        acceptor.async_accept(*sock, 
            bind(&server::accept_handler, this, asio::placeholders::error, sock));
    }
    void accept_handler(const system::error_code& ec, sock_ptr sock)
    {
        if (ec)
        {
            return;
        }
        cout << sock->remote_endpoint().address() << endl;
        sock->async_write_some(boost::asio::buffer(std::string("hello")), 
            bind(&server::write_handler, this, asio::placeholders::error));
        start();
    }
    void write_handler(const system::error_code& ec)
    {    
        cout << "send msg ok\n";
    }
private:
    ip::tcp::acceptor acceptor;
};

void async_server_test()
{
    server ser;
    g_ios.run();
}

void DNS_test()
{
    ip::tcp::socket sock(g_ios);
    ip::tcp::resolver rlv(sock.get_io_service());

    ip::tcp::resolver::query qry("www.baidu.com", lexical_cast<std::string>(80));
    ip::tcp::resolver::iterator iter = rlv.resolve(qry);
    ip::tcp::resolver::iterator end;

    system::error_code ec = error::host_not_found;
    for ( ; ec && iter != end; ++iter)
    {
        sock.close();
        sock.connect(*iter, ec);
    }
    if ( ec )
    {
        cout << "can't connect\n";
    }
}

 

8.2 client

#pragma once
#include <vector>

#include "boost/thread.hpp"
#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"

using namespace boost;
using namespace boost::asio;
using namespace std;

boost::asio::io_service g_ios;    //所有的asio都要有个ios


//客户端
void client_test()
{
    while (1)
    {
        ip::tcp::socket sock(g_ios);
        ip::tcp::endpoint ep(ip::address::from_string("127.0.0.1"), 8866);
        sock.connect(ep);

        std::string str;
        str.resize(100, 0);
        sock.read_some(buffer(str));
        cout << "receive from " << sock.remote_endpoint().address() << endl;
        cout << "content : " << str << endl;

        sock.close();

        boost::this_thread::sleep_for(boost::chrono::seconds(5));
    }
    
}

//异步通信客户端
typedef boost::shared_ptr<ip::tcp::socket> sock_ptr;
typedef boost::shared_ptr<std::string> str_ptr;
class client
{
public:
    client() : ep(ip::address::from_string("127.0.0.1"), 8866)
    {
        start();
    }
    void start()
    {
        sock_ptr sock(new ip::tcp::socket(g_ios));
        sock->async_connect(ep,
            bind(&client::connect_handler, this, asio::placeholders::error, sock));
    }
    void connect_handler(const system::error_code& ec, 
        sock_ptr sock)
    {
        if (ec)
        {
            return;
        }
        cout << "sock connect " << sock->remote_endpoint().address() << endl;
        str_ptr pstr(new std::string(100,0));
        sock->async_read_some(asio::buffer(*pstr),
            bind(&client::read_hander, this, asio::placeholders::error, pstr));
        start();
    }
    virtual void read_hander(const system::error_code& ec,
        shared_ptr<std::string> str)
    {
        cout <<"recv msg: " <<str << endl;
    }
protected:
    ip::tcp::endpoint ep;
};

class client11 : public client
{
    virtual void read_hander(const system::error_code& ec,
        shared_ptr<std::string> str)
    {
        cout <<"child recv msg: " <<str << endl;
    }
};

void async_client_test()
{
    client11 cli;
    g_ios.run();
}

 9 源码

　　1-8的源码地址：https://download.csdn.net/download/honggangqianren/10538015