Boost  v1.57.0
doxygen for
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Doxygen Notes for Boost v1.57.0


Doxygen documentation was generated from the tar.gz source tarball downloaded from

Tag file

The generated Doxygen tag file for Boost can be downloaded from here.

Excluded Libraries

The following Boost library was partially excluded from Doxygen due to problems Doxygen has parsing some of the Boost source files:

  • typeof

The following Boost libraries were partially excluded from Doxygen because they interfered with the Doxygen output by declaring a Doxygen mainpage tag:

  • bimap
  • pool

The following Boost library internal implementation subdirectories were excluded from Doxygen:

  • */aux_/*
  • */detail/*
  • */impl/*
  • */preprocessed/*

This may affect the Doxygen output for some of the Boost libraries.

About Doxygen for Boost

This Doxygen documentation is maintained by Stéphane Charette, This documentation is not officially related to the Boost project and is provided for convenience, not as a replacement for the official Boost documentation. Please refer to the official Boost web site for the full documentation.

Library Summary

Name Type Directory Central Header Central Namespace or Class Description
Accumulators header only boost/accumulators/ boost/accumulators/accumulators.hpp boost::accumulators Framework for incremental calculation, and collection of statistical accumulators.
Algorithm header only boost/boost/algorithm/ boost::algorithm A collection of useful generic algorithms.
Align header only boost/align/ boost/align/align.hpp This library provides an alignment function, aligned allocation and deallocation functions, an aligned allocator, an aligned allocator adaptor, an aligned deleter, a type trait to query alignment requirements, and a function to verify pointer value alignment.
Any header only boost/ boost/any.hpp boost::any Safe, generic container for single values of different value types.
Array header only boost/ boost/array.hpp boost::array STL compliant container wrapper for arrays of constant size.
Asio header only boost/asio/ boost/asio.hpp boost::asio Portable networking, including sockets, timers, hostname resolution and socket iostreams.
Assert header only boost/ boost/assert.hpp BOOST_ASSERT() The header <boost/assert.hpp> defines the macro BOOST_ASSERT, which is similar to the standard assert macro defined in <cassert>. The macro is intended to be used in both Boost libraries and user code.
Assign header only boost/assign/ boost/assign.hpp boost::assign Filling containers with constant or generated data has never been easier.
Atomic header only boost/atomic/ boost/atomic.hpp boost::atomics C++11-style atomic<>.
Bimap header only boost/bimap/ boost/bimap.hpp boost::bimaps Bidirectional maps library for C++. With Boost.Bimap you can create associative containers in which both types can be used as key.
Bind header only boost/bind/ boost/bind.hpp boost::bind is a generalization of the standard functions std::bind1st and std::bind2nd. It supports arbitrary function objects, functions, function pointers, and member function pointers, and is able to bind any argument to a specific value or route input arguments into arbitrary positions.
Call Traits header only boost/ boost/call_traits.hpp Defines types for passing parameters.
Chrono build & link boost/chrono/ boost/chrono.hpp boost::chrono Useful time utilities.
Circular Buffer header only boost/circular_buffer/ boost/circular_buffer.hpp A STL compliant container also known as ring or cyclic buffer.
Compatibility header only boost/compatibility/ boost/compatibility/cpp_c_headers/ Help for non-conforming standard libraries.
Compressed Pair header only boost/ boost/compressed_pair.hpp boost::compressed_pair Empty member optimization.
Concept Check header only boost/concept/ boost::concepts ?
Concept Check header only boost/concept_check/ boost/concept_check.hpp boost::concept_check Tools for generic programming.
Config header only boost/config/ boost/config.hpp Helps Boost library developers adapt to compiler idiosyncrasies; not intended for library users.
Container header only boost/container/ boost::container Standard library containers and extensions.
Context build & link boost/context/ boost/context/all.hpp boost::context Context switching library.
Conversion header only boost/ Polymorphic and lexical casts. The Conversion Library improves program safety and clarity by performing otherwise messy conversions. It includes cast-style function templates designed to complement the C++ Standard's built-in casts.
Core header only boost/core/ boost/core/ The Boost.Core library is a collection of core utilities.
Coroutine header only boost/coroutine/ boost/coroutine/all.hpp boost::coroutines Boost.Coroutine provides templates for generalized subroutines which allow multiple entry points for suspending and resuming execution at certain locations. It preserves the local state of execution and allows re-entering subroutines more than once (useful if state must be kept across function calls).
CRC header only boost/ boost/crc.hpp boost::crc_basic The header crc.hpp provides two implementations of CRC (cyclic redundancy code) computation objects and two implementations of CRC computation functions. The implementations are template-based.
Date Time optional build & link boost/date_time/ boost/date_time.hpp boost::date_time A set of date-time libraries based on generic programming concepts.
Dynamic Bitset header only boost/dynamic_bitset/ boost/dynamic_bitset.hpp The dynamic_bitset class represents a set of bits. It provides accesses to the value of individual bits via an operator[] and provides all of the bitwise operators that one can apply to builtin integers, such as operator& and operator<<. The number of bits in the set is specified at runtime via a parameter to the constructor of the dynamic_bitset.
Enable If header only boost/utility/ boost/utility/enable_if.hpp The enable_if family of templates is a set of tools to allow a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments.
Exception optional build & link boost/exception/ boost/exception.hpp The Boost Exception library supports transporting of arbitrary data in exception objects, and transporting of exceptions between threads.
Filesystem build & link boost/filesystem/ boost/filesystem.hpp boost::filesystem The Boost Filesystem Library provides portable facilities to query and manipulate paths, files, and directories.
Flyweight header only boost/flyweight/ boost/flyweight.hpp boost::flyweights Flyweights are small-sized handle classes granting constant access to shared common data, thus allowing for the management of large amounts of entities within reasonable memory limits.
Foreach header only boost/ boost/foreach.hpp boost::foreach In C++, writing a loop that iterates over a sequence is tedious. We can either use iterators, which requires a considerable amount of boiler-plate, or we can use the std::for_each() algorithm and move our loop body into a predicate, which requires no less boiler-plate and forces us to move our logic far from where it will be used. In contrast, some other languages, like Perl, provide a dedicated "foreach" construct that automates this process. BOOST_FOREACH is just such a construct for C++. It iterates over sequences for us, freeing us from having to deal directly with iterators or write predicates.
Format header only boost/format/ boost/format.hpp The format library provides a class for formatting arguments according to a format-string, as does printf, but with two major differences: format sends the arguments to an internal stream, and so is entirely type-safe and naturally supports all user-defined types; the ellipsis (...) can not be used correctly in the strongly typed context of format, and thus the function call with arbitrary arguments is replaced by successive calls to an argument feeding operator%.
Function header only boost/function/ boost/function.hpp Function object wrappers for deferred calls or callbacks.
Function Types header only boost/function_types/ boost::function_types Boost.FunctionTypes provides functionality to classify, decompose and synthesize function, function pointer, function reference and pointer to member types.
Functional header only boost/functional/ boost/functional.hpp The Boost.Function library contains a family of class templates that are function object wrappers.
Functional/Factory header only boost/functional/ boost/functional/factory.hpp boost::factory The template boost::factory lets you encapsulate a new expression as a function object, boost::value_factory encapsulates a constructor invocation without new.
Functional/Forward header only boost/functional/ boost/functional/forward_adapter.hpp boost::forward_adapter boost::forward_adapter provides a reusable adapter template for function objects. It forwards RValues as references to const, while leaving LValues as-is.
Functional/Hash header only boost/functional/ boost/functional/hash.hpp boost::hash boost::hash is an implementation of the hash function object specified by the Draft Technical Report on C++ Library Extensions (TR1). It is the default hash function for Boost.Unordered, Boost.Intrusive's unordered associative containers, and Boost.MultiIndex's hash indicies and Boost.Bimap's unordered_set_of.
Functional/Overloadedheader only boost/functional/ boost/functional/overloaded_function.hpp boost::overloaded_function This library allows to overload different functions into a single function object.
Fusion header only boost/fusion/ boost::fusion Fusion is a library for working with heterogenous collections of data, commonly referred to as tuples. A set of containers (vector, list, set and map) is provided, along with views that provide a transformed presentation of their underlying data. Collectively the containers and views are referred to as sequences, and Fusion has a suite of algorithms that operate upon the various sequence types, using an iterator concept that binds everything together.
Geometry header only boost/geometry/ boost/geometry.hpp boost::geometry Boost Geometry (aka Generic Geometry Library, GGL), defines concepts, primitives and algorithms for solving geometry problems.
GIL header only boost/gil/ boost/gil/gil_all.hpp boost::gil The Generic Image Library (GIL) is a C++ library that abstracts image representations from algorithms and allows writing code that can work on a variety of images with performance similar to hand-writing for a specific image type.
Graph build & link boost/graph/ boost::graph The BGL graph interface and graph components. Graphs are mathematical abstractions that are useful for solving many types of problems in computer science. A standardized generic interface for traversing graphs is of utmost importance to encourage reuse of graph algorithms and data structures. Part of the Boost Graph Library is a generic interface that allows access to a graph's structure, but hides the details of the implementation. This is an “open” interface in the sense that any graph library that implements this interface will be interoperable with the BGL generic algorithms and with other algorithms that also use this interface. The BGL provides some general purpose graph classes that conform to this interface, but they are not meant to be the “only” graph classes; there certainly will be other graph classes that are better for certain situations.
Heap header only boost/heap/ boost::heap Priority queue data structures. boost.heap is an implementation of priority queues. Priority queues are queue data structures, that order their elements by a priority. The STL provides a single template class std::priority_queue, which only provides a limited functionality. To overcome these limitations, boost.heap implements data structures with more functionality and different performance characteristics.
ICL header only boost/icl/ boost::icl Interval Container Library, interval sets and maps and aggregation of associated values. The meaning of an interval is simple. They represent all the elements between their lower and upper bound and thus a set. But unlike sets, intervals usually can not be added to a single new interval. If you want to add intervals to a collection of intervals that does still represent a set, you arrive at the idea of interval_sets provided by this library.
Identity Type header only boost/utility/ boost/utility/identity_type.hpp BOOST_IDENTITY_TYPE This library allows to wrap types within round parenthesis so they can always be passed as macro parameters.
In Place Factory header only boost/utility/ boost/utility/in_place_factory.hpp boost::in_place_factory This library proposes a framework to allow some containers to directly contruct contained objects in-place without requiring the entire set of constructor overloads from the contained type. It also allows the container to remove the CopyConstuctible requirement from the contained type since objects can be directly constructed in-place without need of a copy.
Integer header only boost/integer/ boost/integer.hpp The organization of boost integer headers and classes is designed to take advantage of <stdint.h> types from the 1999 C standard without resorting to undefined behavior in terms of the 1998 C++ standard. The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace boost without placing any names in namespace std.
Interprocess header only boost/interprocess/ boost::interprocess Shared memory, memory mapped files, process-shared mutexes, condition variables, containers and allocators. Boost.Interprocess simplifies the use of common interprocess communication and synchronization mechanisms and offers a wide range of them
Interval header only boost/numeric/ boost/numeric/interval.hpp This library is intended to help manipulating mathematical intervals.
Intrusive header only boost/intrusive/ boost/intrusive_ptr.hpp boost::intrusive Boost.Intrusive is a library presenting some intrusive containers to the world of C++. Intrusive containers are special containers that offer better performance and exception safety guarantees than non-intrusive containers (like STL containers).
IO State Savers header only boost/io/ boost/io/ios_state.hpp boost::io The I/O sub-library of Boost helps segregate the large number of Boost headers. This sub-library should contain various items to use with/for the standard I/O library.
Iostreams build & link boost/iostreams/ boost/iostreams/stream.hpp boost::iostreams Boost.IOStreams provides a framework for defining streams, stream buffers and i/o filters.
Iterator header only boost/iterator/ boost/iterator.hpp The Boost Iterator Library contains two parts. The first is a system of concepts which extend the C++ standard iterator requirements. The second is a framework of components for building iterators based on these extended concepts and includes several useful iterator adaptors.
Lambda header only boost/lambda/ boost/lambda/lambda.hpp boost::lambda Define small unnamed function objects at the actual call site, and more. The Boost Lambda Library (BLL in the sequel) is a C++ template library, which implements a form of lambda abstractions for C++. The term originates from functional programming and lambda calculus, where a lambda abstraction defines an unnamed function.
Lexical Cast header only boost/ boost/lexical_cast.hpp boost::lexical_cast The lexical_cast function template offers a convenient and consistent form for supporting common conversions to and from arbitrary types when they are represented as text. The simplification it offers is in expression-level convenience for such conversions. For more involved conversions, such as where precision or formatting need tighter control than is offered by the default behavior of lexical_cast, the conventional std::stringstream approach is recommended. Where the conversions are numeric to numeric, boost::numeric_cast may offer more reasonable behavior than lexical_cast.
Local Function header only boost/local_function/ boost/local_function.hpp boost::local_function Local functions (a.k.a., nested functions) are a form of information hiding and they are useful for dividing procedural tasks into subtasks which are only meaningful locally, avoiding cluttering other parts of the program with functions, variables, etc unrelated to those parts. Therefore, local functions complement other structuring possibilities such as namespaces and classes.
Locale build & link boost/locale/ boost/locale.hpp boost::locale Boost.Locale is a library that provides high quality localization facilities in a C++ way. Boost.Locale gives powerful tools for development of cross platform localized software - the software that talks to user in its language.
Lockfree header only boost/lockfree/ boost::lockfree Lockfree data structures. Non-blocking data structures do not rely on locks and mutexes to ensure thread-safety. The synchronization is done completely in user-space without any direct interaction with the operating system.
Log header only boost/log/ boost::log Logging library. This library aims to make logging significantly easier for the application developer. It provides a wide range of out-of-the-box tools along with public interfaces for extending the library.
Math optional build & link boost/math/ boost::math Boost.Math includes several contributions in the domain of mathematics.
Math Common Factor header only boost/math/ boost/math/common_factor.hpp The class and function templates in <boost/math/common_factor.hpp> provide run-time and compile-time evaluation of the greatest common divisor (GCD) or least common multiple (LCM) of two integers.
Math Octonion header only boost/math/ boost/math/octonion.hpp boost::math::octonion Octonions, like quaternions, are a relative of complex numbers. Octonions see some use in theoretical physics.
Math Quaternion header only boost/math/ boost/math/quaternion.hpp boost::math::quaternion Quaternions are a relative of complex numbers.
Math/Special Funcs header only boost/math/ boost/math/special_functions.hpp A wide selection of mathematical special functions.
Math/Stats header only boost/math/ boost/math/distributions.hpp A wide selection of univariate statistical distributions and functions that operate on them.
Member Function header only boost/ boost/mem_fn.hpp Generalized binders for function/object/pointers and member functions.
Meta State Machine header only boost/msm/ MSM is a library allowing you to easily and quickly define state machines of very high performance.
Min-Max header only boost/algorithm/ boost/algorithm/minmax.hpp boost::minmax The problem solved by this library is that simultaneous min and max computation requires only one comparison, but using std::min and std::max forces two comparisons.
Move header only boost/move/ boost/move/move.hpp Portable move semantics for C++03 and C++11 compilers.
MPI build & link boost/mpi/ boost/mpi.hpp boost::mpi Message Passing Interface library, for use in distributed-memory parallel application programming. A Boost.MPI program is one or more processes that can communicate either via sending and receiving individual messages (point-to-point communication) or by coordinating as a group (collective communication). Unlike communication in threaded environments or using a shared-memory library, Boost.MPI processes can be spread across many different machines, possibly with different operating systems and underlying architectures.
MPL header only boost/mpl/ boost::mpl The Boost.MPL library is a general-purpose, high-level C++ template metaprogramming framework of compile-time algorithms, sequences and metafunctions. It provides a conceptual foundation and an extensive set of powerful and coherent tools that make doing explict metaprogramming in C++ as easy and enjoyable as possible within the current language.
Multi-Array header only boost/multi_array/ boost/multi_array.hpp Boost.MultiArray provides a generic N-dimensional array concept definition and common implementations of that interface.
Multi-Index header only boost/multi_index/ boost/multi_index_container.hpp boost::multi_index The Boost Multi-index Containers Library provides a class template named multi_index_container which enables the construction of containers maintaining one or more indices with different sorting and access semantics.
Multiprecision header only boost/multiprecision/ boost::multiprecision Extended precision arithmetic types for floating point, integer andrational arithmetic.
Numeric Conversion header only boost/numeric/ boost/numeric/conversion/converter.hpp boost::numeric The Boost Numeric Conversion library is a collection of tools to describe and perform conversions between values of different numeric types.
Odeint header only boost/numeric/ boost/numeric/odeint.hpp odeint is a library for solving initial value problems (IVP) of ordinary differential equations.
Operators header only boost/ boost/operators.hpp Templates ease arithmetic classes and iterators.
Optional header only boost/optional/ boost/optional.hpp Discriminated-union wrapper for optional values.
Parameter header only boost/parameter/ boost/parameter.hpp boost::parameter Boost.Parameter Library - Write functions that accept arguments by name.
Phoenix header only boost/phoenix/ boost/phoenix.hpp boost::phoenix Define small unnamed function objects at the actual call site, and more.
Pointer Container header only boost/ptr_container/ boost/ptr_container/ptr_container.hpp Boost.Pointer Container provides containers for holding heap-allocated objects in an exception-safe manner and with minimal overhead.
Polygon header only boost/polygon/ boost/polygon/polygon.hpp boost::polygon Voronoi diagram construction and booleans/clipping, resizing/offsetting and more for planar polygons with integral coordinates.
Pool header only boost/pool/ boost/pool/pool.hpp Memory pool management.
Predef header only boost/predef/ boost/predef.h This library defines a set of compiler, architecture, operating system, library, and other version numbers from the information it can gather of C, C++, Objective C, and Objective C++ predefined macros or those defined in generally available headers.
Preprocessor header only boost/preprocessor/ boost/preprocessor.hpp Preprocessor metaprogramming tools including repetition and recursion.
Program Options build & link boost/program_options/ boost/program_options.hpp boost::program_options The program_options library allows program developers to obtain program options, that is (name, value) pairs from the user, via conventional methods such as command line and config file.
Property Map header only boost/property_map/ boost/property_map/property_map.hpp Concepts defining interfaces which map key objects to value objects.
Property Tree header only boost/property_tree/ boost/property_tree/ptree.hpp boost::property_tree A tree data structure especially suited to storing configuration data.
Proto header only boost/proto/ boost/proto/proto.hpp boost::proto Expression template library and compiler construction toolkit for domain-specific embedded languages.
Python build & link boost/python/ boost/python.hpp boost::python The Boost Python Library is a framework for interfacing Python and C++. It allows you to quickly and seamlessly expose C++ classes functions and objects to Python, and vice-versa, using no special tools – just your C++ compiler.
Random optional build & link boost/random/ boost/random.hpp boost::random A complete system for random number generation.
Range header only boost/range/ boost/range.hpp boost::range A new infrastructure for generic algorithms that builds on top of the new iterator concepts.
Ratio header only boost/ratio/ boost/ratio.hpp Compile time rational arithmetic. Boost.Ratio aims to implement the compile time ratio facility in C++0x.
Rational header only boost/ boost/rational.hpp boost::rational The header rational.hpp provides an implementation of rational numbers. The implementation is template-based, in a similar manner to the standard complex number class.
Ref header only boost/core/ boost/core/ref.hpp boost::ref The Ref library is a small library that is useful for passing references to function templates (algorithms) that would usually take copies of their arguments.
Regex build & link boost/regex/ boost/regex.hpp Regular expression library.
Result Of header only boost/utility/ boost/utility/result_of.hpp boost::result_of Determines the type of a function call expression.
Scope Exit header only boost/ boost/scope_exit.hpp BOOST_SCOPE_EXIT This library allows to execute arbitrary code when the enclosing scope exits.
Serialization header only boost/archive/ boost::archive Serialization for persistence and marshalling.
Serialization build & link boost/serialization/ boost/serialization/serialization.hpp boost::serialization Serialization for persistence and marshalling.
Signals (deprecated)build & link boost/signals/ boost/signals.hpp boost::signals Managed signals & slots callback implementation.
Signals2 header only boost/signals2/ boost/signals2.hpp boost::signals2 Managed signals & slots callback implementation (thread-safe version 2).
Smart Ptr header only boost/smart_ptr/ boost/smart_ptr.hpp Smart pointer class templates.
Spirit header only boost/spirit/ boost/spirit.hpp boost::spirit LL parser framework represents parsers directly as EBNF grammars in inlined C++.
Statechart header only boost/statechart/ boost::statechart Boost.Statechart - Arbitrarily complex finite state machines can be implemented in easily readable and maintainable C++ code.
Static Assert header only boost/ boost/static_assert.hpp BOOST_STATIC_ASSERT Static assertions (compile time assertions).
String Algo header only boost/algorithm boost/algorithm/string.hpp The String Algorithm Library provides a generic implementation of string-related algorithms which are missing in STL. It is an extension to the algorithms library of STL and it includes trimming, case conversion, predicates and find/replace functions.
Swap header only boost/ boost/swap.hpp boost::swap The template function boost::swap allows the values of two variables to be swapped, using argument dependent lookup to select a specialized swap function if available. If no specialized swap function is available, std::swap is used.
System build & link boost/system/ boost::system Operating system support, including the diagnostics support that will be part of the C++0x standard library.
Test optional build & link boost/test/ boost::unit_test Support for simple program testing, full unit testing, and for program execution monitoring.
Thread build & link boost/thread/ boost/thread.hpp boost::thread Portable C++ multi-threading. Boost.Thread enables the use of multiple threads of execution with shared data in portable C++ code. It provides classes and functions for managing the threads themselves, along with others for synchronizing data between the threads or providing separate copies of data specific to individual threads.
ThrowException header only boost/ boost/throw_exception.hpp The purpose of Boost Exception is to ease the design of exception class hierarchies and to help write exception handling and error reporting code.
Timer build & link boost/timer/ boost/timer.hpp boost::timer Event timer, progress timer, and progress display classes.
Tokenizer header only boost/ boost/tokenizer.hpp boost::tokenizer The boost Tokenizer package provides a flexible and easy to use way to break off a string or other character sequence into a series of tokens.
TR1 (deprecated) boost/tr1/ The TR1 library provides an implementation of the C++ Technical Report on Standard Library Extensions. This library does not itself implement the TR1 components, rather it's a thin wrapper that will include your standard library's TR1 implementation (if it has one), otherwise it will include the Boost Library equivalents, and import them into namespace std::tr1.
Tribool header only boost/logic/ boost/logic/tribool.hpp boost::logic 3-state boolean type library.
TTI header only boost/tti/ boost/tti/tti.hpp boost::tti Type Traits Introspection library. TTI is a library which provides the ability to introspect by name the elements of a type at compile time.
Tuple header only boost/tuple/ boost/tuple/tuple.hpp boost::tuples Ease definition of functions returning multiple values, and more.
Type Erasure header only boost/type_erasure/ boost::type_erasure Runtime polymorphism based on concepts.
Type Index header only boost/type_index/ boost/type_index.hpp boost::type_index boost::typeindex::type_info is a drop-in replacement for std::type_info and boost::typeindex::type_index is a drop-in replacement for std::type_index. Unlike Standard Library versions those classes can work without RTTI.
Type Traits header only boost/type_traits/ boost/type_traits.hpp Templates for fundamental properties of types.
Typeof header only boost/typeof/ boost/typeof/typeof.hpp boost::type_of Typeof operator emulation.
uBLAS header only boost/numeric/ublas/ boost::numeric::ublas uBLAS provides matrix and vector classes as well as basic linear algebra routines. Several dense, packed and sparse storage schemes are supported.
Units header only boost/units/ boost/units/unit.hpp boost::units Zero-overhead dimensional analysis and unit/quantity manipulation and conversion.
Unordered header only boost/unordered/ boost/unordered_map.hpp boost/unordered_set.hpp boost::unordered Unordered associative containers.
Utility header only boost/utility/ boost/utility.hpp Class noncopyable plus checked_delete(), checked_array_delete(), next(), prior() function templates, plus base-from-member idiom.
Uuid header only boost/uuid/ boost/uuid/uuid.hpp boost::uuids A universally unique identifier.
Value Initialized header only boost/utility/ boost/utility/value_init.hpp Wrapper for uniform-syntax value initialization.
Variant header only boost/variant/ boost/variant.hpp boost::detail::variant Safe, generic, stack-based discriminated union container.
Wave build & link boost/wave/ boost/wave.hpp boost::wave The Boost.Wave library is a Standards conformant, and highly configurable implementation of the mandated C99/C++ preprocessor functionality packed behind an easy to use iterator interface.
Xpressive header only boost/xpressive/ boost/xpressive/xpressive.hpp boost::xpressive Regular expressions that can be written as strings or as expression templates, and which can refer to each other and themselves recursively with the power of context-free grammars.