Error directive

Shows given message and renders program ill-formed. Syntax #error error_message Explanation After encountering #error directive, diagnostic message error_message is shown and the program is rendered ill-formed (the compilation is stopped). error_message can consist of several words not necessarily in quotes. See also C documentation for Error directive

std::prev

Defined in header <iterator> template< class BidirIt > BidirIt prev( BidirIt it, typename std::iterator_traits<BidirIt>::difference_type n = 1 ); (since C++11) Return the nth predecessor of iterator it. Parameters it - an iterator n - number of elements it should be descended Type requirements - BidirIt must meet the requirements of BidirectionalIterator. Return value The nth predecessor of iterator it. Possible implement

std::multimap::emplace

template< class... Args > iterator emplace( Args&&... args ); (since C++11) Inserts a new element into the container by constructing it in-place with the given args . Careful use of emplace allows the new element to be constructed while avoiding unnecessary copy or move operations. The constructor of the new element (i.e. std::pair<const Key, T>) is called with exactly the same arguments as supplied to emplace, forwarded via std::forward<Args>(args).... No iter

std::list::get_allocator

allocator_type get_allocator() const; Returns the allocator associated with the container. Parameters (none). Return value The associated allocator. Complexity Constant.

std::list::pop_front

void pop_front(); Removes the first element of the container. References and iterators to the erased element are invalidated. Parameters (none). Return value (none). Complexity Constant. Exceptions Does not throw. See also pop_back removes the last element (public member function) push_front inserts an element to the beginning (public member function)

std::negative_binomial_distribution::negative_binomial_distribution

explicit negative_binomial_distribution( IntType k = 1, double p = 0.5 ); (1) (since C++11) explicit negative_binomial_distribution( const param_type& params ); (2) (since C++11) Constructs a new distribution object. The first version uses k and p as the distribution parameters, the second version uses params as the distribution parameters. Parameters k - the k distribution parameter (number of trial failures) p - the p distribution parameter (probability of a tr

operators (std::piecewise_linear_distribution)

template< class ResultType > bool operator==( const piecewise_linear_distribution<ResultType>& lhs, const piecewise_linear_distribution<ResultType>& rhs ); (1) template< class ResultType > bool operator!=( const piecewise_linear_distribution<ResultType>& lhs, const piecewise_linear_distribution<ResultType>& rhs ); (2) Compares two distribution objects. Two distribution objects are equal when para

std::wcscpy

Defined in header <cwchar> wchar_t *wcscpy( wchar_t *dest, const wchar_t *src ); Copies the wide string pointed to by src (including the terminating null wide character) to wide character array pointed to by dest. If the strings overlap, the behavior is undefined. Parameters dest - pointer to the wide character array to copy to src - pointer to the null-terminated wide string to copy from Return value dest. Example #include <iostream> #include

std::basic_string::npos

static const size_type npos = -1; This is a special value equal to the maximum value representable by the type size_type. The exact meaning depends on context, but it is generally used either as end of string indicator by the functions that expect a string index or as the error indicator by the functions that return a string index. Example #include <iostream> #include <bitset> #include <string> int main() { // string search functions return npos if nothing i

std::multiset::emplace_hint

template <class... Args> iterator emplace_hint( const_iterator hint, Args&&... args ); (since C++11) Inserts a new element to the container as close as possible to the position just before hint. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments as supplied to the function, forwarded with std::forward<Args>(args).... No iterators or references are invalidated.