default initialization

This is the initialization performed when a variable is constructed with no initializer. Syntax T object ; (1) new T ; new T ( ) ; (until c++03). (2) Explanation Default initialization is performed in three situations: 1) when a variable with automatic, static, or thread-local storage duration is declared with no initializer. 2) when an object with dynamic storage duration is created by a new-expression with no initializer or when an object is created by a new-expression

std::unordered_set::bucket

size_type bucket( const Key& key ) const; (since C++11) Returns the index of the bucket for key key. Elements (if any) with keys equivalent to key are always found in this bucket. The returned value is valid only for instances of the container for which bucket_count() returns the same value. The behavior is undefined if bucket_count() is zero. Parameters key - the value of the key to examine Return value Bucket index for the key key. Complexity Constant. See also

std::strstreambuf::pcount

int pcount() const; Returns the number of characters written to the output sequence. If the next pointer for the put area (std::streambuf::pptr()) is a null pointer, returns zero. Otherwise, returns the next pointer in the put area minus the beginning pointer in the put area, that is pptr() - pbase(). Parameters (none). Return value The number of characters written to the put area. Example #include <strstream> #include <iostream> int main() { std::strstream

std::is_placeholder

Defined in header <functional> template< class T > struct is_placeholder; (since C++11) If T is the type of a standard placeholder (_1, _2, _3, ...), then this template is derived from std::integral_constant<int,1>, std::integral_constant<int,2>, std::integral_constant<int,3>, respectively. If T is not a standard placeholder type, this template is derived from std::integral_constant<int,0> The template may be specialized for any user-defined T

unordered_set

This header is part of the containers library. Includes <initializer_list> (C++11) Classes unordered_set (since C++11) collection of unique keys, hashed by keys (class template) unordered_multiset (since C++11) collection of keys, hashed by keys (class template) Functions operator==operator!= compares the values in the unordered_set (function template) std::swap(std::unordered_set) (C++11) specializes the std::swap algorithm (function template) o

std::exponential_distribution

Defined in header <random> template< class RealType = double > class exponential_distribution; (since C++11) Produces random non-negative floating-point values x, distributed according to probability density function: P(x|λ) = λe. -λx The value obtained is the time/distance until the next random event if random events occur at constant rate λ per unit of time/distance. For example, this distribution describes the time between the clicks of a Geiger counter or the

operator&lt;&lt;(std::basic_ostream)

(1) template< class CharT, class Traits> basic_ostream<CharT,Traits>& operator<<( basic_ostream<CharT,Traits>& os, CharT ch ); template< class CharT, class Traits> basic_ostream<CharT,Traits>& operator<<( basic_ostream<CharT,Traits>& os, char ch ); template< class Traits > basic_ostream<char,Traits>& operator<<( basi

std::basic_ostream

Defined in header <ostream> template< class CharT, class Traits = std::char_traits<CharT> > class basic_ostream : virtual public std::basic_ios<CharT, Traits> The class template basic_ostream provides support for high level output operations on character streams. The supported operations include formatted output (e.g. integer values) and unformatted output (e.g. raw characters and character arrays). This functionality is implemented in terms of t

std::atanh(std::complex)

Defined in header <complex> template< class T > complex<T> atanh( const complex<T>& z ); (since C++11) Computes the complex arc hyperbolic tangent of z with branch cuts outside the interval [−1; +1] along the real axis. Parameters z - complex value Return value If no errors occur, the complex arc hyperbolic tangent of z is returned, in the range of a half-strip mathematically unbounded along the real axis and in the interval [−iπ/2; +iπ/

std::valarray::swap

void swap( valarray& other ); Swaps the contents with those of other. Parameters other - another valarray to swap the contents with Return value (none). Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11)