 |
Boost
v1.57.0
doxygen for www.boost.org
|
|
|
Boost
v1.57.0
doxygen for www.boost.org
|
|
Doxygen documentation was generated from the tar.gz source tarball downloaded from https://sourceforge.net/projects/boost/files/boost/.
The generated Doxygen tag file for Boost can be downloaded from here.
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.
This Doxygen documentation is maintained by Stéphane Charette, stephanecharette@gmail.com. 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.
| 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/Overloaded | header 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. |
1.8.8