Hello World!

C++ boost 簡單應用




  • regex
  • function binding
  • lambda functions
  • unit tests
  • smart pointers
  • noncopyable, optional
  • serialization
  • generic dates
  • portable filesystem
  • circular buffers
  • config utils
  • generic image library
  • program options
  • threads


安裝:sudo apt-get install libboost-all-dev




#include <boost/foreach.hpp>
std::string hello( "Hello, world!" );
BOOST_FOREACH( char ch, hello ){ // equals to for (auto c : hello) in c03
std::cout << ch << endl;

//convient way to use
#define foreach BOOST_FOREACH




#include <boost/lexical_cast.hpp>
double j = 233.211321231;
string mystring = boost::lexical_cast<string>(j);
double k = boost::lexical_cast<double>(mystring);//k = 233.211


#include <boost/algorithm/string.hpp>
string stringtobesplit = "AA/BB-CC";
vector<string> tokens;
boost::split(tokens, stringtobesplit, boost::is_any_of("/\-"));

Smart Pointers

Basic properties of smart pointers

  • no ownership at all
    • smart pointer cannot delete the object, because it doesn’t own it
  • transfer of ownership
    • only one smart pointer can ever point to the same object at the same time
    • If the smart pointer is to be returned from functions, the ownership is transferred to the returned smart pointer
    • Transfer of ownership cannot really be implemented in C++ currently, because object will be copied after return
      • only can use the copy constructor to implement that transfer of ownership
  • share of ownership
    • multiple smart pointers can point to the same object at the same time
    • can be implemented by having a copy constructor

Categorizing smart pointers

  • scoped_ptr
    • neither transferable nor sharable (= normal pointer)
    • when it goes out of scope, it is destroyed
  • shared_ptr
    • shares ownership
    • reference counted so it can see when the last copy of it goes out of scope and then it frees the object automatically
    • 所有使用同一筆資料的指標都不再使用後自動釋放
  • weak_ptr
    • non-owning smart pointer
    • reference a managed object (managed by a shared_ptr) so it will not add a reference count
      • If you need to access the object, you can lock the management of it (to avoid that in another thread a shared_ptr frees it while you use the object)
    • If weak_ptr points to an object already deleted, it will notice you by throwing an exception
    • It is most beneficial when you have a cyclic reference: Reference counting cannot easily cope with such a situation
  • intrusive_ptr
    • like a shared_ptr
      • does not keep the reference count in a shared_ptr
      • but call helper functions to increse/decrese the count
        • helper function need to be defined by the object that is managed
        • reference count is not anymore internal to the smart pointer, but the smart pointer uses an existing reference counting mechanism
    • typically used when there is a 3rd party smart ptr you must use
  • unique_ptr
    • transfer of ownership pointer
    • cannot copy it, but can move it by using C++1x’s move constructors
std::vector< scoped_ptr<T> > tPtrVec;
scoped_ptr<T> tPtr(new T());
// raw T* is freed
tPtrVec[0]->DoSomething(); // accessing freed memory
std::vector< shared_ptr<T> > tPtrVec;
shared_ptr<T> tPtr(new T());
// This copy to tPtrVec.push_back and ultimately to the vector storage
// causes the reference count to go from 1->2
// num references to T goes from 2->1 on the destruction of tPtr
tPtrVec[0]->DoSomething(); // raw T* still exists, so this is safe
std::vector< weak_ptr<T> > tPtrVec;
shared_ptr<T> tPtr(new T());
// num references to T goes from 1->0
shared_ptr<T> tPtrAccessed = tPtrVec[0].lock();
if (tPtrAccessed[0].get() == 0){
cout << "Raw T* was freed, can't access it"
tPtrVec[0]->DoSomething(); // raw
unique_ptr<type> p(new type);
unique_ptr<type> q(p); // not legal!
unique_ptr<type> r(move(p)); // legal. p is now empty and r owns the object
unique_ptr<type> s(function_returning_a_unique_ptr()); // legal!

Chinese Explaination

#include <boost/shared_ptr.hpp>
void safeclose(FILE*fp) {
if(fp) {
void some_fn() {
boost::shared_ptr<FILE> fp( fopen(myfilename, "a+t"), safeclose );
//body of the function, and when ever it exits the file gets closed
fprintf( fp.get(), "a message\n" );


Advantage of using boost libraries
Most used parts of boost