Usage alternative operators: as an alternative for !=

Defined in header <ctime> char* ctime( const std::time_t* time ); Converts given time since epoch to a calendar local time and then to a textual representation, as if by calling std::asctime(std::localtime(time)). The resulting string has the following format: Www Mmm dd hh:mm:ss yyyy Www - the day of the week (one of Mon, Tue, Wed, Thu, Fri, Sat, Sun). Mmm - the month (one of Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec). dd - the day of the month hh -

template<class T1, class D1, class T2, class D2> bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); (1) (since C++11) template<class T1, class D1, class T2, class D2> bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); (2) (since C++11) template<class T1, class D1, class T2, class D2> bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y)

This header is part of the general utility library. Includes <initializer_list>(C++11) Namespaces rel_ops Provide automatic comparison operators Defined in namespace std::rel_ops operator!=operator>operator<=operator>= automatically generates comparison operators based on user-defined operator== and operator< (function template) Functions swap swaps the values of two objects (function template) exchange (C++14) replaces the argument with a

void sort(); (1) (since C++11) template< class Compare > void sort( Compare comp ); (2) (since C++11) Sorts the elements in ascending order. The order of equal elements is preserved. The first version uses operator< to compare the elements, the second version uses the given comparison function comp. Parameters comp - comparison function object (i.e. an object that satisfies the requirements of Compare) which returns ​true if the first argument is less than (i.e.

Non-static data members are the variables that are declared in a member specification of a class. class S { int n; // non-static data member int& r; // non-static data member of reference type int a[10] = {1,2}; // non-static data member with initializer (C++11) std::string s, *ps; // two non-static data members struct NestedS { std::string s; } d5, *d6; // two non-static data members of nested type char bit : 2; // two-bit bitfield }; Any simple declarat

Defined in header <valarray> class gslice; std::gslice is the selector class that identifies a subset of std::valarray indices defined by a multi-level set of strides and sizes. Objects of type std::gslice can be used as indices with valarray's operator[] to select, for example, columns of a multidimensional array represented as a valarray. Given the starting value s, a list of strides ij and a list of sizes dj, a std::gslice constructed from these values selects the set of

void open( const char *filename, ios_base::openmode mode = ios_base::out ); (1) void open( const std::string &filename, ios_base::openmode mode = ios_base::out ); (2) (since C++11) Opens and associates the file with name filename with the file stream. Calls setstate(failbit) on failure. Calls clear() on success. (since C++11) 1) Effectively calls rdbuf()->open(filename, mode | ios_base::out). (see std::basic_filebuf

Defined in header <thread> void yield(); (since C++11) Provides a hint to the implementation to reschedule the execution of threads, allowing other threads to run. Parameters (none). Return value (none). Notes The exact behavior of this function depends on the implementation, in particular on the mechanics of the OS scheduler in use and the state of the system. For example, a first-in-first-out realtime scheduler (SCHED_FIFO in Linux) would suspend the current thre

template< class CharT, class Traits, class Alloc > void swap( std::basic_ostringstream<CharT,Traits,Alloc>& lhs, std::basic_ostringstream<CharT,Traits,Alloc>& rhs ); Specializes the std::swap algorithm for std::basic_ostringstream. Exchanges the state of lhs with that of rhs. Effectively calls lhs.swap(rhs). Parameters lhs, rhs - streams whose state to swap Return value (none). Exceptions (none). Example See also swap (C++11