# C++ concepts: Container

From cppreference.com
< cpp‎ | concept

A `Container` is an object used to store other objects and taking care of the management of the memory used by the objects it contains.

### Requirements

- `C` container type;
- `T` element type;
- `a`, `b` objects of type `C`.

#### Types

name | type | notes
--- | --- | ---
`value_type` | T | `Eraseable`
`reference` | T& |
`const_reference` | const T& |
`iterator` | iterator pointing to T | `ForwardIterator` convertible to `const_iterator`
`const_iterator` | const iterator pointing to T | `ForwardIterator`
`difference_type` | signed integer | must be the same as `iterator_traits::difference_type` for `iterator` and `const_iterator`
`size_type` | unsigned integer | large enough to represent all positive values of `difference_type`

#### Methods and operators

expression | return type | semantics | conditions | complexity
--- | --- | --- | --- | ---
C() | C | creates an empty container | Post: C().empty() == true | Constant
C(a) | C | creates a copy of `a` | Pre: T must be `CopyInsertable` Post: a == C(a) | Linear
a = b | C& | destroys or move-assigns all elements of `a` from elements of `b` | Post: a == b | Linear
(&a)->~C() | void | destroys all elements of `a` and frees all memory |  | Linear
a.begin() | (const_)iterator | Iterator to the first element of `a` |  | Constant
a.end() | (const_)iterator | Iterator to one past the last element of `a` |  | Constant
a.cbegin()(since C++11) | const_iterator | const_cast<const C&>(a).begin() |  | Constant
a.cend()(since C++11) | const_iterator | const_cast<const C&>(a).end() |  | Constant
a == b | convertible to bool | std::equal(a.begin(), a.end(), b.begin(), b.end())(since C++14) | Pre: T must be `EqualityComparable` | Constant[1] if `a.size() != b.size()`, linear otherwise
a != b | convertible to bool | !(a == b) |  | Linear
a.swap(b) | void | exchanges the values of `a` and `b` |  | Constant[2][3]
swap(a, b) | void | a.swap(b) |  | Constant[2]
a.size() | size_type | distance(a.begin(), a.end()) |  | Constant[3]
a.max_size() | size_type | b.size() where `b` is the largest possible container |  | Constant[3]
a.empty() | convertible to bool | a.begin() == a.end() |  | Constant
notes

1. ↑ always linear for std::forward_list
2. ↑ 2.0 2.1 (since C++11) Linear for std::array
3. ↑ 3.0 3.1 3.2 (until C++11) Not strictly constant

Given

- `i` and `j`, objects of a container's `iterator` type,

in the expressions i == j, i != j, i < j, i <= j, i >= j, i > j, i - j, either or both may be replaced by an object of the container's `const_iterator` type referring to the same element with no change in semantics.

(since C++14)

### Container data races

see container thread safety

### Other concepts

C

- `DefaultConstructible`
- `CopyConstructible`
- `EqualityComparable`
- `Swappable`

T

- `CopyInsertable`
- `EqualityComparable`
- `Destructible`

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/concept/Container&oldid=83369"