概述

简化

template< typename T, /* ... */ >
class vector;

详细

常规

template<
    class T,
    class Allocator = std::allocator<T>
> class vector;

多态版 (C++17 起)

namespace pmr {
    template< class T >
    using vector = std::vector<T, std::pmr::polymorphic_allocator<T>>;
}

std::vector 是一个封装动态大小数组的容器。

内存

元素连续存储，一个接一个。这意味着指向 `vector` 元素的指针可以传递给任何期望指向数组元素的指针的函数。

存储大小

vector 的存储是自动处理的，根据需要进行扩展和收缩。Vector 通常比静态数组占用更多的空间，因为分配了更多的内存来处理未来的增长。这样，vector 就不需要在每次插入元素时重新分配，而只在额外内存耗尽时才重新分配。分配的总内存量可以通过 capacity() 函数查询。通过调用 shrink_to_fit() 可以将额外内存返回给系统 (C++11 起)

重新分配通常是代价高昂的性能操作。如果预先知道元素的数量，可以使用 reserve() 函数消除重新分配。

技术细节

复杂度

对向量的常见操作的复杂度（效率）如下：

• 随机访问 - 常数 𝓞(1)
• 在末尾插入或删除元素 - 均摊常数 𝓞(1)
• 插入或删除元素 - 与到向量末尾的距离呈线性关系 𝓞(n)

命名要求

std::vector（对于 T 并非 bool 的情况）满足以下要求：

• 容器
• AllocatorAwareContainer
• SequenceContainer
• ContiguousContainer (C++17 起)
• ReversibleContainer

模板类型要求

T

自 C++17 起

对元素的要求取决于在容器上执行的实际操作。通常，要求元素类型满足可擦除（Erasable）的要求，但许多成员函数施加了更严格的要求。如果分配器满足分配器完整性要求，则此容器（但不是其成员）可以使用不完整的元素类型进行实例化。

C++17 之前

对元素的要求取决于在容器上执行的实际操作。通常，要求元素类型是完整类型并满足可擦除（Erasable）的要求，但许多成员函数施加了更严格的要求。

直到 C++11

T 必须满足 CopyAssignable 和 CopyConstructible 的要求。

分配器

类型必须满足 Allocator 的要求。

自 C++20 起

如果 Allocator::value_type 与 T 不相同，则程序为非良构.

直到 C++20

如果 Allocator::value_type 与 T 不相同，则行为未定义.

std::向量

定义于

向量

模板参数

有关更详细的信息，请参阅技术细节。

公共	T	元素的类型。
公共	分配器	用于获取/释放内存以及在该内存中构造/销毁元素的分配器。

类型名称

公共	值类型	T
公共	分配器类型	分配器
公共	大小类型	无符号整型（通常是std::size_t）
公共	差异类型	有符号整型（通常是std::ptrdiff_t）
公共	引用	值类型&
公共	常量引用	值类型 const&
公共	指针	Allocator::pointer (直到 C++11) std::allocator_traits<Allocator>::pointer (自 C++11 起)
公共	常量指针	Allocator::const_pointer (直到 C++11) std::allocator_traits<Allocator>::const_pointer (自 C++11 起)
公共	迭代器	到 value_type 的 LegacyRandomAccessIterator 和 LegacyContiguousIterator  (直到 C++20) 到 value_type 的 LegacyRandomAccessIterator 和 LegacyConstexprIterator 和 contiguous_iterator  (自 C++20 起)
公共	常量迭代器	到 value_type 的 LegacyRandomAccessIterator 和 LegacyContiguousIterator  (直到 C++20) 到 const value_type 的 LegacyRandomAccessIterator、LegacyConstexprIterator 和 contiguous_iterator  (自 C++20 起)
公共	反向迭代器	std::reverse_iterator<迭代器>
公共	常量反向迭代器	std::reverse_iterator<const_iterator>

成员函数

公共	（构造函数）	构造一个向量。
公共	（析构函数）	销毁向量，如果使用了内部存储则释放。
公共	operator=	将值分配给容器。
公共	赋值	将值分配给容器。
公共	获取分配器	返回关联的分配器。

元素访问

公共	在	带边界检查地访问指定元素。
公共	operator[]	访问指定元素。
公共	前端	返回第一个元素。
公共	末尾	返回最后一个元素。
公共	数据	返回指向底层数组第一个元素的指针。

迭代器

公共	开始 cbegin (自 C++11 起)	返回指向起始元素的iterator/const_iterator。
公共	结束 cend (自 C++11 起)	返回指向结束元素的iterator/const_iterator。
公共	rbegin crbegin (自 C++11 起)	返回一个反向 iterator/const_iterator 指向起始位置。
公共	rend crend (自 C++11 起)	返回一个反向 iterator/const_iterator 指向结束位置。

容量

公共	空	如果向量为空则返回 true，否则返回 false。
公共	大小	返回元素数量。
公共	最大大小	返回最大可能的元素数量。
公共	储备	保留存储。
公共	容量	返回当前已分配存储中可以容纳的元素数量。
公共	收缩到合适 (自 C++11 起)	通过释放未使用的内存来减少内存使用。

操作

公共	清除	清空内容。
公共	插入元素。	插入元素。
公共	就地构造 (自 C++11 起)	就地构造元素。
公共	擦除	删除元素。
公共	推入尾部	在末尾追加一个元素。
公共	就地尾部插入 (自 C++11 起)	在末尾就地构造元素。
公共	弹出尾部	删除最后一个元素。
公共	调整大小	更改存储的元素数量。
公共	交换	交换内容。

非成员函数

公共	运算符== 运算符!= (在 C++20 中移除) 运算符< (在 C++20 中移除) 运算符> (在 C++20 中移除) 运算符<= (在 C++20 中移除) 运算符>= (在 C++20 中移除) 运算符<=>	按字典顺序比较向量中的值。
公共	std::swap (std::vector)	std::swap 算法的重载。
公共	擦除 (std::vector) 擦除_如果 (std::vector)	std::erase/std::erase_if 算法的重载。

推导指南 (C++17 起)

点击展开

推导指南

// (1)
template< class InputIt,
          class Alloc = std::allocator<typename std::iterator_traits<InputIt>::value_type> >
vector( InputIt, InputIt, Alloc = Alloc() )
  -> vector<typename std::iterator_traits<InputIt>::value_type, Alloc>;

(1) 允许从**迭代器范围**进行推导。

重载决议

为了使任何推导指南参与重载决议，必须满足以下要求

• InputIt 满足 LegacyInputIterator 的要求
• Alloc 满足 Allocator 的要求

注意

库确定类型不满足 LegacyInputIterator 的程度是未指定的，但至少

• 整型不符合输入迭代器的条件。

同样，它确定类型不满足 Allocator 的程度是未指定的，但至少

• 成员类型 Alloc::value_type 必须存在。
• 当作为未求值操作数处理时，表达式 std::declval<Alloc&>().allocate(std::size_t{}) 必须是格式良好的。

示例

基本用法

计算算术平均值

#include <iostream>
#include <vector>

auto main() -> int
{
  auto const numbers = std::vector<double>{
    5, 2.4, 3.2, 1.8, 4.6,
    3.1, 2.9, 4.7, 3.8, 2.2,
  };

  auto sum = 0.0;
  for (auto number : numbers) {
    sum += number;
  }
  
  auto const mean = sum / numbers.size();
  std::cout << "Mean: " << mean << '\n';
}

结果

Mean: 3.37

查找最大元素

#include <iostream>
#include <string>
#include <algorithm>

auto main() -> int
{
  auto const numbers = std::vector<int>{
    5, 2, 8, 1, 14, 3, 2, 10, 3, 2
  };
  auto const max_it = std::max_element(
    numbers.begin(),
    numbers.end()
  );
  auto const max_index = std::distance(numbers.begin(), max_it);
  std::cout << "Max: " << *max_it << " at index: " << max_index;
}

结果

Max: 14 at index: 4

擦除第n个元素

#include <iostream>
#include <vector>
#include <string>

auto main() -> int
{
  auto player_names = std::vector<std::string>{
    "Sad Crab", "Happy Wolf", "Angry Panda",
    "Wicked Witch", "Crazy Clown", "Funny Monkey",
  };

  auto const n = 2; // arbitrary, 0-based index
  // Erase the nth element ("Angry Panda")
  player_names.erase(player_names.begin() + n);

  for (auto const& name : player_names) {
    std::cout << name << '\n';
  }
}

结果

Sad Crab
Happy Wolf
Wicked Witch
Crazy Clown
Funny Monkey