Difference between revisions of "cpp/named req"
From cppreference.com
< cpp
(+eraseable) |
D41D8CD98F (Talk | contribs) (+DefaultInsertable) |
||
| Line 47: | Line 47: | ||
{{dsc concept | cpp/concept/UnorderedAssociativeContainer | container that stores elements stored in buckets by associating them to keys | notes={{mark c++11}} }} | {{dsc concept | cpp/concept/UnorderedAssociativeContainer | container that stores elements stored in buckets by associating them to keys | notes={{mark c++11}} }} | ||
{{dsc h2 | Container element}} | {{dsc h2 | Container element}} | ||
| + | {{dsc concept | cpp/concept/DefaultInsertable| element can be default-constructed in uninitialized storage | notes={{mark c++11}} }} | ||
{{dsc concept | cpp/concept/CopyInsertable| element can be copy-constructed in uninitialized storage | notes={{mark c++11}} }} | {{dsc concept | cpp/concept/CopyInsertable| element can be copy-constructed in uninitialized storage | notes={{mark c++11}} }} | ||
{{dsc concept | cpp/concept/MoveInsertable| element can be move-constructed in uninitialized storage | notes={{mark c++11}} }} | {{dsc concept | cpp/concept/MoveInsertable| element can be move-constructed in uninitialized storage | notes={{mark c++11}} }} | ||
{{dsc concept | cpp/concept/EmplaceConstructible| element can be constructed in uninitialized storage | notes={{mark c++11}} }} | {{dsc concept | cpp/concept/EmplaceConstructible| element can be constructed in uninitialized storage | notes={{mark c++11}} }} | ||
| − | {{dsc concept | cpp/concept/ | + | {{dsc concept | cpp/concept/Erasable| element can be destroyed using an allocator | notes={{mark c++11}} }} |
{{dsc h1 | Iterator}} | {{dsc h1 | Iterator}} | ||
Revision as of 04:27, 21 September 2014
A concept is a term that describes a named set of requirements for a type. Concepts are a more convenient way to specify both what properties are expected from a type, and what properties a type has.
There is a proposal to include a formal specification of concepts into a future revision of C++. This proposal allows compilers to check type requirements before template instantiations, allowing much more sensible error messages when those types do not fulfill the template requirements. (This proposal replaces the original C++11 concepts proposal, which was dropped for various reasons.)
Here concepts have little in common with the abovementioned proposal. They refer to informal named requirements, used in the C++03 and C++11 standards to define behavior and expected properties for various types.
Basic | ||
| specifies that an object of the type can be default constructed (concept) | ||
| (C++11) |
specifies that an object of the type can be constructed from rvalue (concept) | |
| specifies that an object of the type can be constructed from lvalue (concept) | ||
| (C++11) |
specifies that an object of the type can be assigned from rvalue (concept) | |
| specifies that an object of the type can be assigned from lvalue (concept) | ||
| specifies that type has a destructor (concept) | ||
Layout | ||
| Note, that the standard doesn't define named requirements or concepts with names specified in this subcategory. These are type categories defined by the core language. They are included here as concepts only for consistency. | ||
| (C++11) |
class with trivial copy, assignment and destructor (concept) | |
| (C++11) |
class with trivial constructors, assignment and destructor (concept) | |
| (C++11) |
non-virtual class containing only other StandardLayout members, all with the same access control (concept) | |
| POD (Plain Old Data) structure, compatible with C struct (concept) | ||
Library-wide | ||
has a working operator== that is an equivalence relation (concept) | ||
operator< is a strict weak ordering relation (concept) | ||
| (C++11) |
can be swapped with an unqualified non-member function call swap() (concept) | |
| (C++11) |
an Template:concept that dereferences to a Template:concept type (concept) | |
| (C++11) |
pointer-like type supporting a null value (concept) | |
| (C++11) |
a Template:concept that for inputs with different values has a low probability of giving the same output (concept) | |
| class type that contains allocation information (concept) | ||
| an object that can be called with the function call syntax (concept) | ||
| a type for which the invoke operation is defined (concept) | ||
| a Template:concept that returns a value convertible to bool for one argument without modifying it (concept) | ||
| a Template:concept that returns a value convertible to bool for two arguments without modifying them (concept) | ||
| a Template:concept that establishes an ordering relation (concept) | ||
Container | |
| data structure that allows element access using iterators (concept) | |
| container using bidirectional iterators (concept) | |
| (C++11) |
container using an allocator (concept) |
| container with elements stored linearly (concept) | |
| container that stores elements by associating them to keys (concept) | |
| container that stores elements stored in buckets by associating them to keys (concept) | |
Container element | |
| (C++11) |
element can be default-constructed in uninitialized storage (concept) |
| (C++11) |
element can be copy-constructed in uninitialized storage (concept) |
| (C++11) |
element can be move-constructed in uninitialized storage (concept) |
| (C++11) |
element can be constructed in uninitialized storage (concept) |
| (C++11) |
element can be destroyed using an allocator (concept) |
Iterator | |
| general concept to access data within some data structure (concept) | |
| iterator that can be used to read data (concept) | |
| iterator that can be used to write data (concept) | |
| iterator that can be used to read data multiple times (concept) | |
| iterator that can be both incremented and decremented (concept) | |
| iterator that can be advanced in constant time (concept) | |
Stream I/O functions | |
| a stream input function that doesn't skip whitespace and counts the processed characters (concept) | |
| a stream input function that skips leading whitespace (concept) | |
| a basic stream output function (concept) | |
| a stream output function that sets failbit on errors and returns a reference to the stream (concept) | |
Random Number Generation | |
| (C++11) |
consumes a sequence of integers and produces a sequence of 32-bit unsigned values (concept) |
| (C++11) |
returns uniformly distributed random unsigned integers (concept) |
| (C++11) |
a deterministic Template:concept, defined by the seed (concept) |
| (C++11) |
a Template:concept that transforms the output of another Template:concept (concept) |
| (C++11) |
returns random numbers distributed according to a given mathematical probability density function (concept) |
Concurrency | |
| (C++11) |
provides exclusive ownership semantics for execution agents (i.e. threads) (concept) |
| (C++11) |
adds attempted lock acquisition to Template:concept (concept) |
| (C++11) |
adds timed lock acquisition to Template:concept (concept) |
| (C++11) |
a Template:concept that protects against data races and sequentially consistent synchronization (concept) |
| (C++11) |
a Template:concept that protects against data races and sequentially consistent synchronization (concept) |
| (C++14) |
a Template:concept that supports shared ownership mode (concept) |
Other | |
| (C++11) |
describes a property of a type (concept) |
| (C++11) |
describes a relationship between two types (concept) |
| (C++11) |
modifies a property of a type (concept) |
| (C++11) |
aggregates a duration, a time point, and a function to get the current time point (concept) |
| (C++11) |
a Template:concept that doesn't throw exceptions (concept) |
| defines types and functions for a character type (concept) | |
| represents a position in a stream (concept) | |
| represents an offset in a stream (concept) | |
| bitset, integer, or enumeration (concept) | |
| a type for which initialization is effectively equal to assignment (concept) | |
| (C++11) |
defines types and functions used by the regular expressions library (concept) |
| (C++11) |
a type with constexpr constructor (concept) |
| This section is incomplete Reason: Any other missing concept? |
