boost 使用列子

#include <boost/lexical_cast.hpp>
void test_lexical_cast()
{
int number = 123;
string str = "456";
try
{
int tmp1 = boost::lexical_cast<int>(str);
string tmp2 = boost::lexical_cast<string>(number);
cout<<tmp1<<endl;
cout<<tmp2<<endl;
}catch(boost::bad_lexical_cast& ex)
{
cout<<ex.what()<<endl;
}
}

//==============================================================================
#include <boost/format.hpp>
void test_format()
{
int number = 123;
string str = "456";
cout<<boost::format("%1%:%2%") % number % str<<endl;
cout<<boost::format("%d:%s") % number % str<<endl;
cout<<boost::format("%|05d|:%|s|") % number % str<<endl;
cout<<boost::format("%1%:%|8t|%2%") % number % str<<endl;
}

//==============================================================================
#include <boost/algorithm/string.hpp>
void test_string_algo()
{
string str = " this is a test!";
cout<<boost::to_upper_copy(str)<<endl;
cout<<boost::trim_left_copy(str)<<endl;
string num = "0853";
boost::trim_left_if(num,boost::is_any_of("0"));
cout<<num<<endl;
if(boost::find_first(str, "is"))
{
cout<<"'is' in "<<str<<endl;
}
boost::replace_first(str, "this", "that");
cout<<str<<endl;
boost::erase_all(str, " ");
cout<<str<<endl;
}

//==============================================================================
#include <boost/tokenizer.hpp>
void test_tokenizer()
{
string str = "this is a test!";
boost::tokenizer<> tok(str);
for(boost::tokenizer<>::iterator it=tok.begin();it!=tok.end();++it)
{
cout<<*it<<endl;
}
boost::char_separator<char> sep(" ");
boost::tokenizer<boost::char_separator<char> > tok2(str, sep);
for(boost::tokenizer<boost::char_separator<char> >::iterator it=tok2.begin();it!=tok2.end();++it)
{
cout<<*it<<endl;
}
}

//==============================================================================
#include <boost/array.hpp>
void test_array()
{
boost::array<int,10> ai = {11,12,13};
for(boost::array<int,10>::iterator it=ai.begin();it!=ai.end();++it)
{
cout<<*it<<endl;
}
}

//==============================================================================
#include <boost/dynamic_bitset.hpp>
void test_dynamic_bitset()
{
cout<<endl<<">>>test_dynamic_bitset()"<<endl;
boost::dynamic_bitset<> db1(string("01000010"));
boost::dynamic_bitset<> db2(string("01000001"));
cout<<(db1 | db2)<<endl;
}

//==============================================================================
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
void test_unordered()
{
boost::unordered_set<int> us;
us.insert(1);
us.insert(2);
us.insert(5);
us.insert(25);
for(boost::unordered_set<int>::iterator it=us.begin();it!=us.end();++it)
{
cout<<*it<<endl;
}

boost::unordered_map<int,string> um;
um.insert(make_pair(1,"first"));
um.insert(make_pair(2,"second"));
um.insert(make_pair(5,"just"));
um.insert(make_pair(25,"soso"));
for(boost::unordered_map<int,string>::iterator it=um.begin();it!=um.end();++it)
{
cout<<it->first<<"-"<<it->second<<endl;
}
for(int i=0; i<um.bucket_count(); ++i)
{
cout<<"bucket["<<i<<"].size="<<um.bucket_size(i)<<endl;
}
}

//==============================================================================
#include <boost/bimap.hpp>
void test_bimap()
{
boost::bimap<int,string> bm;
bm.left.insert(make_pair(1,"first"));
bm.left.insert(make_pair(2,"second"));
bm.right.insert(make_pair("just",5));
bm.right.insert(make_pair("soso",25));
for(boost::bimap<int,string>::iterator it=bm.begin();it!=bm.end();++it)
{
cout<<"<"<<it->left<<","<<it->right<<">"<<endl;
}
for(boost::bimap<int,string>::left_iterator it=bm.left.begin();it!=bm.left.end();++it)
{
cout<<"left["<<it->first<<"]="<<it->second<<endl;
}
for(boost::bimap<int,string>::right_iterator it=bm.right.begin();it!=bm.right.end();++it)
{
cout<<"right["<<it->first<<"]="<<it->second<<endl;
}
}

//==============================================================================
#include <boost/assign.hpp>
void test_assign()
{
typedef boost::bimap<int,string> bm_t;
bm_t bm = boost::assign::list_of<bm_t::relation>(1,"just")(2,"soso");
for(bm_t::iterator it=bm.begin();it!=bm.end();++it)
{
cout<<"<"<<it->left<<","<<it->right<<">"<<endl;
}
}

//==============================================================================
#include <boost/circular_buffer.hpp>
void test_circular_buffer()
{
typedef boost::circular_buffer<int> cb_t;
cb_t cb = (boost::assign::list_of(1),2,3,4,5);
cb.push_back(6);
boost::assign::push_back(cb)(7),8,9;
for(cb_t::iterator it=cb.begin();it!=cb.end();++it)
{
cout<<*it<<endl;
}
}

//==============================================================================
#include <boost/tuple/tuple.hpp>
void test_tuple()
{
typedef boost::tuple<int,string> tp_t;
tp_t tp = boost::make_tuple(1,"just");
cout<<tp.get<0>()<<","<<tp.get<1>()<<endl;
}

//==============================================================================
#include <boost/any.hpp>
void test_any()
{
boost::any a(string("any_string"));
string str = boost::any_cast<string>(a);
cout<<str<<endl;

boost::array<boost::any,2> ar = {1,string("just")};
cout<<boost::any_cast<int>(ar[0])<<endl;
cout<<boost::any_cast<string>(ar[1])<<endl;
}

//==============================================================================
#include <boost/variant.hpp>
void test_variant()
{
typedef boost::variant<int,string> var_t;
var_t v1(123);
var_t v2(string("just"));
if(v2.type() == typeid(string))
{
cout<<"v2.type=string"<<endl;
}
}

//==============================================================================
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/property_tree/ini_parser.hpp>
#include <boost/property_tree/json_parser.hpp>
void test_property_tree()
{
boost::property_tree::ptree pt;
pt.put("conf.user", "just");
pt.put("conf.pass", "soso");
boost::property_tree::write_xml("conf.xml", pt);
boost::property_tree::write_ini("conf.ini", pt);
boost::property_tree::write_json("conf.json", pt);

boost::property_tree::read_xml("conf.xml", pt);
cout<<pt.get<string>("conf.user")<<endl;
cout<<pt.get<string>("conf.pass")<<endl;

boost::property_tree::ptree child = pt.get_child("conf");
for(boost::property_tree::ptree::iterator it = child.begin();
it != child.end(); ++it)
{
cout<<it->first<<"->"<<it->second.get_value<string>()<<endl;
}

try
{
boost::property_tree::read_xml("ex_conf.xml", pt);
cout<<"comment: "<<pt.get<string>("conf.<xmlcomment>")<<endl;
cout<<"attr: "<<pt.get<string>("conf.username.<xmlattr>.id")<<endl;
}catch(std::exception& e)
{
cout<<e.what()<<endl;
}
}

//==============================================================================
#include <boost/timer.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
void test_date_time()
{
boost::timer t;
cout<<"tim elapsed: "<<t.elapsed()<<endl;

typedef boost::gregorian::date date_t;
date_t d1(2012,2,16);
date_t d2 = boost::gregorian::from_string("2012-02-17");
date_t d3 = boost::gregorian::from_undelimited_string("20120218");
date_t d4 = d3 + boost::gregorian::days(1);
cout<<boost::gregorian::to_iso_string(d1)<<endl;
cout<<boost::gregorian::to_iso_extended_string(d2)<<endl;
cout<<"dayofweek: "<<d3.day_of_week()<<endl;

boost::gregorian::date_period dp(d1, d4);
cout<<dp.end()<<endl;

typedef boost::posix_time::ptime ptime_t;
ptime_t p1 = boost::posix_time::time_from_string("2012-02-17 12:30:00");
cout<<boost::posix_time::to_iso_extended_string(p1)<<endl;

boost::posix_time::time_period tp(p1, boost::posix_time::hours(8));
cout<<tp.end()<<endl;
}

//==============================================================================
#include <boost/filesystem.hpp>
void test_filesystem()
{
typedef boost::filesystem::path path_t;
path_t p("/home/lhw/code/BoostTest/main.cpp");
cout<<"string: "<<p.string()<<endl;
cout<<"filename: "<<p.filename()<<endl;
cout<<"extension: "<<p.extension()<<endl;
cout<<"file_size: "<<boost::filesystem::file_size(p)<<endl;
cout<<"is_dir: "<<boost::filesystem::is_directory(p)<<endl;
cout<<"exists: "<<boost::filesystem::exists(p)<<endl;

boost::filesystem::create_directory("./tmp");
boost::filesystem::copy_file(p, "./tmp/tmp.txt");
boost::filesystem::remove_all("./tmp");

typedef boost::filesystem::recursive_directory_iterator rdit_t;
rdit_t end;
for(rdit_t it("/home/lhw/code"); it!=end; ++it)
{
if(it.level()==1 && boost::filesystem::is_directory(*it))
{
it.no_push();
}
cout<<"level["<<it.level()<<"]"<<*it<<endl;
}
}

//==============================================================================
#include <boost/smart_ptr.hpp>
void test_smart_ptr()
{
typedef boost::shared_ptr<string> str_ptr;
str_ptr sp1(new string("just soso"));
cout<<*sp1<<",use_count: "<<sp1.use_count()<<endl;

typedef vector<boost::shared_ptr<string> > vec_str;
vec_str v;
str_ptr s1(new string("just"));
str_ptr s2(new string("soso"));
v.push_back(s1);
v.push_back(s2);
}

//==============================================================================
#include <boost/pool/pool.hpp>
#include <boost/pool/object_pool.hpp>
#include <boost/pool/singleton_pool.hpp>
struct pool_tag
{
int m_id;
pool_tag(int id)
{
m_id = id;
}
~pool_tag()
{
}
};
void test_pool()
{
typedef boost::singleton_pool<pool_tag, sizeof(int)> spool;
int *p1 = (int*)spool::malloc();
cout<<"is_form: "<<spool::is_from(p1)<<endl;
spool::free(p1);

boost::object_pool<pool_tag> opool;
pool_tag* p2 = opool.construct(25);
cout<<"m_id="<<p2->m_id<<endl;
opool.destroy(p2);
}

//==============================================================================
#include <boost/assign.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/ref.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
int sum(int a, int b)
{
return a+b;
};
struct square
{
void operator()(int& x)
{
x = x * x;
cout<<x<<",";
}

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

void print(int& x, int i)
{
cout<<x+i<<",";
}
};
void test_bind()
{
typedef int (*Func)(int,int);
Func func = sum;
boost::result_of<Func(int,int)>::type x = sum(2,3)+func(2,3);
cout<<"typename: "<<typeid(x).name()<<"("<<x<<")"<<endl;

vector<int> v = (boost::assign::list_of(1),2,3,4,5);
for_each(v.begin(), v.end(), square());
cout<<endl;

string s("just so so.");
cout<<boost::ref(s).get()<<endl;
cout<<boost::unwrap_ref(s)<<endl;

cout<<"bind: "<<boost::bind(sum,2,3)()<<endl;
cout<<"bind: "<<boost::bind(sum,_1,_2)(2,3)<<endl;
cout<<"bind: "<<boost::bind<int>(sum,2,3)()<<endl;

square sq;
cout<<"bind: "<<boost::bind(&square::sum, &sq, 2, 3)()<<endl;

for_each(v.begin(), v.end(),
boost::bind(&square::print, &sq, _1, 1));
cout<<endl;

pair<int,string> p(123, "just");
cout<<boost::bind(&pair<int,string>::second, p)()<<endl;

boost::function<int(int,int)> f = sum;
if(f)
{
cout<<"bind func: "<<f(2,3)<<endl;
f = 0;
}

f = boost::bind(&square::sum, boost::ref(sq), _1, _2);
cout<<"bind class func: "<<f(2,3)<<endl;
}

//==============================================================================
#include <boost/regex.hpp>
void test_regex()
{
boost::smatch what;
string str1 = "just192.168.7.250soso";
boost::regex exp1("just.*soso");
boost::regex exp2("(\\d+\\.)(\\d+\\.)(\\d+\\.)(\\d+)");
boost::regex exp3("\\d+");
if(boost::regex_match(str1, exp1))
{
cout<<"match."<<endl;
}

if(boost::regex_search(str1, what, exp2))
{
cout<<"0: "<<what[0]<<endl;
cout<<"1: "<<what[1]<<endl;
cout<<"2: "<<what[2]<<endl;
cout<<"3: "<<what[3]<<endl;
cout<<"4: "<<what[4]<<endl;
}

string::const_iterator start = str1.begin();
string::const_iterator end = str1.end();
while(boost::regex_search(start, end, what, exp3))
{
start = what[0].second;
string msg(what[0].first, what[0].second);
cout<<msg<<endl;
}

string tmp = boost::regex_replace(str1, exp3, "*");
cout<<"after replace: "<<tmp<<endl;
}

//==============================================================================
#include <boost/thread.hpp>
queue<int> g_qu;
boost::mutex g_mu;
boost::condition_variable_any cond_g;
boost::condition_variable_any cond_p;
void myThread(boost::mutex& mu, int n)
{
try
{
boost::mutex::scoped_lock lock(mu);
for(int i=1; i<4; ++i)
{
cout<<"<"<<n<<">thread running "<<i<<endl;
boost::this_thread::sleep(boost::posix_time::seconds(1));
}
}catch(boost::thread_interrupted& ex)
{
cout<<"<"<<n<<">interrupted."<<endl;
}
}
bool isNotFull()
{
return (g_qu.size()<3);
}
bool isNotEmpty()
{
return (!g_qu.empty());
}
void GetThread(int id)
{
for(int i=0; i<5; ++i)
{
{
boost::mutex::scoped_lock lock(g_mu);
//while(g_qu.empty())
//{
// cond_g.wait(g_mu);
//}
cond_g.wait(g_mu, isNotEmpty);
cout<<"<"<<id<<">get: "<<g_qu.front()<<endl;
g_qu.pop();
}
cond_p.notify_one();
}
}
void PutThread(int id)
{
for(int i=0; i<10; ++i)
{
{
boost::mutex::scoped_lock lock(g_mu);
while(g_qu.size() >= 3)
{
cond_p.wait(g_mu);
}
cout<<"<"<<id<<">put: "<<i<<endl;
g_qu.push(i);
}
cond_g.notify_one();
boost::this_thread::sleep(boost::posix_time::seconds(1));
}
}
int fab(int n)
{
if(n==0 || n==1)
return 1;
return fab(n-1)+fab(n-2);
}
void test_thread()
{
boost::mutex mu;
boost::thread t1(myThread, boost::ref(mu), 1);
boost::thread t2(boost::bind(myThread, boost::ref(mu), 2));
boost::function<void(int)> f
= boost::bind(myThread, boost::ref(mu), _1);
boost::thread t3(f, 3);
t1.join();
t2.interrupt();
t2.join();
t3.join();

boost::thread g1(GetThread, 1);
boost::thread g2(GetThread, 2);
boost::thread p1(PutThread,1);
g1.join();
g2.join();
p1.join();

boost::packaged_task<int> pt(boost::bind(fab, 10));
boost::unique_future<int> uf = pt.get_future();
boost::thread(boost::move(pt));
uf.wait();
cout<<uf.get();
}

//==============================================================================
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
void test_asio()
{
boost::asio::io_service ios;
cout<<"now: "<<boost::posix_time::second_clock::local_time()<<endl;
boost::asio::deadline_timer t(ios, boost::posix_time::seconds(3));
cout<<"expires at: "<<t.expires_at()<<endl;
t.wait();
cout<<boost::posix_time::second_clock::local_time()
<<": time expires."<<endl;

boost::asio::ip::address addr =
boost::asio::ip::address::from_string("127.0.0.1");
//boost::asio::ip::tcp::endpoint ep(addr, 6688);
boost::asio::ip::tcp::endpoint ep(
boost::asio::ip::tcp::v4(), 6688);
boost::asio::ip::tcp::acceptor acc(ios, ep);
cout<<"["<<acc.local_endpoint().address()<<"]:"<<endl;
while(true)
{
boost::asio::ip::tcp::socket soc(ios);
acc.accept(soc);
cout<<soc.remote_endpoint().address()<<" connected."<<endl;
soc.write_some(boost::asio::buffer("hello, asio!"));
}
}