C++ Standard Library

In C++, the C++ Standard Library is a collection of classes and functions, which are written in the core language and part of the C++ ISO Standard itself.^[1] The C++ Standard Library provides several generic containers, functions to utilize and manipulate these containers, function objects, generic strings and streams (including interactive and file I/O), support for some language features, and everyday functions for tasks such as finding the square root of a number. The C++ Standard Library also incorporates 18 headers of the ISO C90 C standard library ending with ".h", but their use is deprecated.^[2] All other headers in the C++ Standard Library do not end in ".h". Features of the C++ Standard Library are declared within the std namespace.

The C++ Standard Library is based upon conventions introduced by the Standard Template Library (STL). Although the C++ Standard Library and the STL share many features, neither is a strict superset of the other. In particular, the C++ Standard Library has also been influenced^[3] by the work of Alexander Stepanov and Meng Lee.^[4]

The C++ Standard Library underwent ISO standardization as part of the C++ ISO Standardization effort, and is undergoing further work^[5] regarding standardization of expanded functionality.

Standard headers

The following files contain the declarations of the C++ Standard Library.

Containers

<array>: New in C++11 and TR1. Provides the container class template std::array, a container for a fixed sized array.
<bitset>: Provides the specialized container class std::bitset, a bit array.
<deque>: Provides the container class template std::deque, a double-ended queue.
<forward_list>: New in C++11 and TR1. Provides the container class template std::forward_list, a singly linked list.
<list>: Provides the container class template std::list, a doubly linked list.
<map>: Provides the container class templates std::map and std::multimap, sorted associative array and multimap.
<queue>: Provides the container adapter class std::queue, a single-ended queue, and std::priority_queue, a priority queue.
<set>: Provides the container class templates std::set and std::multiset, sorted associative containers or sets.
<stack>: Provides the container adapter class std::stack, a stack.
<unordered_map>: New in C++11 and TR1. Provides the container class template std::unordered_map and std::unordered_multimap, hash tables.
<unordered_set>: New in C++11 and TR1. Provides the container class template std::unordered_set and std::unordered_multiset.
<vector>: Provides the container class template std::vector, a dynamic array.

General

<algorithm>: Provides definitions of many container algorithms.
<functional>: Provides several function objects, designed for use with the standard algorithms.
<iterator>: Provides classes and templates for working with iterators.
<locale>: Provides classes and templates for working with locales.
<memory>: Provides facilities for memory management in C++, including the class template std::unique_ptr.
<stdexcept>: Contains standard exception classes such as std::logic_error and std::runtime_error, both derived from std::exception.
<tuple>: New in C++11 and TR1. Provides a class template std::tuple, a tuple.
<utility>: Provides the template class std::pair, for working with pairs (two-member tuples) of objects.

Strings

<string>: Provides the C++ standard string classes and templates.
<regex>: Provides utilities for pattern matching strings using regular expressions.

Streams and Input/Output

<fstream>: Provides facilities for file-based input and output. See fstream.
<iomanip>: Provides facilities to manipulate output formatting, such as the base used when formatting integers and the precision of floating point values.
<ios>: Provides several types and functions basic to the operation of iostreams.
<iosfwd>: Provides forward declarations of several I/O-related class templates.
<iostream>: Provides C++ input and output fundamentals. See iostream.
<istream>: Provides the template class std::istream and other supporting classes for input.
<ostream>: Provides the template class std::ostream and other supporting classes for output.
<sstream>: Provides the template class std::sstream and other supporting classes for string manipulation.
<streambuf>: Provides reading and writing functionality to/from certain types of character sequences, such as external files or strings.

Numerics

<complex>: Provides class template std::complex and associated functions for working with complex numbers.

<numeric>: Provides algorithms for numerical processing

<random>: New in C++11. 26.5-1 This subclase defines a facility for generating (pseudo-)random numbers.

<valarray>: Provides the template class std::valarray, an array class optimized for numeric processing.

Language support

<exception>: Provides several types and functions related to exception handling, including std::exception, the base class of all exceptions thrown by the Standard Library.
<limits>: Provides the template class std::numeric_limits, used for describing properties of fundamental numeric types.
<new>: Provides operators new and delete and other functions and types composing the fundamentals of C++ memory management.
<typeinfo>: Provides facilities for working with C++ run-time type information.

Thread support library

<thread>: New in C++11. Provide class and namespace for working with threads.
<mutex>: New in C++11. 30.4-1 This section provides mechanisms for mutual exclusion: mutexes, locks, and call once.
<condition_variable>: New in C++11. 30.5-1 Condition variables provide synchronization primitives used to block a thread until notified by some other thread that some condition is met or until a system time is reached.
<future>: New in C++11. 30.6.1-1 Describes components that a C++ program can use to retrieve in one thread the result (value or exception) from a function that has run in the same thread or another thread.