The are a collection of 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 .http://www.open-std.org/jtc1/sc22/wg21/docs/library_technical_report.html
The libraries are aimed at a wide range of C++ users and application domains. 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 .
In order to ensure efficiency and flexibility, Boost makes extensive use of Template s. Boost has been a source of extensive work and research into Generic Programming and Metaprogramming in C++.
Boost provides extension libraries in the following areas:
- 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
- --- 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 Token s
- --- 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
Boost includes a Linear Algebra library called , with BLAS support for vectors and matrices.
- Example showing how to multiply a vector with a matrix:
#include
#include
#include
using namespace boost::numeric::ublas;
- "y = Ax" example ---/
int main () {
vector x (2);
x(0) = 1; x(1) = 2;
matrix A(2,2);
A(0,0) = 0; A(0,1) = 1;
A(1,0) = 2; A(1,1) = 3;
vector y = prod(A, x);
std::cout << y << std::endl;
return 0;
}
Boost provides distribution-independent Pseudorandom Number Generator s and PRNG-independent probability distributions, which are combined to build a concrete generator.
#include
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 (std::time(0)));
// select Gaussian probability distribution
normal_distribution norm_dist(mean, sigma);
// bind random number generator to distribution, forming a function
variate_generator > normal_sampler(rng, norm_dist);
// sample from the distribution
return normal_sampler();
}
See Boost Random Number Library for more details.
Example code that demonstrates creation of threads:
#include
#include
using namespace std;
void hello_world() {
cout << "Hello world, I'm a thread!" << endl;
}
boost::thread my_thread(&hello_world);
// wait for the thread to finish
my_thread.join();
return 0;
}
Original founders of Boost still active in the community include Beman Dawes and David Abrahams . Author of several books on C++, Nicolai Josuttis contributed the Boost array library in 2001. Around 3,000 people are subscribed to Boost mail-list and dozens of them are very active ( As Of 2007 ).
|
