C++ -- vector的元素处理

std::vector 是 C++ 标准模板库（STL）中最常用的‌序列容器‌之一。它本质上是一个‌动态数组‌，能够自动管理内存，支持在尾部高效地增加或压缩数据，并提供对元素的随机访问能力。

 核心特性

• ‌动态扩容‌：与普通数组不同，vector 的大小可以动态改变。当插入新元素导致当前容量不足时，它会自动分配一块更大的连续内存（通常按原容量的 1.5 倍或 2倍增长），将原有元素移动到新空间，并释放旧空间。
• ‌连续存储‌：元素在内存中连续存放，这使得 vector 支持通过下标进行 O(1)O(1) 时间复杂度的‌随机访问‌。
• ‌尾部操作高效‌：在末尾插入 (push_back) 或删除 (pop_back) 元素的均摊时间复杂度为 O(1)。
• ‌中间/头部操作低效‌: 在非末尾位置插入或删除元素需要移动后续所有元素，时间复杂度为 O(n)。

使用前需包含头文件 <vector> 并使用 std 命名空间。

#include <vector>
#include <iostream>
using namespace std;

元素访问

• v[i] / v.at(i)：访问索引为 i 的元素。
  • operator[]：‌不检查‌越界，速度快，越界行为未定义。
  • at()：‌检查‌越界，若越界抛出 std::out_of_range 异常，更安全。
• v.front()：返回第一个元素的引用。
• v.back()：返回最后一个元素的引用。
• v.data()：返回指向内部数组首元素的指针。

容量与大小管理

• v.size()：返回当前实际存储的元素个数。
• v.capacity()：返回当前分配的内存能容纳的元素总数（≥≥ size）。
• v.empty()：判断容器是否为空。
• v.reserve(n)：‌预分配‌至少能容纳 n 个元素的内存。若已知大致数据量，提前调用此函数可避免多次重新分配内存，提升性能。
• v.resize(n)：调整容器大小。若 n 大于当前 size，新增元素默认初始化；若小于，则删除多余元素。
• v.shrink_to_fit() (C++11)：请求将容量缩减至等于 size，以释放多余内存。

增删改查

• v.push_back(val)：在尾部添加一个元素。
• v.pop_back()：删除尾部最后一个元素。
• v.insert(pos, val)：在迭代器 pos 指向的位置之前插入元素。
• v.erase(pos)：删除迭代器 pos 指向的元素。
• v.clear()：清空所有元素，size 变为 0，但 capacity 通常不变。
• v.swap(v2)：交换两个 vector 的内容。

遍历方式

vector<int> v = {1, 2, 3, 4, 5};

// 1. 下标访问
for (size_t i = 0; i < v.size(); ++i) {
    cout << v[i] << " ";
}

// 2. 迭代器访问
for (auto it = v.begin(); it != v.end(); ++it) {
    cout << *it << " ";
}

// 3. 范围 for 循环 (C++11 推荐，简洁且安全)
for (const auto& elem : v) {
    cout << elem << " ";
}

与其他容器的对比

• ‌vs 原生数组‌：vector 自动管理内存，支持动态扩容，更安全灵活；原生数组固定大小，需手动管理内存。
• ‌vs std::array‌：array 是固定大小的栈上数组，性能略高但无动态扩容能力；vector 是堆上动态数组。
• ‌vs std::deque‌：deque 支持两端高效插入删除，但不保证内存连续；vector 保证连续内存，缓存友好性更好，随机访问更快。

综上所述，std::vector 是 C++ 中大多数场景下的‌首选序列容器‌，除非有特定的性能需求（如频繁头部插入选 deque，频繁中间插入选 list），否则应优先使用 vector。

1、删除方法

---- 向量容器vector的成员函数pop_back()可以删除最后一个元素.

---- 而函数erase()可以删除由一个iterator指出的元素，也可以删除一个指定范围的元素。

---- 还可以采用通用算法remove()来删除vector容器中的元素，大家可以看到这里说的是算法，而不是方法；

     即vector没有remove()成员，这里的remove是algorithm中的remove函数。

---- 不同的是：采用remove()一般情况下不会改变容器的大小，而pop_back()与erase()等成员函数会改变容器的大小。

2、pop_back()

void pop_back();

删除容器内的最后一个元素，容器的size减1.

This destroys the removed element. 销毁删除的元素

#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
int main()
{
	vector<int> vec;
	int sum = 0, i = 0;
	vec.push_back(10);
	vec.push_back(20);
	vec.push_back(30);
	cout << "init vec.size() =  "<< vec.size() << endl;
	while(!vec.empty())
	{
		i++;
		sum += vec.back();	//取最后一个元素	
		vec.pop_back();         //删除最后一个元素
		printf("after %d time, sum: %d size = %d\n", i, sum, vec.size());		
	}
	system("pause");
	return 0;
}

3、erase()

C++98

iterator erase (iterator position);
iterator erase (iterator first, iterator last);

C++11

iterator erase (const_iterator position);
iterator erase (const_iterator first, const_iterator last);

删除指定位置的一个元素或删除指定范围内的元素

Removes from the  vector either a single element (position) or a range of elements ([first,last)).  包括first，不包括last。
This effectively reduces the container  size by the number of elements removed, which are destroyed. 这个操作会让容器的size减小，减小的个数为删除的元素个数。

迭代器用于erase删除元素后，其后会失效，即不能再用该迭代器操作向量。

第一个erase()的例子

#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
int main()
{
	vector<int> vec;
	for( int i = 0; i < 10; i++ )
	{
		vec.push_back( i );
	}
	printf("init vec size: %d\n", vec.size());   //0-9
	
	vec.erase( vec.begin() + 5 );                //删除第6个元素,{0 1 2 3 4 6 7 8 9}
	printf("after erase size: %d\n", vec.size());//9
	vec.erase( vec.begin(), vec.begin() + 3 );   //删除第1个元素，到第4个元素 {3 4 6 7 8 9}
	printf("vec = { ");
	for( unsigned int j = 0; j < vec.size(); j++ )
	{	
		printf("%d ", vec[j]);
	}
	printf("}\n");
	system("pause");
	return 0;
}

第二个erase()的例子

#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
int main()
{
	vector<int> vec;
	vec.push_back(100);
	vec.push_back(300);
	vec.push_back(300);
	vec.push_back(300);
	vec.push_back(300);
	vec.push_back(500);
	cout << &vec << endl;
	vector<int>::iterator itor;
	for( itor = vec.begin(); itor != vec.end(); itor++ )
	{
		if( *itor == 300 )
		{
			itor = vec.erase(itor);
		}
	}

	for( itor = vec.begin(); itor != vec.end(); itor++)
	{
		cout<< *itor <<" ";
	}	
	system("pause");
	return 0;
}

解析：

1）初始化后，即调用push_back之后，vec中的元素是{ 100 300 300 300 300 500 }

2）迭代器itor指向第一个元素100，不满足条件，itor++；

     迭代器itor指向第二个元素300，满足条件，调用erase删除300，之后vec是{ 100  300 300 300 500 }

     迭代器itor++，指向第三个元素，会调过一个300，满足条件，调用erase，删除300，之后vec是 { 100 300 300 500 }

     迭代器itor++，指向第四个元素，指向500，所以最终vec中的数据就是{ 100 300 300 500 }

3）主要是vec中的数据不断变化，但是itor的指向一直在增加的缘故

那怎么改善这个问题呢？如果我想删除容器中所有的300，应该怎么做？

#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
int main()
{
	vector<int> vec;
	vec.push_back(100);
	vec.push_back(300);
	vec.push_back(300);
	vec.push_back(300);
	vec.push_back(300);
	vec.push_back(500);
	vector<int>::iterator itor = vec.begin();
	while( itor != vec.end() )
	{
		if( *itor == 300 )
		{
			itor = vec.erase(itor);
		}
		else
		{
			itor++;
		}
	}
	printf("vec = { ");
	for( itor = vec.begin(); itor != vec.end(); itor++)
	{
		cout<< *itor <<" ";
	}	
	printf("}\n");

	system("pause");
	return 0;
}

4、remove()

先来抄写一段吧：我们可以选择STL方法（特定类的成员函数）或STL函数，通常方法是更好的选择。首先，它更适合于特定的容器；其次，作为成员函数，它可以使用模板类的内存管理工具，从而在需要时调整容器的长度。

例如：假设有一个由数字组成的链表，并要删除链表中某个特定值（4）的所有实例。如果mylist是一个list<int>对象，则可以使用链表的remove()方法。

mylist.remove(4);   //remove all 4 from the list

调用该方法后，链表中所有值为4的元素都将被删除，同时链表的长度将被自动调整。

还有一个名为remove()的STL函数（算法），它不是由对象调用，而是接受区间参数。因此，如果mylist是一个list<int>对象，则调用该函数的代码如下：

remove(mylist.begin(), mylist.end(), 4);

然而，由于该remove()函数不是成员，因此不能调整链表的长度。它将没被删除的元素放在链表的开始位置，并返回一个指向新的超尾值的迭代器。

来举个例子吧

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <stdio.h>
using namespace std;

void Show(int v)
{
	std::cout << v << ' ';
}

int main()
{
    int age[10] ={ 2, 3, 5, 4, 2, 3, 2, 6, 2, 7 };
	std::list<int> list_a(age, age + 10);
	std::list<int> list_b(list_a);
	printf("Original list_a:\n");
	for_each(list_a.begin(), list_a.end(), Show);
	printf("\n\n");
	list_a.remove( 2 );
	printf("remove() method list_a:\n");
	for_each(list_a.begin(), list_a.end(), Show);
	printf("\n\n");
	list<int>::iterator itor;
	itor = remove(list_b.begin(), list_b.end(), 2);
	printf("remove() function list_b:\n");
	for_each(list_b.begin(), list_b.end(), Show);
	printf("\n\n");
	list_b.erase( itor, list_b.end() );
	printf("erase() method list_b:\n");
	for_each(list_b.begin(), list_b.end(), Show);
	printf("\n");
	system("pause");
	return 0;
}

vector同理：

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <stdio.h>
using namespace std;

void Show(int v)
{
	std::cout << v << ' ';
}

int main()
{
	int age[10] ={ 2, 3, 5, 4, 2, 3, 2, 6, 2, 7 };
	vector<int> vec_a(age, age + 10);
	printf("Original vec_a:\n");
	for_each(vec_a.begin(), vec_a.end(), Show);
	printf("\n\n");
	
	vector<int>::iterator itor;
	itor = remove(vec_a.begin(), vec_a.end(), 2);
	printf("remove() function vec_a:\n");
	for_each(vec_a.begin(), vec_a.end(), Show);
	printf("\n");
	printf("remove() size: %d\n\n", vec_a.size());
	vec_a.erase( itor, vec_a.end() );
	printf("erase() method vec_a:\n");
	for_each(vec_a.begin(), vec_a.end(), Show);
	printf("\n");
	printf("erase() size: %d\n\n", vec_a.size());
	system("pause");
	return 0;
}