Beyond the C++ Standard Library: An Introduction to Boost [Electronic resources] نسخه متنی

Miscellaneous

Boost.Conversion

The Conversion library contains functions that augment the existing cast operators (static_cast, const_cast, and dynamic_cast). Conversion adds polymorphic_cast and polymorphic_downcast for safe polymorphic casts, numeric_cast for safe conversions among numeric types, and lexical_cast for lexical conversions (for example, between string and double). You can customize these casts to work optimally with your own typessomething that isn't possible with the casts provided by the language. The library is covered in detail in "Library 2: Conversion."

The authors of Conversion are Dave Abrahams and Kevlin Henney.

Boost.Crc

The Crc library provides calculations of cyclic redundancy codes (CRC), a commonly used checksum type. A CRC is attached to a stream of data (from which it is computed), so the checksum can be used later to validate the data. The library includes four sample CRC types: crc_16_type, crc_ccitt_type, crc_xmodem_type, and crc_32_type5.

The author of Crc is Daryle Walker.

Boost.Date_time

The Date_time library provides extensive support for date and time types and operations upon them. Without library support for dates and time, temporal programming tasks are complicated and error prone. Using Date_time, the natural abstractions that one would expect are supported: days, weeks, months, durations (and intervals thereof), addition and subtraction, and so on. The library addresses issues commonly omitted from other date/time libraries, such as handling leap seconds and supporting high-resolution time sources. The library's design is extensible, allowing for customized behavior or added functionality.

The author of Date_time is Jeff Garland.

5. CRC32 is used in PKZip, for example.

Boost.Optional

It is common for functions to indicate that the returned value is invalid, but often the returned type does not have a state to indicate that it's not valid. Optional offers the class template optional, which is a type that semantically has an additional state, one that is in effect when instances of optional are not containing instances of the wrapped object.

The author of Optional is Fernando Cacciola.

Boost.Pool

The Pool library provides a pool memory allocatorthat is, a tool for managing dynamic memory in a single, large allocation. Using memory pools is a good solution when allocating and deallocating many small objects, or when memory control needs to be made more efficient.

The author of Pool is Steve Cleary.

Boost.Preprocessor

Using the preprocessor is hard when you need to express common constructs such as recursion, it doesn't have containers, doesn't provide means for iteration, and so forth. Nevertheless, the preprocessor is a powerful and portable tool. The Preprocessor library provides abstractions on top of the preprocessor. These include lists, tuples, and arrays, as well as algorithms that operate on the elements of those types. The library helps eliminate repetitive code, thus reducing your effort, while making code more readable, expressive, and maintainable.

The authors of Preprocessor are Vesa Karvonen and Paul Mensonides.

Boost.Program_options

The Program_options library retrieves program configuration options (name/value pairs), typically provided through command-line arguments or configuration files. The library relieves the programmer from the task of parsing the data by hand.

The author of Program_options is Vladimir Prus.

Boost.Python

The Python library provides interoperability between C++ and Python.[6] It is used to expose C++ classes and functions to Python and Python objects to C++. It is non-intrusive, which means that existing code typically requires no changes to be exposed in Python.

[6] A popular programming language that you should get acquainted with.

The author of Python is David Abrahams, with important contributions from Joel de Guzman and Ralf W. Grosse-Kunstleve.

Boost.Smart_ptr

Smart pointers are vital parts of any programmer's toolbox. They are used everywhere to avoid resource leaks, share resources, and manage object lifetimes correctly. There are a great number of good smart pointer libraries available, some for free, others part of commercial packages. Smart_ptr is among the best, as proven by thousands of users and the recommendations from leading experts in the field. Smart_ptr includes non-intrusive smart pointers for limiting scope (scoped_ptr and scoped_array) and sharing resources (shared_ptr and shared_array), an observing smart pointer to use with shared_ptr (weak_ptr), and an intrusive smart pointer class (intrusive_ptr). Smart_ptr's shared_ptr (including the helper enable_shared_from_this) and weak_ptr have been accepted for the upcoming Library Technical Report. For more about these really smart pointers, see "Library 1: Smart_ptr 1."

The authors of Smart_ptr are Greg Colvin, Beman Dawes, Peter Dimov, and Darin Adler.

Boost.Test

The Test library provides a matched set of components for writing test programs, organizing tests into simple test cases and test suites, and controlling their runtime execution. The Program Execution Monitor, a component in the library, is also useful in some production (nontest) environments.

The author of Test is Gennadiy Rozental (based upon earlier work by Beman Dawes).

Boost.Thread

Portable threading is tricky business, and there's no help to be had from C++ itself, as the language includes no threading support, nor acknowledges it in any way. Of course, there's POSIX, available on many platforms, but POSIX defines a C API. Thread is a library that offers portable threading through a number of threading primitives and higher-level abstractions.

The author of Thread is William Kempf.

Boost.Timer

The Timer library contains features for measuring time, and aims to be as consistent as possible across different platforms. Although there are typically platform-specific APIs that allow programmers to measure time, there is no portable way of attaining high-resolution timers. Boost.Timer addresses this problem by offering the best possible resolution whilst remaining portable, in return for a certain degree of freedom of guaranteed accuracy and precision.

The author of Timer is Beman Dawes.

Boost.Tribool

This library contains a tribool class, which implements three-state Boolean logic. A three-state Boolean type has an additional state besides true and false: indeterminate (this state could also be named maybe; the name is configurable).

The author of Tribool is Douglas Gregor.

Boost.Utility

Some useful stuff just doesn't find its way into a separate library, typically because it is not complicated or extensive enough to warrant a separate library. That doesn't make it less useful; in fact, small utilities often have the most widespread use. In Boost, such utilities are contained in the aptly named Utility library. Here, one finds checked_delete, a function that ensures that a type is complete upon the point of deletion, the class noncopyable to ensure that a class cannot be copied, and enable_if for total control of function overloading. There's a lot more to Utility. See "Library 3: Utility" for the whole story.

The authors of Utility are David Abrahams, Daryle Walker, Douglas Gregor, and others.

Boost.Value_initialized

The Value_initialized library helps construct and initialize objects in a generic way. In C++, a newly constructed object can be either zero-initialized, default-constructed, or indeterminate, all depending upon the type of the object. With Boost.Value_initialized, this inconsistency problem goes away.