C++ Programming/Libraries/Boost

The Boost project (http://www.boost.org/) provides free peer-reviewed, open source libraries that extend the functionality of C++. Most of the libraries are licensed under the Boost Software License, designed to allow Boost to be used with both open and closed source projects. Many of Boost's founders are on the C++ standard committee and several Boost libraries have been accepted for incorporation into the Technical Report 1 of C++0x. Although Boost was begun by members of the C++ Standards Committee Library Working Group, participation has expanded to include thousands of programmers from the C++ community at large. The emphasis is on libraries which work well with the C++ Standard Library. The libraries are aimed at a wide range of C++ users and application domains, and are in regular use by thousands of programmers. They range from general-purpose libraries like SmartPtr, to OS Abstractions like FileSystem, to libraries primarily aimed at other library developers and advanced C++ users, like MPL. A further goal is to establish "existing practice" and provide reference implementations so that Boost libraries are suitable for eventual standardization. Ten Boost libraries will be included in the C++ Standards Committee's upcoming C++ Standard Library Technical Report as a step toward becoming part of a future C++ Standard. In order to ensure efficiency and flexibility, Boost makes extensive use of templates. Boost has been a source of extensive work and research into generic programming and metaprogramming in C++. Libraries Libraries by category Concurrent programming ... TODO Algorithms Concurrent programming (threads) Containers array - Management of fixed-size arrays with STL container semantics Boost Graph Library (BGL) - Generic graph containers, components and algorithms multi-array - Simplifies creation of N-dimensional arrays multi-index containers - Containers with built in indexes that allow different sorting and access semantics pointer containers - Containers modeled after most standard STL containers that allow for transparent management of pointers to values property map - Interface specifications in the form of concepts and a general purpose interface for mapping key values to objects variant - A safe and generic stack-based object container that allows for the efficient storage of and access to an object of a type that can be chosen from among a set of types that must be specified at compile time. Correctness and testing concept check - Allows for the enforcement of actual template parameter requirements (concepts) static assert - Compile time assertion support Boost Test Library - A matched set of components for writing test programs, organizing tests into test cases and test suites, and controlling their runtime execution Data structures dynamic_bitset - Dynamic std::bitset-like data structure Function objects and higher-order programming bind and mem_fn - General binders for functions, function objects, function pointers and member functions function - Function object wrappers for deferred calls. Also, provides a generalized mechanism for callbacks functional - Enhancements to the function object adapters specified in the C++ Standard Library, including: function object traits negators binders adapters for pointers to functions adapters for pointers to member functions hash - An implementation of the hash function object specified by the C++ Technical Report 1 (TR1). Can be used as the default hash function for unordered associative containers lambda - In the spirit of lambda abstractions, allows for the definition of small anonymous function objects and operations on those objects at a call site, using placeholders, especially for use with deferred callbacks from algorithms. ref - Provides utility class templates for enhancing the capabilities of standard C++ references, especially for use with generic functions result_of - Helps in the determination of the type of a call expression Signals2 - Managed signals and slots callback implementation Generic programming Graphs Input/output Interlanguage support (for Python) Iterators iterators operators - Class templates that help with overloaded operator definitions for user defined iterators and classes that can participate in arithmetic computation. tokenizer - Provides a view of a set of tokens contained in a sequence that makes them appear as a container with iterator access Math and Numerics Memory pool - Provides a simple segregated storage based memory management scheme smart_ptr - A collection of smart pointer class templates with different pointee management semantics scoped_ptr - Owns the pointee (single object) scoped_array - Like scoped_ptr, but for arrays shared_ptr - Potentially shares the pointer with other shared_ptrs. Pointee is destroyed when last shared_ptr to it is destroyed shared_array - Like shared_ptr, but for arrays weak_ptr - Provides a "weak" reference to an object that is already managed by a shared_ptr intrusive_ptr - Similared to shared_ptr, but uses a reference count provided by the pointee utility - Miscellaneous support classes, including: base from member idiom - Provides a workaround for a class that needs to initialize a member of a base class inside its own (i.e., the derived class') constructor's initializer list checked delete - Check if an attempt is made to destroy an object or array of objects using a pointer to an incomplete type next and prior functions - Allow for easier motion of a forward or bidirectional iterator, especially when the results of such a motion need to be stored in a separate iterator (i.e., should not change the original iterator) noncopyable - Allows for the prohibition of copy construction and copy assignment addressof - Allows for the acquisition of an object's real address, bypassing any overloads of operator&(), in the process result_of - Helps in the determination of the type of a call expression Miscellaneous Parsers Preprocessor metaprogramming String and text processing lexical_cast - Type conversions to/from text format - Type safe argument formatting according to a format string iostreams - C++ streams and stream buffer assistance for new sources/sinks, filters framework regex - Support for regular expressions Spirit - An object-oriented recursive-descent parser generator framework string algorithms - A collection of various algorithms related to strings tokenizer - Allows for the partitioning of a string or other character sequence into tokens wave - Standards conformant implementation of the mandated C99 / C++ pre-processor functionality packed behind an easy to use interface Template metaprogramming mpl - A general purpose high-level metaprogramming framework of compile-time algorithms, sequences and metafunctions static assert - Compile time assertion support type traits - Templates that define the fundamental properties of types Workarounds for broken compilers The current Boost release contains 87 individual libraries, including the following three: noncopyable The boost::noncopyable utility class that ensures that objects of a class are never copied. class C : boost::noncopyable { ... }; Linear algebra – uBLAS Boost includes the uBLAS linear algebra library (faster alternative libraries include armadillo and eigen), with BLAS support for vectors and matrices. uBlas supports a wide range of linear algebra operations, and has bindings to some widely used numerics libraries, such as ATLAS, BLAS and LAPACK. Example showing how to multiply a vector with a matrix: #include <boost/numeric/ublas/vector.hpp> #include <boost/numeric/ublas/matrix.hpp> #include <boost/numeric/ublas/io.hpp> #include <iostream> using namespace boost::numeric::ublas; /* "y = Ax" example */ int main () { vector<double> x(2); x(0) = 1; x(1) = 2; matrix<double> A(2,2); A(0,0) = 0; A(0,1) = 1; A(1,0) = 2; A(1,1) = 3; vector<double> y = prod(A, x); std::cout << y << std::endl; return 0; } Generating random numbers – Boost.Random Boost provides distribution-independent pseudorandom number generators and PRNG-independent probability distributions, which are combined to build a concrete generator. Example showing how to sample from a normal distribution using the Mersenne Twister generator: #include <boost/random.hpp> #include <ctime> using namespace boost; double SampleNormal (double mean, double sigma) { // Create a Mersenne twister random number generator // that is seeded once with #seconds since 1970 static mt19937 rng(static_cast<unsigned> (std::time(0))); // select Gaussian probability distribution normal_distribution<double> norm_dist(mean, sigma); // bind random number generator to distribution, forming a function variate_generator<mt19937&, normal_distribution<double> > normal_sampler(rng, norm_dist); // sample from the distribution return normal_sampler(); } See Boost Random Number Library for more details. Multi-threading – Boost.Thread Example code that demonstrates creation of threads: #include <boost/thread/thread.hpp> #include <iostream> using namespace std; void hello_world() { cout << "Hello world, I'm a thread!" << endl; } int main(int argc, char* argv[]) { // start two new threads that calls the "hello_world" function boost::thread my_thread1(&hello_world); boost::thread my_thread2(&hello_world); // wait for both threads to finish my_thread1.join(); my_thread2.join(); return 0; } See also Threading with Boost - Part I: Creating Threads Thread locking Example usage of a mutex to enforce exclusive access to a function: #include <iostream> #include <boost/thread.hpp> void locked_function () { // function access mutex static boost::mutex m; // wait for mutex lock boost::mutex::scoped_lock lock(m); // critical section // TODO: Do something // auto-unlock on return } int main (int argc, char* argv[]) { locked_function(); return 0; } Example of read/write locking of a property: #include <iostream> #include <boost/thread.hpp> /** General class for thread-safe properties of any type. */ template <class T> class lock_prop : boost::noncopyable { public: lock_prop () {} /** Set property value. */ void operator = (const T & v) { // wait for exclusive write access boost::unique_lock<boost::shared_mutex> lock(mutex); value = v; } /** Get property value. */ T operator () () const { // wait for shared read access boost::shared_lock<boost::shared_mutex> lock(mutex); return value; } private: /// Property value. T value; /// Mutex to restrict access mutable boost::shared_mutex mutex; }; int main () { // read/write locking property lock_prop<int> p1; p1 = 10; int a = p1(); return 0; } Introduction to Boost.Threads in Dr. Dobb's Journal. (2002) What's New in Boost Threads? in Dr. Dobb's Journal. (2008) Boost.Threads API reference. threadpool library based on Boost.Thread Ceemple Boost included in Ceemple, a rapid JIT based C++ technical computing environment.