<think>在C++中，向`
std::vector`插入多个元素有多种方法。根据引用[1]提供的`vector
::insert
()`
函数语法，我们可以
使用它的重载版本一次性插入多个元素。以下是几种常见方法：
### 1
. **
使用`insert
()`插入多个相同元素**
```cpp
// 语法：vector
::insert(iterator position,
size_type n, const value_type& val);
std::vector<int> vec = {1, 2, 3};
// 在索引1处插入3个值为42的元素
vec
.insert(vec
.begin
() + 1, 3, 42);
// 结果：vec = {1, 42, 42, 42, 2, 3}
```
### 2
. **
使用`insert
()`插入另一个容器的元素范围**
```cpp
// 语法：vector
::insert(iterator position, InputIterator first, InputIterator last);
std::vector<int> source = {10, 20, 30};
std::vector<int> target = {1, 2, 3};
// 在target的末尾插入source的全部元素
target
.insert(target
.end
(), source
.begin
(), source
.end
());
// 结果：target = {1, 2, 3, 10, 20, 30}
```
### 3
. **
使用初始化列表（C++11及以上）**
```cpp
// 语法：vector
::insert(iterator position, initializer_
list<value_type> il);
std::vector<int> vec = {1, 2, 3};
// 在开头插入多个元素（直接通过花括号指定）
vec
.insert(vec
.begin
(), {99, 100, 101});
// 结果：vec = {99, 100, 101, 1, 2, 3}
```
### 4
. **结合`
std::move`高效插入（C++11及以上）**
当插入的元素来自临时容器或需要转移所有权时，
使用`
std::move`避免复制（引用[2]提到）：
```cpp
std::vector<
std::string> vec = {"a", "b"};
std::vector<
std::string> temp = {"x", "y", "z"};
//
使用move迭代器转移元素所有权
vec
.insert(vec
.end
(),
std::make_move_iterator(temp
.begin
()),
std::make_move_iterator(temp
.end
()));
// 结果：vec = {"a", "b", "x", "y", "z"}, temp变为空或未定义状态
```
### 5
. **循环插入（不推荐，
效率低）**
如果需要插入的元素是动态生成的，可循环调用`insert
()`，但性能较差（$O(n^2)$）：
```cpp
std::vector<int> vec = {1, 2, 3};
for (int i = 0; i < 3; ++i) {
// 每次插入都在开头插入一个元素（
效率极低！）
vec
.insert(vec
.begin
(), i + 10);
}
// 结果：vec = {12, 11, 10, 1, 2, 3}
```
### 性能注意事项
- **时间复杂度**：`insert
()`在非末尾位置插入时，需要移动后续元素。若插入$k$个元素，时间复杂度为$O(n + k)$。
- **迭代器失效**：插入操作可能导致vector扩容，使所有迭代器失效。
- **优化建议**：
- 在插入前
使用`reserve
()`预分配足够空间。
- 优先在末尾插入（用`push_back
()`或`insert
()`到`end
()`）。
### 完整示例
```cpp
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
int main
() {
std::vector<int> base = {1, 5, 6};
// 方法1：插入3个42
base
.insert(base
.begin
() + 1, 3, 42);
// base
: {1, 42, 42, 42, 5, 6}
// 方法2：插入另一个容器的范围
std::vector<int> ext = {7, 8, 9};
base
.insert(base
.end
(), ext
.begin
(), ext
.end
());
// base
: {1, 42, 42, 42, 5, 6, 7, 8, 9}
// 方法3：插入初始化列表
base
.insert(base
.begin
(), {-1, 0});
// base
: {-1, 0, 1, 42, 42, 42, 5, 6, 7, 8, 9}
// 输出结果
for (int num
: base) {
std::cout << num << " ";
}
return 0;
}
```
### 总结
向`
std::vector`插入多个元素时，优先选择：
1
. **批量插入相同值**：`insert(position, count, value)`
2
. **插入另一个容器的范围**：`insert(position, start_iter, end_iter)`
3
. **直接插入初始化列表**（C++11）：`insert(position, {elem1, elem2,
...})`
结合`
std::move`可进一步提升大型对象插入的
效率[^2]。
§§相关问题§§
1
. 如何避免在`
std::vector`中间插入元素时的性能损失？
2
. `
std::vector`的`insert
()`方法与其他容器（如`
std::list`）有何性能差异？
3
. 在C++17/20中，`
std::vector`插入操作有哪些新特性？</think>### 在 C++
std::vector 中插入多个元素的方法
在 C++ 中，向 `
std::vector` 插入多个元素主要有以下几种高效方法（基于引用[1]提供的 `vector
::insert
()` 语法）：
#### 1
. **插入多个相同值的元素** [^1]
```cpp
// 语法：vector
::insert(iterator position,
size_type n, const value_type& val);
std::vector<int> vec = {1, 2, 3};
vec
.insert(vec
.begin
() + 1, 3, 42); // 在索引1处插入3个42
// 结果：{1, 42, 42, 42, 2, 3}
```
#### 2
. **插入另一个容器的元素范围** [^1]
```cpp
// 语法：vector
::insert(iterator position, InputIterator first, InputIterator last);
std::vector<int> source = {10, 20, 30};
std::vector<int> target = {1, 2, 3};
target
.insert(target
.end
(), source
.begin
(), source
.end
()); // 在末尾插入source的全部元素
// 结果：{1, 2, 3, 10, 20, 30}
```
#### 3
. **
使用初始化列表（C++11 及以上）**
```cpp
std::vector<int> vec = {1, 2, 3};
vec
.insert(vec
.begin
(), {99, 100, 101}); // 在开头插入多个元素
// 结果：{99, 100, 101, 1, 2, 3}
```
#### 4
. **结合 `
std::move` 高效插入（C++11 及以上）** [^2]
当插入的元素来自临时容器时，
使用移动语义避免复制：
```cpp
std::vector<
std::string> vec = {"a", "b"};
std::vector<
std::string> temp = {"x", "y", "z"};
vec
.insert(vec
.end
(),
std::make_move_iterator(temp
.begin
()),
std::make_move_iterator(temp
.end
()));
// vec
: {"a", "b", "x", "y", "z"}，temp 内容被转移
```
#### 5
. **
使用 `back_inserter` 和算法（适用于连续添加）**
```cpp
#include <iterator>
#include <algorithm>
std::vector<int> vec = {1, 2};
int new_data[] = {5, 6, 7};
std::copy(
std::begin(new_data),
std::end(new_data),
std::back_inserter(vec));
// 结果：{1, 2, 5, 6, 7}
```
### 性能优化建议
1
. **预分配空间**
插入前
使用 `reserve
()` 避免多次扩容：
```cpp
std::vector<int> vec;
vec
.reserve(100); // 预分配空间
vec
.insert(vec
.end
(), { /* 大量元素 */ }); // 高效插入
```
2
. **优先在末尾插入**
在末尾插入（
使用 `end
()` 迭代器）
效率最高，时间复杂度 $O(1)$ 均摊。
3
. **避免中间插入**
在中间插入需要移动后续元素，时间复杂度 $O(n)$。若需频繁中间插入，考虑 `
std::list`。
### 完整示例
```cpp
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
int main
() {
std::vector<int> base = {1, 5, 6};
// 方法1：插入3个相同值
base
.insert(base
.begin
() + 1, 3, 42); // {1, 42, 42, 42, 5, 6}
// 方法2：插入另一个容器的范围
std::vector<int> ext = {7, 8, 9};
base
.insert(base
.end
(), ext
.begin
(), ext
.end
()); // {1,42,42,42,5,6,7,8,9}
// 方法3：插入初始化列表
base
.insert(base
.begin
(), {-1, 0}); // {-1,0,1,42,42,42,5,6,7,8,9}
// 输出结果
for (int num
: base) {
std::cout << num << " ";
}
// 输出
: -1 0 1 42 42 42 5 6 7 8 9
return 0;
}
```
### 关键点总结
| 方法 | 适用场景 | 时间复杂度 |
|--------------------------|-----------------------------------|------------------|
| `insert(pos, n, value)` | 插入多个相同值 | $O(n + m)$¹ |
| `insert(pos, start, end)`| 插入另一个容器的元素范围 | $O(n + m)$¹ |
| `insert(pos, {a,b,c})` | 直接插入初始化列表（C++11） | $O(n + m)$¹ |
| `back_inserter` + 算法 | 流式插入（如从文件/网络读取数据） | $O(m)$² |
> ¹ *n = 原容器大小, m = 插入元素数量*
> ² *仅当已预分配足够空间时成立*
本文介绍了一个在Linux环境下库函数效率低的问题，并详细解释了std::list.size()为何效率低下。通过替换为!aList.empty()解决了性能瓶颈。
扫一扫
841
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
