【C++提高编程-04】----C++之Vector容器实战

于 2024-05-25 14:14:37 发布
阅读量579 收藏 13
点赞数 12
分类专栏： C++ 提高编程学习 文章标签： c++ 开发语言 c语言 学习方法 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59951855/article/details/139174288
版权

34889d2e7fec4a02bb0ae3a22b011a2a.png

🎩 欢迎来到技术探索的奇幻世界👨‍💻

📜 个人主页：@一伦明悦-CSDN博客

✍🏻 作者简介： C++软件开发、Python机器学习爱好者

🗣️ 互动与支持：💬评论      👍🏻点赞      📂收藏     👀关注+

如果文章有所帮助，欢迎留下您宝贵的评论，

点赞加收藏支持我，点击关注，一起进步！

目录

前言

正文

01-Vector容器简介

 02-Vector容器构造函数简介

03-Vector容器赋值操作

04-Vector容器容量和大小

05-Vector容器插入和删除

06-Vector容器数据存取

07-Vector互换容器

总结

前言

       vector是C++中非常常用的容器，提供了动态数组的灵活性和高效的随机访问能力，是处理动态数据集合的重要工具之一。在使用时需要注意选择合适的数据结构来满足需求，并考虑到vector的性能特征。

正文

01-Vector容器简介

     vector是C++标准模板库（STL）中的一个容器，它提供了动态数组的功能，允许在数组的尾部高效地插入或删除元素。下面是关于vector容器的详细分析和介绍：

  1. 特点：

    • vector是一个动态数组，可以根据需要自动调整大小。
    • 支持随机访问，可以通过索引快速访问元素。
    • 在尾部插入或删除元素的开销低，但在中间或头部插入或删除元素开销较大。
    • 内部基于数组实现，内存是连续存储的，因此支持高效的随机访问。

  2. 创建vector：

    • 可以通过std::vector<T> v;来创建一个空的vector，其中T是存储的元素类型。
    • 也可以通过初始化列表初始化vector，比如std::vector<int> v = {1, 2, 3};。

  3. 常用操作：

    • push_back(element)：在vector的尾部插入一个元素。
    • pop_back()：删除vector的尾部元素。
    • size()：返回vector中的元素个数。
    • empty()：判断vector是否为空。
    • at(index)：访问指定索引位置的元素。
    • back()：返回最后一个元素的引用。
    • front()：返回第一个元素的引用。
    • clear()：清空vector中的所有元素。

  4. 遍历vector：

    • 可以使用迭代器或范围循环遍历vector中的元素。
    • 例如： 
      std::vector<int> v = {1, 2, 3, 4};
for (int i : v) {
    std::cout << i << " ";
}

    • 性能分析：

      • vector在尾部插入和删除元素的时间复杂度是O(1)。
      • 随机访问的时间复杂度是O(1)。
      • 在中间或头部插入或删除元素，需要移动后续元素，时间复杂度为O(n)。

    • 注意事项：

      • 当vector的大小超过预分配的内存时，会重新分配更大的内存，这可能导致性能开销。
      • 插入或删除操作会导致重新分配内存和元素的移动，需要注意性能消耗。

 02-Vector容器构造函数简介

    在 C++ 的标准模板库（STL）中，不同类型的容器（如 vector、map、set 等）都有各自的构造函数，用于创建容器对象并进行初始化。下面简要介绍一些常见容器的构造函数：

  vector<T> v;：构造一个空的 vector，存储类型为 T。

  vector<T> v(n);：构造一个包含 n 个元素的 vector，每个元素值为类型 T 的默认值。  

  vector<T> v(n, value);：构造一个包含 n 个元素的 vector，并每个元素初始化为 value。

  vector<T> v(begin, end);：使用迭代器指定的范围内的元素来构造 vector

        下面给出具体代码分析应用过程：这段代码主要演示了使用不同方式构造vector容器并进行操作，代码分析如下：

  1. 头文件包含：

    • #include<iostream>：包含 C++ 标准输入输出流头文件。
    • using namespace std;：使用 std 命名空间，避免在后续代码中需要写出 std::前缀。
    • #include <vector>：包含 C++ STL 中的 vector 容器头文件。

  2. 函数定义：

    • void printVector(vector<int> & v)：定义了一个用于输出 vector<int> 容器元素的函数，并使用引用方式传入容器，以便在函数内部可以修改容器的内容。

  3. 主测试函数 test01：

    • 创建一个空的 vector<int> 容器 v1，并通过 push_back 方法向容器中添加元素。
    • 调用 printVector 函数输出 v1 容器的内容。
    • 使用区间构造方法，将 v1 的元素复制到 v2 容器中，并输出 v2 内容。
    • 使用 n 个元素相同的方式构造 v3 容器，其中包含 10 个值为 100 的元素，并输出 v3 内容。
    • 使用拷贝构造方式，将 v1 容器的内容拷贝构造到 v4 容器中，并输出 v4 内容。

  4. main 函数：

    • 在 main 函数中调用 test01 函数以执行测试。
    • 使用 system("pause"); 使程序暂停，防止窗口一闪而过。

       总体来说，这段代码展示了如何使用不同构造方式初始化vector容器，并演示了如何输出容器中的元素。通过对不同构造方式的使用和输出结果的比较，可以更好地理解vector容器的构造函数及其作用。

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

// 容器构造函数 

void printVector(vector<int> & v)   // 这里既然需要输出容器，必然要传入一个定义的容器变量，采用引用方式
{
	for (vector<int>::iterator it = v.begin(); it != v.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;

}

void test01()
{
	vector<int>v1;   // 1、默认构造函数 

	for (int i = 0; i < 10;i++)
	{
		v1.push_back(i);
	}

	// 调用一个输出容器的函数
	printVector(v1);   // 这里函数以引用方式做传入的参数，并且参数类型是vector<int>容器类型

	// 2、通过区间方式进行构造
	vector<int> v2(v1.begin(), v1.end());
	printVector(v2);

	// 3、n个elem方式构造
	vector<int>v3(10, 100);   // 指的是10个100
	printVector(v3);

	// 4、拷贝构造
	vector<int>v4(v1);   // 直接传入就是拷贝构造
	printVector(v4);


}

int main() {

	test01();


	system("pause");
	return 0;
}

       实例结果如下图所示：  

ffcade4743614f448929a2a7253003f3.png

03-Vector容器赋值操作

    vector容器的赋值操作可以通过多种方式进行，下面是对这些方式的详细简介：

  1. 赋值运算符 =：

    • 可以使用 = 运算符将一个 vector 容器的内容赋值给另一个 vector 容器。
    • 例如：vector<int> v1 = {1, 2, 3}; vector<int> v2 = v1; 将 v1 的内容赋值给 v2。

  2. assign 函数：

    • assign 函数用于将指定范围内的元素赋值给 vector 容器。
    • 格式为 v.assign(first, last)，其中 first 和 last 是迭代器，指定了赋值范围。
    • 例如：vector<int> v; v.assign({4, 5, 6}); 将 {4, 5, 6} 赋值给 v。

  3. fill 函数：

    • fill 函数用于将容器中的所有元素替换为指定值。
    • 格式为 v.fill(value)，其中 value 是要填充的值。
    • 例如：vector<int> v(5); v.fill(10); 将 v 中的所有元素都填充为 10。

  4. swap 函数：

    • swap 函数用于交换两个 vector 容器的内容。
    • 格式为 v1.swap(v2)，其中 v1 和 v2 是要交换内容的两个容器。
    • 例如：vector<int> v1 = {1, 2, 3}; vector<int> v2 = {4, 5, 6}; v1.swap(v2); 将 v1 和 v2 的内容进行交换。

       这些赋值操作提供了灵活的方式来修改 vector 容器的内容，可以根据具体需求选择适合的方式进行赋值操作。

       下面给出具体代码分析应用过程：这段代码演示了使用赋值操作符 = 和 assign 函数对vector容器进行赋值操作，下面是对代码的简要分析：

  1. 头文件包含：

    • 包含了 <iostream> 头文件用于输入输出操作。
    • 使用了 using namespace std; 声明，避免了在后续代码中需要加上 std:: 命名空间前缀。
    • 引入了 <vector> 头文件，以使用vector容器。

  2. 函数定义：

    • 定义了一个名为 printVector 的函数，用来输出 vector<int> 容器中的元素。

  3. 测试函数 test01：

    • 创建一个空的 vector<int> 容器 v1，并通过 push_back 方法向容器中添加元素。
    • 使用printVector函数输出 v1 容器的内容。
    • 使用赋值操作符 = 将 v1 的内容赋值给另一个空的 vector<int> 容器 v2，并输出 v2 的内容。
    • 使用 assign 函数将 v1 的内容复制给另一个空的 vector<int> 容器 v3，并输出 v3 的内容。
    • 使用 assign 函数将 10 个值为 100 的元素赋值给另一个空的 vector<int> 容器 v4，并输出 v4 的内容。

  4. main 函数：

    • 在 main 函数中调用 test01 函数以执行测试。
    • 使用 system("pause"); 使程序暂停，防止窗口一闪而过。

       总体来说，这段代码演示了如何使用赋值操作符 = 和 assign 函数来对vector容器进行赋值操作。通过不同的赋值方式，可以将一个容器的内容复制给另一个容器，或者将指定范围或固定值赋给容器，从而灵活地操作容器的内容。

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



// 容器赋值操作 

void printVector(vector<int> & v)   // 这里既然需要输出容器，必然要传入一个定义的容器变量，采用引用方式
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

}

void test01()
{
	vector<int>v1;   // 1、默认构造函数 

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	// 调用一个输出容器的函数
	printVector(v1);   // 这里函数以引用方式做传入的参数，并且参数类型是vector<int>容器类型

	// 赋值操作 operator=
	vector<int>v2;
	v2 = v1;
	printVector(v2);
	// assign 赋值   区间使用，assign([a,b));
	vector<int>v3;
	v3.assign(v1.begin(), v1.end());   //v1.begin(), v1.end()
	printVector(v3);

	// assign 赋值   区间使用，assign([a,b));
	vector<int>v4;
	v4.assign(10, 100);   //赋值，和构造有区别
	printVector(v4);



}

int main() {

	test01();

	system("pause");
	return 0;
}

       实例结果如下图所示：  

34028933f30d4ec598c36203fea65b61.png

04-Vector容器容量和大小

      在 C++ STL 中，vector 容器的容量（capacity）和大小（size）是两个重要的概念，它们表示了容器中元素的数量和存储空间的分配情况。下面是关于 vector 容器容量和大小的详细介绍：

  1. 大小（size）：

    • 容器的大小是指容器中当前实际存储的元素数量。
    • 可以通过 size() 成员函数获取容器的大小。
    • 当我们向容器中添加元素时，大小会增加；当我们从容器中删除元素时，大小会减少。
    • 例如，如果一个 vector 容器中有 5 个元素，则其大小为 5。

  2. 容量（capacity）：

    • 容器的容量是指在不分配新的存储空间的情况下，容器可以容纳的元素数量。
    • 可以通过 capacity() 成员函数获取容器的容量。
    • 容器的容量总是大于或等于其大小。当容器的元素数量接近容量时，可能需要重新分配内存空间，以增加容器的容量。
    • 容器的容量通常会随着元素的动态添加而增加，并可能会超过实际存储的元素数量。

  3. 空间操作细节：

    • 当容器的大小超过容量时，容器会自动分配更大的存储空间，并将原有元素拷贝到新的存储空间中。
    • 这种情况下，容器的容量会增加，但元素本身的数量没有改变。
    • 当容器的大小小于等于容量时，并不会释放多余的存储空间。但可以使用 shrink_to_fit() 函数来要求容器释放多余的存储空间，使容量等于大小。

       总之，vector 容器的大小和容量是在动态管理元素存储空间时非常重要的概念，了解它们能够帮助我们更好地理解容器内部的存储机制，并合理地使用容器的操作函数。

       下面给出具体代码分析应用过程：这段代码展示了容器构造函数的使用以及容器的基本操作，以下是简要的代码分析：

  1. 头文件包含：

    • 代码包含了 <iostream> 头文件用于输入输出操作。
    • 使用了 using namespace std; 声明，以便在代码中直接使用 cout 和 endl 等标准库中的元素。
    • 引入了 <vector> 头文件，以使用 vector 容器。

  2. 函数定义：

    • 定义了一个名为 printVector 的函数，用于输出 vector<int> 容器中的元素。

  3. 测试函数 test01：

    • 创建一个空的 vector<int> 容器 v1，并通过循环将 0 到 9 的整数依次添加到容器中。
    • 调用 printVector 函数输出 v1 容器的内容。
    • 使用 empty() 函数检查容器是否为空，如果为空则输出 “v1为空”，否则输出容器的容量和大小，以及继续执行后续语句。
    • 调用 resize(15) 函数重新指定容器 v1 的大小为 15，这会导致容器的容量自动扩大，由于原先只有 10 个元素，额外的 5 个位置会用默认值（0）填充。
    • 再次调用 printVector 函数输出修改后的 v1 容器的内容，并输出当前容器的容量。

  4. main 函数：

    • 在 main 函数中调用 test01 函数以执行测试。
    • 使用 system("pause"); 使程序暂停，防止窗口一闪而过。

       总体来说，这段代码展示了使用 vector 容器的构造函数、基本操作（如输出容器内容、检查容器是否为空、获取容器的容量和大小，重新指定容器大小等）。通过这些操作，我们可以更好地理解 vector 容器的特性和使用方法。

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



// 容器构造函数 

void printVector(vector<int> & v)   // 这里既然需要输出容器，必然要传入一个定义的容器变量，采用引用方式
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

}

void test01()
{
	vector<int>v1;   // 1、默认构造函数 

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	// 调用一个输出容器的函数
	printVector(v1);   // 这里函数以引用方式做传入的参数，并且参数类型是vector<int>容器类型

    if (v1.empty())   // 为真，代表容器为空
    {
		cout << "v1为空" << endl;
    }
	else
	{
		cout << "v1不为空" << endl;
		cout << "v1的容量" << v1.capacity() << endl;   // 容量一定大于等于插入的参数个数
		cout << "v1的大小" << v1.size() << endl;

	}

	// 重新指定容器大小
	v1.resize(15);
	printVector(v1);// 这里重新指定了size大小，容器容量回自动扩大，由于v1本来只有10个数值，另外5个参数默认为0
	cout << "v1此时的容量" << v1.capacity() << endl;



}

int main() {

	test01();


	system("pause");
	return 0;
}

       实例结果如下图所示：  

8bf213845ade4d3bafabb01c274710bf.png

05-Vector容器插入和删除

    在 C++ STL 中，vector 容器提供了丰富的方法用于插入和删除元素，下面是关于 vector 容器插入和删除操作的详细介绍：

插入操作：

  1. push_back： 在容器的末尾插入一个元素。

    vector<int> v = {1, 2, 3};
v.push_back(4); // 将元素 4 插入到容器末尾后，容器变为 {1, 2, 3, 4}

  2. insert： 在指定位置插入元素或一段元素。

    vector<int> v = {1, 2, 3, 4, 5};
v.insert(v.begin() + 2, 10); // 在第三个位置（索引为2）插入元素 10，容器变为 {1, 2, 10, 3, 4, 5}
v.insert(v.begin() + 3, {20, 30, 40}); // 在第四个位置插入元素 20, 30, 40，容器变为 {1, 2, 10, 20, 30, 40, 3, 4, 5}

删除操作：

  1. pop_back： 删除容器末尾的元素。

    vector<int> v = {1, 2, 3, 4, 5};
v.pop_back(); // 删除容器末尾的元素，容器变为 {1, 2, 3, 4}

  2. erase： 删除指定位置或指定范围内的元素。

    vector<int> v = {1, 2, 3, 4, 5};
v.erase(v.begin() + 2); // 删除第三个位置的元素，容器变为 {1, 2, 4, 5}
v.erase(v.begin() + 1, v.begin() + 4); // 删除从第二个位置至第四个位置的元素，容器变为 {1, 5}

  3. clear： 清空容器中的所有元素，使容器为空。

    vector<int> v = {1, 2, 3, 4, 5};
v.clear(); // 清空容器中的所有元素，容器变为空

  4. 注意事项：

    • 插入和删除元素可能会导致迭代器失效，要特别注意在循环中插入或删除元素时的迭代器处理。
    • 删除元素后，后续的元素会向前移动，因此要注意索引的变化。

       通过上述详细介绍，你可以深入了解 vector 容器在实际编程中如何进行元素的插入和删除操作，合理地利用这些操作可以使代码更加灵活和高效。

       下面给出具体代码分析应用过程：  这段代码主要演示了关于 vector 容器的插入和删除操作，以下是代码的简要分析：

  1. 头文件包含和函数定义：

    • 引入了 <iostream> 和 <vector> 头文件，用于输入输出以及使用 vector 容器。
    • 定义了一个用于输出 vector<int> 容器元素的函数 printVector。

  2. test01 函数：

    • 创建一个空的 vector<int> 容器 v1。
    • 使用 push_back 方法向容器尾部依次插入元素 10, 20, 30, 40, 50。
    • 调用 printVector 函数输出容器 v1 中的所有元素。
    • 使用 pop_back 方法删除容器尾部的元素，此处删除了元素 50。
    • 使用 insert 方法在容器的起始位置插入元素 100。
    • 使用 erase 方法删除容器的第一个元素。
    • 注释掉了 v1.clear() 方法，该方法用于清空容器中的所有元素，但在此处被注释掉未执行。

  3. main 函数：

    • 在 main 函数中调用 test01 函数以执行测试。
    • 使用 system("pause"); 使程序暂停，防止窗口一闪而过。

  4. 运行结果：

    • 程序执行后，将依次输出 v1 容器中的元素，每次操作后的容器内容都会被打印出来。

        通过这段代码的执行，你可以了解 vector 容器的插入和删除操作的具体细节，并体会这些操作对容器中元素的影响。如果想要继续学习和探究，可以尝试更多不同方式的插入和删除操作，以加深对 vector 容器的理解。

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



/*  push_back(ele); //尾部插入元素ele
	pop_back(); //删除最后一个元素
	insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele
	insert(const_iterator pos, int count,ele); //迭代器指向位置pos插入count个元素ele
	erase(const_iterator pos); //删除迭代器指向的元素
	erase(const_iterator start, const_iterator end); //删除迭代器从start到end之间的元素
	clear(); //删除容器中所有元素
*/
void printVector(vector<int> & v)   // 这里既然需要输出容器，必然要传入一个定义的容器变量，采用引用方式
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

}

void test01()
{
	vector<int>v1;   // 1、默认构造函数 
	// 1、插入数据，尾插法
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);


	// 调用一个输出容器的函数
	printVector(v1);   // 这里函数以引用方式做传入的参数，并且参数类型是vector<int>容器类型
	// 2、尾删
	v1.pop_back();   // 这里直接默认删除尾部数据
	printVector(v1);

	// 3、插入
	v1.insert(v1.begin(), 100);  // 这里第一个参数必须插入一个迭代器，第二参数是需要插入的数值
	printVector(v1);

	// 4、删除
	v1.erase(v1.begin());
//	v1.clear();// 清空操作
	printVector(v1);



}

int main() {

	test01();


	system("pause");
	return 0;
}

       实例结果如下图所示：  

dac686e47eed48cdb3be6402967f14f4.png

06-Vector容器数据存取

    在 C++ 的标准模板库（STL）中，vector 容器提供了多种方法用于数据的存取，下面是关于 vector 容器数据存取操作的详细介绍：

数据存取：

  1. 使用下标 [] 运算符：

    • 可以通过下标访问 vector 容器中的元素。
    vector<int> v = {10, 20, 30, 40, 50};
cout << v[1]; // 输出第二个元素，即 20

  2. at 方法：

    • 类似于 [] 运算符，但提供了边界检查，并在索引超出范围时抛出异常。
    vector<int> v = {10, 20, 30, 40, 50};
cout << v.at(3); // 输出第四个元素，即 40

  3. 使用迭代器：

    • 可以使用迭代器访问 vector 容器中的元素，包括正向迭代器和反向迭代器。
    vector<int> v = {10, 20, 30, 40, 50};
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
    cout << *it << " ";
}

  4. front 和 back 方法：

    • front 方法返回容器中第一个元素的引用，back 方法返回容器中最后一个元素的引用。
    vector<int> v = {10, 20, 30, 40, 50};
cout << v.front(); // 输出第一个元素，即 10
cout << v.back(); // 输出最后一个元素，即 50

  5. data 方法：

    • 返回指向存储容器内所有元素的数组的指针，常用于与 C 风格的函数进行交互。
    vector<int> v = {10, 20, 30, 40, 50};
int *ptr = v.data();

       通过以上详细介绍，你可以更全面地了解如何使用 vector 容器进行数据的存取操作。合理地选择不同的方法可以方便地访问和操作 vector 容器中的元素，提高代码效率和可读性。

       下面给出具体代码分析应用过程：这段代码主要演示了使用 vector 容器存储一组整数数据，并通过不同方式进行数据的访问操作。以下是对代码的简要分析：

  1. 头文件包含和命名空间：

    • 引入了 <iostream> 头文件用于输入输出，以及 <vector> 头文件用于使用 vector 容器。
    • 使用 using namespace std; 表示使用 std 命名空间。

  2. test01 函数：

    • 创建一个空的 vector<int> 容器 v1。
    • 使用 push_back 方法向容器中插入整数数据 0 到 9。
    • 通过 [] 运算符访问容器中的元素，依次输出所有元素。
    • 通过 at 方法访问容器中的元素，同样依次输出所有元素。
    • 在每种方式下，使用 for 循环遍历容器中的元素并输出。

  3. main 函数：

    • main 函数调用 test01 函数来执行测试。

  4. 运行结果：

    • 程序执行后，将会输出两次相同的整数序列，分别通过 [] 运算符和 at 方法访问 vector 容器中的元素。

  5. 补充说明：

    • 通过 [] 运算符和 at 方法都可以实现对 vector 容器元素的访问，但使用 at 方法能够进行边界检查，当索引越界时会抛出异常。
    • 在这段代码中，循环遍历容器并输出元素是比较常见的操作，可以方便地查看容器中的数据内容。

       通过这段代码的简要分析，你可以更加熟悉如何在 C++ 中使用 vector 容器存储数据并进行访问操作，同时了解了如何通过 [] 运算符和 at 方法来访问容器中的元素。这些基本操作对于处理容器数据是非常重要的，希望这样的分析对你有所帮助。

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



void test01()
{
	vector<int>v1;   // 1、默认构造函数 

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	// 可以使用[]方式访问
	for (int i = 0; i < v1.size();i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;

	// 使用at方式
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1.at(i) << " ";
	}
	cout << endl;




}

int main() {

	test01();


	system("pause");
	return 0;
}

        实例结果如下图所示：   b09ea5840c51417f89975e074125f9c3.png

07-Vector互换容器

    在 C++ STL 中，vector 容器提供了 swap 方法用于交换两个容器的内容，实现容器之间的互换操作。下面是关于 vector 容器互换容器内容的详细介绍：

swap 方法：

  1. swap 方法：

    • swap 方法可以交换两个容器的所有元素，实现容器内容的互换操作。
    • 语法：void swap(vector& x) noexcept;，其中 x 是另一个 vector 容器。
    • 注意：交换后，原本的容器会变为空，另一个容器则包含原本容器中的所有元素。

  2. 示例代码：

    vector<int> v1 = {1, 2, 3, 4};
vector<int> v2 = {5, 6, 7};

v1.swap(v2);

// 现在 v1 包含 {5, 6, 7}，v2 变为空

  3. 注意事项：

    • swap 不会进行元素的复制或移动，而是直接交换指向元素的内部指针。
    • 交换操作对于大容器的性能开销较小，适合用于交换大量数据的情况。

  4. 与其他容器的互换：

    • 除了两个相同类型的 vector 容器之间可以互换外，不同类型的容器也可以通过 swap 方法进行互换。
    • 例如，vector<int> 与 vector<double> 之间的互换也是可能的。

       通过使用 swap 方法，可以方便快速地交换两个 vector 容器的所有元素，而无需复制或移动元素，提高了程序的效率和性能。这对于需要频繁交换大量数据的情况特别有用，让程序更加高效。希望这个详细介绍对你有所帮助。

       下面给出具体代码分析应用过程：这段代码主要演示了使用 vector 容器的 swap 方法来交换容器内容，并展示了通过巧妙利用 swap 方法来收缩内存空间的用法。以下是对代码的简要分析：

  1. 头文件包含和命名空间：

    • 引入了 <iostream> 头文件用于输入输出，以及 <vector> 头文件用于使用 vector 容器。
    • 使用 using namespace std; 表示使用 std 命名空间。

  2. printVector 函数：

    • 定义了一个函数 printVector，用于打印传入的 vector 容器中的所有元素。

  3. test01 函数：

    • 创建两个 vector<int> 容器 v1 和 v2，分别存储递增和递减的整数序列。
    • 打印输出两个容器的元素。
    • 使用 swap 方法交换 v1 和 v2 的内容。
    • 再次打印输出两个容器的元素，展示交换后的结果。

  4. test02 函数：

    • 创建一个 vector<int> 容器 v，存储从 0 到 99999 的整数序列。
    • 打印输出容器的容量和大小。
    • 使用 resize 方法将容器大小重新指定为 3，但容量没有改变。
    • 利用 swap 方法来收缩内存空间，将匿名对象和原容器进行交换，实现收缩空间的效果。
    • 最后打印输出容器的容量和大小，展示内存空间被收缩的效果。

  5. 运行结果：

    • 程序执行后，会输出各个阶段的容器内容、容量和大小信息，展示了 swap 方法交换容器内容和收缩内存空间的效果。

       通过这段代码的简要分析，你可以了解到如何使用 swap 方法来交换两个容器的内容，并学习了一种利用 swap 方法来收缩 vector 容器内存空间的技巧。这种技巧能够避免浪费过多内存空间，提高程序的效率。希望这个分析对你有所帮助。

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

void printVector(vector<int> & v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end();it++)
	{
		cout << *it <<" ";
	}
	cout << endl;
}
void test01()
{
	vector<int>v1;   // 1、默认构造函数 

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout << "交换前" << endl;
	printVector(v1);

	vector<int>v2;   // 1、默认构造函数 

	for (int i = 10; i > 0; i--)
	{
		v2.push_back(i);
	}
	
	printVector(v2);

	cout << "交换后" << endl;
	v1.swap(v2);
	printVector(v1);
	printVector(v2);



}


// 实际用途
// 巧用swap交换函数可以收缩内存空间
void test02()
{
	vector<int>v;
	for (int i = 0; i < 100000;i++)
	{
		v.push_back(i);
	}
	cout << "v的容量" << v.capacity() << endl;   // 138255
	cout << "v的大小" << v.size() << endl;       // 100000

	v.resize(3);   // 重新指定大小  ，容量并没有改变，很容易浪费空间
	cout << "v的容量" << v.capacity() << endl;    // 138255
	cout << "v的大小" << v.size() << endl;        // 3

	// 巧用swap交换函数可以收缩内存空间
	vector<int>(v).swap(v);    // vector<int>(v)匿名对象的内存，在执行完毕后，将被自动释放
	cout << "v的容量" << v.capacity() << endl;    // 3
	cout << "v的大小" << v.size() << endl;        // 3

}


int main() {

	test02();


	system("pause");
	return 0;
}

        实例运行结果如下图所示：

ee88d9ef24e8491589021a4f30fa4ef2.png

总结

    在 C++ STL 中，vector 容器是一个非常常用的动态数组容器，提供了灵活的数组功能。以下是关于 vector 容器的总结：

特点：

  1. 动态数组：

    • vector 是一个动态数组容器，可以根据需要动态增长或缩减其大小。

  2. 连续存储：

    • vector 中的元素在内存中是连续存储的，因此支持高效的随机访问。

  3. 大小可变：

    • 可以通过 push_back 方法向尾部添加元素，也可以通过 pop_back 方法删除尾部元素。

  4. 下标访问：

    • 可以使用下标运算符 [] 或 at 方法来访问容器中的元素。

  5. 尾部插入、删除高效：

    • 在尾部插入或删除元素的时间复杂度为常数时间，即 O(1)。

  6. 插入、删除中间元素效率低：

    • 在中间位置插入或删除元素的时间复杂度为线性时间，即 O(n)，因为需要移动元素。

常用操作：

  1. 构造与赋值：

    • 支持多种构造方式，如默认构造、指定大小和初始值构造等。
    • 可以使用 assign 方法进行赋值操作。

  2. 访问元素：

    • 提供了 [] 运算符、at 方法、front 和 back 方法等访问元素的方式。

  3. 插入与删除：

    • 提供了 push_back、pop_back、insert、erase 等方法用于插入和删除元素。

  4. 容量操作：

    • 可以使用 size 方法获取容器中元素的数量，使用 capacity 方法获取容器的容量。
    • 支持 resize 方法调整容器的大小，以及 reserve 方法预留容量。

  5. 交换容器：

    • 可以使用 swap 方法交换两个 vector 容器的内容，用于快速交换大量数据或收缩内存空间。

   vector 容器是 C++ 中常用的动态数组容器，具有灵活性和高效性。它支持动态增长和缩减、高效的尾部插入和删除操作，以及随机访问元素等功能。同时，通过 swap 方法可以方便地交换容器内容，用于优化内存使用。在 C++ 编程中，vector 是处理动态数组数据的首选容器之一。

 

一伦明悦
关注
  • 12
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一伦明悦

感谢，您的支持是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值