C++ 具名要求：容器 (Container)

来自cppreference.com
See More


 
C++
 
C++ 具名要求
 

容器 (Container) 是用于存储其他对象并负责管理那些对象使用的内存的对象。

要求

给定以下类型和值：

类型 定义
T 对象类型
C 包含 T 类型对象的容器类
值 定义
u, v C 或 const C 类型的值
mv C 类型的值
cv const C 类型的值
lhs，rhs C 类型的左值
i，j C::iterator 或 const C::iterator 类型的值

C 在以下类型，语句和表达式都良构并具有指定的语义时满足容器 (Container) ：

类型

类型 定义 要求
typename C::value_type T T 可复制构造 (CopyConstructible) (C++11 前)从 C 可擦除 (Erasable) (C++11 起)。
typename C::reference T& 无显式要求
typename C::const_reference const T&
typename C::iterator 迭代器类型
typename C::const_iterator 常迭代器类型 C::const_iterator 是老式向前迭代器 (LegacyForwardIterator) ，并且它的值类型 是 T。
typename C::difference_type 有符号整数类型  C::difference_type 与 C::iterator 和 C::const_iterator 的差类型相同。
typename C::size_type 无符号整数类型 C::size_type 足以表示 C::difference_type 的所有非负值。

语句

语句 语义  复杂度 
C c;

C c = C();

后条件  c.empty() 是 true。 常数
C c(v);

C c = C(v);

前条件

如果 v 不是 C 类型右值，那么 T 可复制插入 (CopyInsertable) 到 C 中。

(C++11 起)
 线性[1]
后条件
  • 如果 v 是左值，那么 c == v 是 true.
  • 如果 v 是右值，并且 c 和 v 表示不同对象(C++11 起)，那么 c 等于 v 在本次构造之前的值。
注解
  1. ↑ 如果 v 是 C 类型右值，并且 C 不是 std::array 或 std::inplace_vector 的特化，那么复杂度是常数。

表达式

表达式 类型 语义  复杂度 
C() C 后条件  C().empty() 是 true。 常数
C(v) C 前条件

如果 v 不是 C 类型右值，那么 T 可复制插入 (CopyInsertable) 到 C 中。

(C++11 起)
 常数[1]
后条件
  • 如果 v 是左值，那么 C(v) == v 是 true。
  • 如果 v 是右值，并且 C(v) 和 v 表示不同对象(C++11 起)，那么 C(v) 等于 v 在本次构造之前的值。
lhs = v C& 后条件
  • 如果 v 是左值，那么 lhs == v 是 true。
  • 如果 v 是右值，并且 lv 和 v 表示不同对象(C++11 起)，那么 lhs 等于 v 在本次赋值之前的值。
 线性
v.~C() void 效果 销毁 v 的所有元素并解分配所有获取到的内存。 线性
mv.begin() C::iterator 效果 返回指向 mv 的首元素的迭代器。 常数
cv.begin() C::const_iterator 效果 返回指向 cv 的首元素的迭代器。 常数
mv.end() C::iterator 效果 返回 mv 的尾后迭代器。 常数
cv.end() C::const_iterator 效果 返回 cv 的尾后迭代器。 常数
v.cbegin()
(C++11 起) 		C::const_iterator 效果 返回 const_cast<const C&>(v).begin()， 常数
v.cend()
(C++11 起) 		C::const_iterator 效果 返回 const_cast<const C&>(v).end()， 常数
i <=> j
(C++20 起) 		std::strong_ordering     约束 此表达式只要求在 C::iterator 满足随机访问迭代器时良构。 常数
u == v bool 效果 返回
u.size() == v.size() &&
std::equal(u.begin(),
u.end(), v.begin())		 (C++14 前)
std::equal(u.begin(), u.end(),
v.begin(), v.end())		 (C++14 起)
。 		线性[2]
u != v 效果 等价于 !(u == v)。
lhs.swap(rhs)

swap(lhs, rhs)

void 效果 交换 lhs 与 rhs 的内容。 常数[3]
v.size() C::size_type 效果 返回 v 的元素数量。[4] 常数
v.max_size() C::size_type 效果 返回可能存在的最大 C 类型容器的元素数量。 常数
v.empty() bool 效果 返回 v.begin() == v.end()。 常数
可选容器要求
（仅对某些类型的容器提供）
u <=> v
(C++20 起) 		synth-three-way-result
    <C::value_type> 		前条件 要么 T 实现 three_way_comparable，要么 operator< 是一种对 T 和 const T 类型的值定义的全序关系。 线性
效果 返回 std::lexicographical_compare_three_way
    (u.begin(), u.end(),
     v.begin(), v.end(),
     synth-three-way )[5]。
注解
  1. ↑ 如果 v 是 C 类型右值，并且 C 是 std::array 或 std::inplace_vector 的特化，那么复杂度是线性。
  2. ↑ 如果 u.size() != v.size() 是 true，那么复杂度是常数。
  3. ↑ 如果 C 是 std::array 或 std::inplace_vector 的特化，那么复杂度是线性。
  4. ↑ 元素数量由构造函数，插入和擦除的规则定义。它等于 std::distance(v.begin(), v.end()) 的值。
  5. ↑ 如果传递给 std::lexicographical_compare_three_way 的迭代器是常量表达式迭代器 (ConstexprIterator) ，那么操作会由 constexpr 函数实现。

在表达式 i == j、i != j、i < j、i <= j、i >= j、i > j 和 i - j 中，如果 i 和/或 j 分别被替换为指向相同元素的 C::const_iterator 类型迭代器，那么语义保持不变。

容器数据竞争

见容器线程安全。

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
LWG 179 C++98 iterator 与 const_iterator 类型可能不可比较 要求可比较
LWG 276 C++98 T 要求 可复制赋值 (CopyAssignable) T 要求 可复制构造 (CopyConstructible)
LWG 322 C++98 未指定 iterator 与 const_iterator 的值类型 指定为 T
LWG 774 C++98 对 swap(a, b) 没有要求 已补充
LWG 883 C++98 a.swap(b) 被定义为 swap(a, b)，导致循环定义 定义为交换 a 和 b 的值
LWG 1319 C++98 iterator 和 const_iterator 不一定有多趟保证 它们需要满足
老式向前迭代器 (LegacyForwardIterator)
LWG 2114
(P2167R3) 		C++98 曾允许某些函数的非 bool 返回类型 已禁止
LWG 2182 C++98 reference 和 const_reference 表示的类型未被良好指定 改进用词
LWG 2257 C++98 两个容器即使大小不同也需要线性时间比较相等 此时只需要常数时间
LWG 2263 C++11 LWG 问题 179 的解决方案在 C++11 中被意外丢弃 已恢复
LWG 2839 C++11 不允许标准容器的自移动赋值 容许但结果未指定
N3346 C++11 C::value_type 要求可析构 (Destructible) 要求从 C 可擦除 (Erasable)

参阅

容器库的 C++ 文档