Boost

Boost is a set of C++ libraries providing commonly used features not present in the C++ standard library. Many Boost libraries are intended for standardisation in later versions of the C++ standard, and several have been accepted for TR1 and the C++0x standard.

Boost is distributed under a liberal open source license, intended to allow compiler and library vendors to use Boost code in their products.

Libraries
As of version 1.33.1, Boost provides extension libraries for the following areas:
 * Algorithms
 * Concurrent programming (threads)
 * Containers
 * array - Management of fixed-size arrays with STL container semantics
 * dynamic bitset - Management of a container of bits, whose size can be specified at runtime
 * 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
 * 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
 * signals and slots - 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