C++ concepts: Container - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# 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.

### [edit] Requirements

- `C` Container type
- `T` Element type
- `a`, `b` Objects of type `C`

#### [edit] 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`

#### [edit] Methods and operators

expression | return type | semantics | conditions | complexity
--- | --- | --- | --- | ---
C() | C | Creates an empty container | Post: C().empty() == true | Constant
C(a) | C | Create a copy of `a` | Pre: T must be `CopyInsertable` Post: a == C(a) | Linear
a = b | C& | All elements of `a` are destroyed or move assigned to elements of b | Post: a == b | Linear
(&a)->~C() | void | Destroy all elements and free all memory |  | Linear
a.begin() | (const_)iterator | Iterator to the first element |  | Constant
a.end() | (const_)iterator | Iterator to one past the last element |  | 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
↑ always linear for std::forward_list ↑ 2.0 2.1 (since C++11) Linear for std::array ↑ 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)

### [edit] Container data races

see container thread safety

### [edit] 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=75177"