Part 2: The Standard C++ Library

Standard C++ not only incorporates all the Standard C libraries, with small additions and changes to support type safety, it also adds libraries of its own. These libraries are far more powerful than those in Standard C; the leverage you get from them is analogous to the leverage you get from changing from C to C++.

This section of the book gives you an in-depth introduction to the most important portions of the Standard C++ library.

The most complete and also the most obscure reference to the full libraries is the Standard itself. Somewhat more readable (and yet still a self-described “expert’s guide”) is Bjarne Stroustrup’s 3^rd Edition of The C++ Programming Language (Addison-Wesley, 1997). Another valuable reference is the 3^rd edition of C++ Primer, by Lippman & Lajoie. The goal of the chapters in this book that cover the libraries is to provide you with an encyclopedia of descriptions and examples so you’ll have a good starting point for solving any problem that requires the use of the Standard libraries. However, there are some techniques and topics that are used rarely enough that they are not covered here, so if you can’t find it in these chapters you should reach for the other two books; this book is not intended to replace those but rather to complement them. In particular, I hope that after going through the material in the following chapters you’ll have a much easier time understanding those books.

You will notice that this section does not contain exhaustive documentation describing every function and class in the Standard C++ library. I’ve left the full descriptions to others; in particular there a particularly good on-line sources of standard library documentation in HTML format that you can keep resident on your computer and view with a Web browser whenever you need to look something up. This is PJ Plauger’s Dinkumware C/C++ Library reference at http://www.dinkumware.com. You can view this on-line, and purchase it for local viewing. It contains complete reference pages for the both the C and C++ libraries (so it’s good to use for all your Standard C/C++ programming questions). I am particularly fond of electronic documentation not only because you can always have it with you, but also because you can do an electronic search for what you’re seeking.

When you’re actively programming, these resources should adequately satisfy your reference needs (and you can use them to look up anything in this chapter that isn’t clear to you). Appendix XX lists additional references.

[[ Still needs work ]]

The first chapter in this section introduces the Standard C++ string class, which is a powerful tool that simplifies most of the text processing chores you might have to do. The string class may be the most thorough string manipulation tool you’ve ever seen. Chances are, anything you’ve done to character strings with lines of code in C can be done with a member function call in the string class, including append( ), assign( ), insert( ), remove( ), replace( ), resize( ), copy( ), find( ), rfind( ), find_first_of( ), find_last_of( ), find_first_not_of( ), find_last_not_of( ), substr( ), and compare( ). The operators =, +=, and [ ] are also overloaded to perform the intuitive operations. In addition, there’s a “wide” wstring class designed to support international character sets. Both string and wstring (declared in <string>, not to be confused with C’s <string.h>, which is, in strict C++, <cstring>) are created from a common template class called basic_string. Note that the string classes are seamlessly integrated with iostreams, virtually eliminating the need for you to ever use strstream.

The next chapter covers the iostream library.

Language Support. Elements inherent to the language itself, like implementation limits in <climits> and <cfloat>; dynamic memory declarations in <new> like bad_alloc (the exception thrown when you’re out of memory) and set_new_handler; the <typeinfo> header for RTTI and the <exception> header that declares the terminate( ) and unexpected( ) functions.

Diagnostics Library. Components C++ programs can use to detect and report errors. The <exception> header declares the standard exception classes and <cassert> declares the same thing as C’s assert.h.

General Utilities Library. These components are used by other parts of the Standard C++ library, but you can also use them in your own programs. Included are templatized versions of operators !=, >, <=, and >= (to prevent redundant definitions), a pair template class with a tuple-making template function, a set of function objects for support of the STL, and storage allocation functions for use with the STL so you can easily modify the storage allocation mechanism.

Localization Library. This allows you to localize strings in your program to adapt to usage in different countries, including money, numbers, date, time, and so on.

Containers Library. This includes the Standard Template Library (described in the next section of this appendix) and also the bits and bit_string classes in <bits> and <bitstring>, respectively. Both bits and bit_string are more complete implementations of the bitvector concept introduced in Chapter XX. The bits template creates a fixed-sized array of bits that can be manipulated with all the bitwise operators, as well as member functions like set( ), reset( ), count( ), length( ), test( ), any( ), and none( ). There are also conversion operators to_ushort( ), to_ulong( ), and to_string( ).

The bit_string class is, by contrast, a dynamically sized array of bits, with similar operations to bits, but also with additional operations that make it act somewhat like a string. There’s a fundamental difference in bit weighting: With bits, the right-most bit (bit zero) is the least significant bit, but with bit_string, the right-most bit is the most significant bit. There are no conversions between bits and bit_string. You’ll use bits for a space-efficient set of on-off flags and bit_string for manipulating arrays of binary values (like pixels).

Iterators Library. Includes iterators that are tools for the STL (described in the next section of this appendix), streams, and stream buffers.

Algorithms Library. These are the template functions that perform operations on the STL containers using iterators. The algorithms include: adjacent_find, prev_permutation, binary_search, push_heap, copy, random_shuffle, copy_backward, remove, count, remove_copy, count_if, remove_copy_if, equal, remove_if, equal_range, replace, fill, replace_copy, fill_n, replace_copy_if, find, replace_if, find_if, reverse, for_each, reverse_copy, generate, rotate, generate_n, rotate_copy, includes, search, inplace_merge, set_difference, lexicographical_compare, set_intersection, lower_bound, set_symmetric_difference, make_heap, set_union, max, sort, max_element, sort_heap, merge, stable_partition, min, stable_sort, min_element, swap, mismatch, swap_ranges, next_permutation, transform, nth_element, unique, partial_sort, unique_copy, partial_sort_copy, upper_bound, and partition.

Numerics Library. The goal of this library is to allow the compiler implementer to take advantage of the architecture of the underlying machine when used for numerical operations. This way, creators of higher level numerical libraries can write to the numerics library and produce efficient algorithms without having to customize to every possible machine. The numerics library also includes the complex number class (which appeared in the first version of C++ as an example, and has become an expected part of the library) in float, double, and long double forms.