The C++ Standard Library Extensions

A Tutorial and Reference

by Pete Becker

This book is for C++ programmers who are frustrated with some of the limitations of the standard C++ library. The book is a tutorial and reference for the library described in the first C++ Library Technical Report, which was approved in 2006 by the International Organization for Standardization (ISO). The library, except for the special math functions, has also been added to the draft working paper for the next C++ standard. It extends the standard C++ library with new facilities in several areas:

• Utilities: a reference-counted smart pointer; a class template tuple that generalizes the std::pair class template to handle various numbers of arguments
• Containers: sets and maps implemented with hash tables; a fixed-size array
• Call wrappers: more powerful and flexible templates that provide wrappers around functions, member functions, and other function objects, allowing them to be used more easily as arguments to algorithms
• Type traits: a set of templates that extract properties of types or modify types at compile time, simplifying template metaprogramming
• Numerics: a rich set of random number generators; advanced mathematical special functions; numeric facilities like those added to the C language in 1999
• Regular expressions: classes and functions to describe and search for patterns in text
• C compatibility: types, functions, and macros like those added to the C language in 1995 and 1999

The book has nearly 200 example programs. You can download an archive file with all of the examples here. If you have questions or comments about the book, please send them to tr1book@petebecker.com.

Errata

• 8The final comment in example 1.4 says that the second element is a reference to j. Its actual type is const int&; that is, j cannot be modified through that reference.
• 39In Example 2.14, the text message in the second call to show is a little confusing. Before the call to sp0.reset(), the object sp0 is empty. The call to show that follows this call to reset shows the effect of calling reset on an empty object.
• 40In Example 2.15, the text messages in the last two calls to the function show are a little confusing. Before the call to sp0.reset(new resource(1)), the object sp0 is empty. The call to show that follows this call to reset shows the effect of calling reset on an empty object. After that call, sp0 is not empty, so the final call to show shows the effect of calling reset on a non-empty object.
• 56In the text near the top of the page there are two mentions of shared_ptr. They should both refer to weak_ptr.
• 118In the last bullet item, (&a)-> X(); should be (&a)->~X();.
• 119The third bullet item says that the expression replaces the container’s contents with a copy of b’s controlled sequence. It should be a copy of a’s controlled sequence.
• 120The last bullet item in the first list uses the identifier const_ local_iterator. The space does not belong there. It should be const_local_iterator.
• 130The last sentence says that a range can be used if its value_type is the same as the type held by the container. The actual requirement is less strict: the range’s value_type must be convertible to the type held by the container.
• 145In the second and third lines of the table at the bottom of the page, the expressions in the column labeled "meaning" use the wrong function names. (d.*f)(1.0) should be (d.*g)(1.0) and (br.*f)(1.0, 2.0) should be (br.*h)(1.0, 2.0).
• 168The return type in the declaration of operator() in the synopsis for reference_wrapper uses a type named T that is not defined. result_of<T(T1, T2, ... TN)> should be result_of<Ty(T1, T2, ... TN)>.
• 191Example 10.1 and its description got a bit tangled up. The example shows how to use bind to create a predicate that is true whenever its argument is less than 10, not when its argument is greater than or equal to 10.
• 266In the text immediately preceding the example code, the reference to Section 12.3.2 should be to Section 12.3.1.
• 283The exponent in the final term in the definition of sph_legendre at the top of the page is incorrect. Replace i*m*theta with i*m*phi.
• 306Some of the declarations of engines with predefined parameters in the synopsis of the header <random> use types named sint, uint, and i-type. Those names represent implementation-specific integral types that are large enough to hold the generator’s values. The first is a signed integral type, the second is an unsigned integral type, and the third is a signed or unsigned integral type.
• 314The synopsis of the template class mersenne_twister lists a member function void seed(); and a member function void seed(unsigned long x0 = 5489);. With both of these overloads, a call to seed() would be ambiguous. Ignore void seed();.
• 363In the third bullet item, there is an extra closing parenthesis at the end of "((a+)(b+))(c+)".
• 377In the code snippet at the bottom of the page, rgy("a*b") should be rgy(rgx).
• 441In the last bullet item, basic_string<char_type is missing its final >.
• 494The text introducing the example says that it uses the second form of regex_replace, which takes a string object as its first argument. The actual code passes an insert iterator. To pass the string object, in the call to regex_replace change back_inserter(result) to result.
• 522In the calls to printf in the code snippets a few extra backslashes crept in. Where the format string says \%u it should say %u.
• 528Example 22.4 has the directive using std::hexfloat;. That should be using std::tr1::hexfloat;.