BGLH Boost Graph Library Home
Acronym Definition
BGLH Bachelor of General Law Home
BGLH Baglung Airport (Nepal) Home
BGLH Banque Générale du Luxembourg Home
BGLH BattleGrounds League Home
BGLH Below Ground Level Home
BGLH Berchtesgadener Land (Bavaria, Germany) Home
BGLH Bibliographie des Grammairiens Latins Hom
BGLH Big Game Lodge Home
BGLH Big Giant Lock Home
BGLH Blood Glucose Level Home
BGLH Bomb Laser Guided Home
BGLH Bonn Guidelines Home
BGLH Boost Graph Library Home
BGLH Brady Green Library (San Antonio, Texas) Home
BGLH Brimson Grow Library (Lombard, Illinois) Home
BGLH British Gas/Lurgi Home
BGLH Bulgarian Lev (former currency code; now BGN) Home
BGLH Bulgarian Lev (Old) Home
BGLH Boost Graph Library Home
The Boost C++ Libraries are a collection of 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.
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
templates. Boost has been a source of extensive work and research into generic
programming and metaprogramming in C++.
Libraries
This section is currently a list, and needs cleanup.
A good lead should be written for this, and/or the entire section converted to
prose. Once this task is complete, please remove this message. (talk, help, how
to edit)
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 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
Linear algebra
Boost includes a linear algebra library called uBLAS, with BLAS support for
vectors and matrices.
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>
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 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.
Multithreading
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 a new thread that calls the "hello_world" function
boost::thread my_thread(&hello_world);
// wait for the thread to finish
my_thread.join();
return 0;
}
Introduction to Boost.Threads in Dr. Dobb's Journal.
Boost.Threads API reference.
threadpool library based on Boost.Thread
Associated people
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).
Contact Information
Call our office today to set up an appointment. Learn more about how we can
help you, and learn more about the other services that we can offer you. All
messages we receive will be answered as soon as possible. We look forward to
hearing from you.
- Electronic mail
- General Information:
