vector的总结

徐凤年lll

已于 2023-11-24 10:41:56 修改

阅读量422

点赞数 5

分类专栏： c++ 文章标签： c++

于 2023-11-20 19:55:46 首次发布

本文链接：https://blog.csdn.net/m0_71920611/article/details/134487088

版权

c++ 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

种一棵树最好的时间是10年前，其次是现在！加油学啊！

1.什么是vector

在C++中，std::vector是标准模板库（STL）中的一种动态数组容器，它可以存储任意类型的元素，并且能够自动调整大小。std::vector提供了许多方便的成员函数，使得对数组的操作更加简单和高效。相当于数据结构中的顺序表

下面是一个使用std::vector的简单示例：三种遍历方法

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


void test_vector1()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);


	//数组下标
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;

	//范围for
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	
	//迭代器
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
}


int main()
{
    test_vector1();

	return 0;
}

2.vector的使用

2.1 vector构造函数

explicit vector (const allocator_type& alloc = allocator_type());	
//构造一个空容器，不包含任何元素。
explicit vector (size_type n, const value_type& val = value_type(),
                 const allocator_type& alloc = allocator_type());
//构造一个包含n 个元素的容器。每个元素都是val的副本。	
template <class InputIterator>
         vector (InputIterator first, InputIterator last,
                 const allocator_type& alloc = allocator_type());
//构造一个包含与范围[first,last)一样多的元素的容器，其中每个元素均从该范围内的相应元素按相同的顺序构造。
vector (const vector& x);//构造一个容器，其中包含x中每个元素的副本（按相同顺序）。

例子

#include <iostream>
#include <vector>
using namespace std;
int main ()
{
  //构造函数的使用顺序与上述相同：
  vector<int> first;                                // 默认构造
  vector<int> second (4,100);                       // 初始化四个值为 100 的整数
  vector<int> third (second.begin(),second.end());  // 使用迭代器的拷贝
  vector<int> fourth (third);                       // 拷贝构造

  
  return 0;
}

2.2 赋值运算符的重载

vector& operator= (const vector& x);

该运算符重载函数使得两个 std::vector 对象的内容相同，但是它们是独立的，修改一个对象不会影响另一个对象。

std::vector<int> vec1 = {1, 2, 3, 4};
std::vector<int> vec2 = {5, 6, 7};

vec1 = vec2; // 将 vec2 的内容赋值给 vec1

在上面的示例中，vec1 的内容将变成 {5, 6, 7}，与 vec2 相同。vec2 本身不受影响。

2.3 迭代器的使用

iterator begin():: 返回一个指向 std::vector 容器中第一个元素的可修改迭代器。通过这个迭代器，可以对容器中的元素进行修改。

const_iterator begin() const:: 返回一个指向 std::vector 容器中第一个元素的常量迭代器。通过这个迭代器，可以遍历容器中的元素，但不能对容器中的元素进行修改。

正向迭代器使用

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


void test_vector1()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	vector<int>::iterator it = v.begin();
	while(it!=v.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

}

int main()
{
	test_vector1();
}

reverse_iterator rbegin():: 返回一个指向 std::vector 容器中最后一个元素的可修改逆向迭代器。逆向迭代器是一种特殊的迭代器，它可以从容器的末尾向前遍历元素。

const_reverse_iterator rbegin() const:: 返回一个指向 std::vector 容器中最后一个元素的常量逆向迭代器。通过这个逆向迭代器，可以从容器的末尾向前遍历元素，但不能对容器中的元素进行修改

反向迭代器的使用

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


void test_vector1()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	vector<int>::reverse_iterator rit = v.rbegin();
	//auto rit =v.rbegin();    也可以这么写
	while(rit!=v.rend())
	{
		cout << *rit << " ";
		rit++;
	}
	cout << endl;

}

int main()
{
	test_vector1();
}

cbegin(): 返回指向 std::vector 容器中第一个元素的常量迭代器。
cend(): 返回指向 std::vector 容器中最后一个元素之后位置的常量迭代器。
crbegin(): 返回指向 std::vector 容器中最后一个元素的常量逆向迭代器。
crend(): 返回指向 std::vector 容器中第一个元素之前位置的常量逆向迭代器。

vector容量函数

容量空间	接口说明
size	获取数据个数
capacity	获取容量大小
empty	判断是否为空
resize	改变vector的size
reverse	改变vector的capacity

例子

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


int main() {
   vector<int> myVector = { 1, 2, 3, 4, 5 };

   cout << "Size: " << myVector.size() << endl;
    cout << "Max Size: " << myVector.max_size() <<endl;

    myVector.resize(8, 10); // 增加元素并用值 10 填充
    cout << "Resized Size: " << myVector.size() << endl;
    cout << "Capacity: " << myVector.capacity() << endl;

    cout << "Is Empty: " << (myVector.empty() ? "Yes" : "No") << endl;

    myVector.reserve(10); // 预留内存，但不实际创建元素
    cout << "New Capacity After Reserve: " << myVector.capacity() << endl;

    myVector.shrink_to_fit(); // 尝试缩小内存使用
    cout << "New Capacity After Shrink: " << myVector.capacity() << endl;

    return 0;
}

注意：capacity() 和 size() 的区别在于，capacity() 表示在不重新分配内存的情况下 std::vector 可以容纳的最大元素个数，而 size() 表示实际存储在 std::vector 中的元素个数

3.vector元素访问函数

3.1 operator[]

reference operator[] (size_type n);

reference operator[] (size_type n): 这个重载用于访问 std::vector 中指定索引位置 n 处的元素，并返回该元素的引用。通过此重载，可以对元素进行读取和修改操作。如果 n 超出了有效的索引范围（即小于 0 或大于等于 size()），行为将是未定义的（Undefined Behavior）。

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


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

    // 修改元素
    v[0] = 10; // 将索引 1 处的元素修改为 10

    cout <<  v[0] << endl;
   
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

}

3.2 at

reference at (size_type n);

reference at (size_type n): 这个重载用于访问 std::vector 中指定索引位置 n 处的元素，并返回该元素的引用。通过此重载，可以对元素进行读取和修改操作。如果 n 超出了有效的索引范围（即小于 0 或大于等于 size()），at 函数会抛出 std::out_of_range 异常，以保证程序的健壮性。

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


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

    // 修改元素
    v.at(1) = 10; // 将索引 2 处的元素修改为 10

    cout <<  v[1] << endl;
   
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

}

3.3 front()

reference front();

reference front(): 这个重载用于访问 std::vector 容器中的第一个元素，并返回该元素的引用。通过此重载，可以对元素进行读取和修改操作。

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


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

    // 修改元素
    v.front() = 10; // 将索引 1 处的元素修改为 10

    cout << "First element: "<<  v[0] << endl;
   
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

}

3.4 back

reference back();

reference back(): 这个重载用于访问 std::vector 容器中的最后一个元素，并返回该元素的引用。通过此重载，可以对元素进行读取和修改操作。

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


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

    // 修改元素
    v.back() = 10; // 将索引 1 处的元素修改为 10

    cout << "Last element: "<<  v[4] << endl;
   
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

}

4.vector增删查改

4.1 push back 尾插

void push_back (const value_type& val);

vector 的 push_back 函数用于向容器的末尾添加一个新元素。它接受一个引用参数 const value_type& val，表示要添加的新元素的值。

其中，value_type 是 std::vector 中元素的类型，通常是模板参数中指定的类型。const 表示在函数中不会修改传入的值。

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


int main()
{
    vector<int> v;

    v.push_back(1);
    v.push_back(3);
    v.push_back(5);
    v.push_back(7);

   
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

}

4.2 pop back 头插

void pop_back();

vector 的 pop_back 函数用于从容器的末尾移除一个元素。它没有参数，直接从容器的末尾删除最后一个元素。

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

int main()
{
    vector<int> v = {1,3,5,7};

    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    v.pop_back( );

    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

}

4.3 assign() 替换函数

vector 提供了两种重载的 assign 函数，用于替换vector 中的内容：

template <class InputIterator> void assign (InputIterator first, InputIterator last);:

这个重载模板函数接受一对迭代器 first 和 last 作为参数，它们表示一个范围。assign 函数将容器的内容替换为指定范围中的元素。

这个重载函数可以接受任何类型的迭代器，例如指针，普通迭代器或者 const 迭代器等。只要指定的范围是有效的，assign 函数就会将容器的内容替换为该范围内的元素。

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

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

    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    // 使用 assign 重载函数替换容器内容为一组元素
   vector<int> a = { 10, 20, 30, 40, 50 };

    v.assign(a.begin(), a.end());
 
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}

void assign (size_type n, const value_type& val);:

这个重载函数接受一个整数 n 和一个值 val 作为参数，将容器的内容替换为 n 个 val 值。
n 表示新容器应该包含多少个 val 值，容器的大小将设置为 n，原来的元素都将被替换。

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

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

    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    // 使用 assign 重载函数替换容器内容为一组元素
  

    v.assign(5, 10);  //5是个数，10是里面的数字 ，5个10 
 
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}

4.4 insert 插入元素

iterator insert (iterator position, const value_type& val);
void insert (iterator position, size_type n, const value_type& val);
template <class InputIterator> void insert (iterator position, InputIterator first, InputIterator last);

vector 的 insert 函数用于在指定位置插入一个或多个元素。

4.4.1. 插入单个元素：

这个版本的 insert 函数在 position 位置之前插入一个元素，并返回指向插入元素的迭代器。

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

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

    vector<int>::iterator it = v.begin() + 1; //第二个位置
    v.insert(it, 10);   // 第二个位置插入10 ， 1 10 2 3 4 5
  
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}

4.4.2. 插入多个相同元素：

这个版本的 insert 函数在 position 位置之前插入 n 个值为 val 的元素。

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

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

    vector<int>::iterator it = v.begin() + 1; //第二个位置
    v.insert(it,3, 10);   // 第二个位置插入10 ， 1 10 10 10 2 3 4 5
  
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}

4.4.3. 插入范围内的元素：

这个版本的 insert 函数在 position 位置之前插入从 first 到 last 区间内的元素。

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

int main()
{
    vector<int> v = {1, 2, 3, 4, 5};
    vector<int> a = {6, 7, 8, 9, 10};

    vector<int>::iterator it = v.begin() + 1; //第二个位置
    v.insert(it, a.begin(), a.end());
  
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}

4.5 erase() 删除元素

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

vector 的 erase 函数用于从容器中移除一个或一段元素

4.5.1.移除单个元素：

这个版本的 erase 函数移除由 position 指向的元素，并返回指向下一个元素的迭代器。

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

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

    vector<int>::iterator it = v.begin() + 1; //第二个位置
    v.erase(it);
  
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}

4.5.2 移除一段元素

这个版本的 erase 函数移除从 first 到 last 区间内的元素，并返回指向下一个元素的迭代器。

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

int main()
{
    vector<int> v = {1, 2, 3, 4, 5};
  
    vector<int>::iterator it1 = v.begin() + 1; //第二个位置

    vector<int>::iterator it2 = v.begin() + 4; //第三个位置

    //删除是左闭右开区间  ，  [2,5)     1  5 

    v.erase(it1,it2);
  
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    return 0;

}

注意区间问题，左闭右开

4.5 swap() 交换函数

void swap (vector& x);

std::vector 的 swap 函数用于交换两个顺序表的内容。它将当前顺序表和参数顺序表 x 的内容进行交换。

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

int main()
{
    vector<int> a = {1, 2, 3, 4, 5};
    vector<int> b = { 6, 7, 8, 9, 10};

    cout << "交换前:" << endl;

    for (auto e : a)
    {
        cout << e << " ";
    }
    cout << endl;   
    

    for (auto e : b)
    {
        cout << e << " ";
    }
    cout << endl;

    a.swap(b);

    cout << "交换后:" << endl;

    for (auto e : a)
    {
        cout << e << " ";
    }
    cout << endl;


    for (auto e : b)
    {
        cout << e << " ";
    }
    cout << endl;

    return 0;

}

4.6 clear 清空

void clear();

clear 函数用于清空 std::vector 中的所有元素，使其变为空顺序表。

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

int main()
{
    vector<int> a = {1, 2, 3, 4, 5};
 

    cout << "clear前:" << endl;

    for (auto e : a)
    {
        cout << e << " ";
    }
    cout << endl;   
    

    a.clear();

    cout << "clear后:" << endl;

    for (auto e : a)
    {
        cout << e << " ";
    }
    cout << endl;

    return 0;

}

4.7迭代器失效问题

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。
对于vector可能会导致其迭代器失效的操作有：
1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。

2. 指定位置元素的删除操作–erase

删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

3. 与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效

迭代器失效解决办法：在使用前，对迭代器重新赋值即可。

本文借鉴了下面的文章，有兴趣可以去这里看，谢谢大家
原文链接：https://blog.csdn.net/kingxzq/article/details/132078597

徐凤年lll

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
3
评论
vector的总结

在C++中，std::vector是标准模板库（STL）中的一种动态数组容器，它可以存储任意类型的元素，并且能够自动调整大小。std::vector提供了许多方便的成员函数，使得对数组的操作更加简单和高效。相当于数据结构中的顺序表下面是一个使用std::vector的简单示例：三种遍历方法//数组下标i++)//范围for//迭代器while (it!
复制链接

扫一扫