Container

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	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` (since C++11) Linear for `std::array` (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

T

Links:

http://en.cppreference.com/w/cpp/concept/Container

doc_CPP

2016-10-11 09:58:04

Comments