• STL好难（3）：vector的使用

    目录

    1.vector的介绍和使用

    2.vector的常见构造：

    3.vector的遍历方式

    🍉[ ] + 下标

    🍉通过迭代器进行访问：

    🍉范围for：

    4.vector的迭代器

    🍉begin 和 end

    🍉rbegin 和 rend

    5.vector空间扩容：

    🍉size

    🍉capacity

    🍉capacity的增容：

    🍉empty

    🍉reserve

    🍉resize

    6.vector 的增删改查

    🍉push back

    🍉pop back

    🍉insert

    🍉erase

    🍉swap

    🍉find

    🍉sort

    7.vector的迭代器失效问题

    🍉情况1：迭代器指向的位置意义改变

    🍉情况2：扩容、缩容，导致迭代器的野指针，使其失效

    8.总结：

    1.vector的介绍和使用

    vector就类似数据结构中的顺序表

    • 1. vector是表示可变大小数组的序列容器。
    • 2. 就像数组一样，vector也采用的连续存储空间来存储元素。
      意味着可以采用下标对vector的元素 进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自 动处理
    • 3. 本质讲，vector使用动态分配数组来存储它的元素。
      当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小
    • vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大
    • vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长
    • 与其它动态序列容器相比，vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效
      对于其它不在末尾的删除和插入操作，效率更低

    2.vector的常见构造：

    在C++98里面主要有以下4中构造

    1）无参构造一个空的容器

    2）构造并初始化 n 个 val 容器 

    3）拷贝构造某类型容器

    4）使用迭代器进行初始化构造

    1. //1）无参构造一个空的容器
    2. vector<int> v1; //构造一个int类型的空容器
    3.  
    4. //2）构造并初始化 n 个 val 容器 
    5. vector<int> v2(3, 6); //构造含有3个6的int类型容器
    6.  
    7. //3）拷贝构造某类型容器
    8. vector<int> v3(v2); //拷贝构造int类型的v2容器
    9.  
    10. //4）使用迭代器进行初始化构造
    11. vector<int> v4(v2.begin()+1, v2.end()-1); //使用迭代器拷贝构造v2容器的某一段内容
    12.     
    13.     //当然也可以用使用迭代器构造其他类型的容器，
    14. 	string s("hello world");
    15. 	vector<char> v5(s.begin(), s.end()); //拷贝构造string对象的某一段内容

    3.vector的遍历方式

    🍉[ ] + 下标

    vector 对 [ ] 运算符进行了重载，所以我们可以直接使用 [ ]+下标 访问或修改对象中的元素

    1. int main()
    2. {
    3. 	vector<int> v1; // 定义容器v1
    4.  
    5. 	// 尾插5个数据
    6. 	v1.push_back(1);
    7. 	v1.push_back(2);
    8. 	v1.push_back(3);
    9. 	v1.push_back(4);
    10. 	v1.push_back(5);
    11.  
    12. 	// 使用下标访问数据
    13. 	for (size_t i = 0; i < v1.size(); ++i)
    14. 	{
    15. 		cout << v1[i] << " ";
    16. 	}
    17. 	cout << endl;
    18.  
    19. 	// 使用下标修改数据
    20. 	for (size_t i = 0; i < v1.size(); ++i)
    21. 	{
    22. 		v1[i] += 3;
    23. 		cout << v1[i] << " ";
    24. 	}
    25. 	cout << endl;
    26.  
    27. 	retur

    结果： 

    🍉通过迭代器进行访问：

    begin 获取一个字符的迭代器， end获取最后一个字符下一个位置的迭代器

    1. int main()
    2. {
    3. 	vector<int> v2; // 定义容器v2
    4.  
    5. 	// 尾插5个数据
    6. 	v2.push_back(1);
    7. 	v2.push_back(2);
    8. 	v2.push_back(3);
    9. 	v2.push_back(4);
    10. 	v2.push_back(5);
    11.  
    12. 	// 使用迭代器访问数据
    13. 	vector<int>::iterator it1 = v2.begin();
    14. 	while (it1 != v2.end())
    15. 	{
    16. 		cout << *it1 << " ";
    17. 		it1++;
    18. 	}
    19. 	cout << endl;
    20.  
    21. 	// 使用迭代器修改数据
    22. 	vector<int>::iterator it2 = v2.begin();
    23. 	while (it2 != v2.end())
    24. 	{
    25. 		*it2 += 1;
    26. 		cout << *it2 << " ";
    27. 		it2++;
    28. 	}
    29.  
    30. 	return 0;
    31. }

    结果如下： 

    🍉范围for：

    1. int main()
    2. {
    3. 	vector<int> v3; // 定义容器v3
    4.  
    5. 	// 尾插5个数据
    6. 	v3.push_back(1);
    7. 	v3.push_back(2);
    8. 	v3.push_back(3);
    9. 	v3.push_back(4);
    10. 	v3.push_back(5);
    11.  
    12. 	// 使用范围for访问数据
    13. 	for (auto a : v3)
    14. 	{
    15. 		cout << a << " ";
    16. 	}
    17. 	cout << endl;
    18.  
    19. 	// 使用范围for修改数据
    20. 	for (auto& a : v3)
    21. 	{
    22. 		a += 4;
    23. 		cout << a << " ";
    24. 	}
    25.  
    26. 	return 0;
    27. }

    结果：

    4.vector的迭代器

    正向迭代器：

     

    反向迭代器：

    如下图：

    🍉begin 和 end

    通过 begin 函数可以得到容器中第一个元素的正向迭代器

    通过 end 函数可以得到容器中最后一个元素的后一个位置的正向迭代器

    左闭右开

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.push_back(1);
    6. 	v.push_back(2);
    7. 	v.push_back(3);
    8. 	v.push_back(4);
    9. 	v.push_back(5);
    10.  
    11. 	//正向迭代器遍历容器
    12. 	vector<int>::iterator it = v.begin();
    13. 	//也可以用auto来自动识别：auto it = v.begin();
    14. 	while (it != v.end()) 
    15. 	{
    16. 		cout << *it << " ";
    17. 		it++;
    18. 	}
    19.  
    20. 	return 0;
    21. }

      

    🍉rbegin 和 rend

    通过 rbegin 函数可以得到容器中最后一个元素的反向迭代器

    通过 rend 函数可以得到容器中第一个元素的前一个位置的反向迭代器

    左开右闭

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.push_back(1);
    6. 	v.push_back(2);
    7. 	v.push_back(3);
    8. 	v.push_back(4);
    9. 	v.push_back(5);
    10.  
    11. 	//反向迭代器遍历容器
    12. 	vector<int>::reverse_iterator it = v.rbegin();
    13. 	//也可以用auto来自动识别：auto it = v.rbegin();
    14. 	while (it != v.rend())
    15. 	{
    16. 		cout << *it << " ";
    17. 		it++;
    18. 	}
    19.  
    20. 	return 0;
    21. }

     

    5.vector空间扩容：

    官方文本里面的内容：

     我们主要学习：

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

    点击这里查看文档

    🍉size

    size 函数获取当前容器的有效元素个数

    1. int main()
    2. {
    3. 	vector<int> v(6, 5);	//定初始化6个5
    4.  
    5. 	cout << v.size() << endl; //获取当前容器中的有效元素个数
    6.  
    7. 	return 0;
    8. }

    🍉capacity

    capacity 函数获取当前容器的最大容量

    1. int main()
    2. {
    3. 	vector<int> v(6, 5);	//定初始化6个5
    4.  
    5. 	//获取当前容器中的容量大小
    6. 	cout << v.capacity() << endl; // 结果：6
    7.  
    8. 	return 0;
    9. }

    🍉capacity的增容：

    可以看下面代码实例：

    1. int main()
    2. {
    3. 	size_t sz;
    4.  
    5. 	vector<int> v;
    6.  
    7. 	sz = v.capacity();
    8.  
    9. 	cout << "making for grow:\n";
    10.  
    11. 	for (int i = 0; i < 100; ++i) 
    12.     {
    13. 		v.push_back(i);
    14. 		if (sz != v.capacity())
    15.         {
    16. 			sz = v.capacity();
    17. 			cout << "capacity changed: " << sz << endl;
    18. 		}
    19. 	}
    20.  
    21. 	return 0;
    22. }

    结果：

    可以看到在VS2022下，capacity 是按照 1.5 倍增长的，

    当然，在不同编译环境下，其增长倍数不同，如果在Linux下就是2倍的增长

    着是应为VS用的是 PJ版本，Linux的 g++ 用的是 SGI版本

    🍉empty

    empty 函数用来判断当前容器是否为空。

    • 如果为空，输出1，否则，输出0
    1. int main()
    2. {
    3. 	vector<int> v1(3, 6);
    4. 	cout << v1.empty() << endl; // v1非空，输出0
    5.  
    6. 	vector<int> v2;
    7. 	cout << v2.empty() << endl; // v2为空，输出1
    8.  
    9. 	return 0;
    10. }

    🍉reserve

    reserve函数用来改变vector的最大容量

    其有两个注意点，如下：

    1. 当所给值大于容器当前的 capacity 时，将 capacity 扩大到该值
    2. 当所给值小于容器当前的 capacity 时，什么也不做

    用法：当我们事先知道要用多大空间时，就提前用reserve开辟好，来减少代码增容时的消耗

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.reserve(100); // 提前开好100空间
    6.  
    7. 	//......
    8.  
    9. 	return 0;
    10. }

    🍉resize

    resize 函数改变容器中的有效元素个数。

    1）当所给值大于当前的 size 时，将 size 扩大到该值，扩大的元素为第二个所给值，若为给出，则默认为0

    2）当所给值小于容器当前的 size 时，只将初始化给的值的数

    1. int main()
    2. {
    3. 	vector<int> v1(6, 3);
    4.  
    5. 	v1.reserve(20);
    6. 	cout << v1.capacity() << endl;
    7. 	cout << v1.size() << endl << endl;
    8.  
    9. 	v1.resize(10);
    10. 	cout << v1.capacity() << endl;
    11. 	cout << v1.size() << endl;
    12.  
    13. 	return 0;
    14. }

    结果：

     注意：

    • reserve 只负责开辟空间，如果确定知道需要用多少空间，可以用 reserve 缓解 vector 扩容代价，reserve不会影响size
    • resize 在开空间的同时还会进行初始化，会影响 size。

    6.vector 的增删改查

    C++文档里面的内容：

    我们重点学下面这些：

    vector增删改查接口说明
    push back尾插
    pop back尾删
    find查找（这个是算法模块，不是vector接口）
    insert在position之前插入val
    erase删除position位置数据
    swap交换两个vector位置的数据

     点击这里查看文档

    🍉push back

    尾插

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	//使用push_back插入5个数据
    6. 	v.push_back(1);
    7. 	v.push_back(2);
    8. 	v.push_back(3);
    9. 	v.push_back(4);
    10. 	v.push_back(5);
    11.  
    12. 	//打印
    13. 	for (auto e : v) 
    14. 	{
    15. 		cout << e << " ";
    16. 	}
    17.  
    18. 	return 0;
    19. }

    🍉pop back

    尾删：

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	//使用push_back尾插6个数据
    6. 	v.push_back(1);
    7. 	v.push_back(2);
    8. 	v.push_back(3);
    9. 	v.push_back(4);
    10. 	v.push_back(5);
    11. 	v.push_back(6);
    12.  
    13. 	//使用pop_back尾删3个数据
    14. 	v.pop_back();
    15. 	v.pop_back();
    16. 	v.pop_back();
    17. 	v.pop_back();
    18.  
    19. 	//打印
    20. 	for (auto e : v) 
    21. 	{
    22. 		cout << e << " ";
    23. 	}
    24.  
    25. 	return 0;
    26. }

    🍉insert

    insert函数可以在所给迭代器位置插入一个或多个元素

    1）插入一个值：

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.push_back(1);
    6. 	v.push_back(2);
    7. 	v.push_back(3);
    8. 	v.push_back(4);
    9. 	v.push_back(5);
    10.  
    11. 	//在容器头部插入9
    12. 	v.insert(v.begin(), 9);
    13.  
    14. 	//在位置2插入6
    15. 	v.insert(v.begin()+2, 6);
    16.  
    17.  
    18. 	//打印
    19. 	for (auto e : v) 
    20. 	{
    21. 		cout << e << " ";
    22. 	}
    23.  
    24. 	return 0;
    25. }

    结果：         9 1 6 2 3 4 5

    2）插入多个值：

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.push_back(1);
    6. 	v.push_back(2);
    7. 	v.push_back(3);
    8. 	v.push_back(4);
    9. 	v.push_back(5);
    10.  
    11. 	//在容器头部插入2个4
    12. 	v.insert(v.begin(), 2, 4);
    13.  
    14. 	//打印
    15. 	for (auto e : v) 
    16. 	{
    17. 		cout << e << " ";
    18. 	}
    19.  
    20. 	return 0;
    21. }

    结果：         4 4 1 2 3 4 5

    🍉erase

    erase 函数用来删除所给迭代器位置的元素，或者删除所给迭代器区间内的所有函数（左闭右开）

    1）删除一个值

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.push_back(1);
    6. 	v.push_back(2);
    7. 	v.push_back(3);
    8. 	v.push_back(4);
    9. 	v.push_back(5);
    10.  
    11. 	//头删
    12. 	v.erase(v.begin());
    13.  
    14. 	//尾删
    15. 	v.erase(v.end()-1); //因为是左闭右开区间，所以end-1才能删掉‘5’
    16.  
    17. 	//打印
    18. 	for (auto e : v) 
    19. 	{
    20. 		cout << e << " ";  //结果：2 3 4 
    21. 	}
    22.  
    23. 	return 0;
    24. }

    2）删除一个区间的值

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.push_back(0);
    6. 	v.push_back(1);
    7. 	v.push_back(2);
    8. 	v.push_back(3);
    9. 	v.push_back(4);
    10. 	v.push_back(5);
    11. 	v.push_back(6);
    12. 	v.push_back(7);
    13. 	v.push_back(8);
    14. 	v.push_back(9);
    15.  
    16.  
    17. 	//删除在该迭代器区间内的元素（左闭右开]
    18. 	v.erase(v.begin()+3, v.end() - 3);
    19.  
    20. 	//打印
    21. 	for (auto e : v) 
    22. 	{
    23. 		cout << e << " ";//结果：0 1 2 7 8 9
    24. 	}
    25.  
    26. 	return 0;
    27. }

    🍉swap

    通过swap函数来交换两个容器的数据空间，实现两个容器的交换

    1. int main()
    2. {
    3. 	//容器v1
    4. 	vector<int> v1;
    5. 	v1.push_back(1);
    6. 	v1.push_back(1);
    7. 	v1.push_back(1);
    8.  
    9. 	//容器v2
    10. 	vector<int> v2;
    11. 	v2.push_back(2);
    12. 	v2.push_back(2);
    13. 	v2.push_back(2);
    14.  
    15. 	//交换v1和v2的数据
    16. 	v1.swap(v2);
    17.  
    18. 	//打印v1
    19. 	cout << "v1：";
    20. 	for (auto e1 : v1) 
    21. 	{
    22. 		cout << e1 << " ";
    23. 	}
    24. 	cout << endl;
    25.  
    26.  
    27. 	//打印v2
    28. 	cout << "v2：";
    29. 	for (auto e2 : v2)
    30. 	{
    31. 		cout << e2 << " ";
    32. 	}
    33.  
    34. 	return 0;
    35. }

    🍉find

    由于 vector 没有 find 函数，如果我们要用的话，我们需要去调用算法库里面的一个函数接口：find

    使用 std:: find 需要包头文件 #include

    可以看到 find 共有三个参数，前两个确定迭代器的区间，第三个参数确定所要寻找的返回值

    函数在所给迭代器区间内寻找，
    若找到，返回第一个匹配的元素，并返回它的迭代器
    若未找到，返回第二个参数

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.push_back(1);
    6. 	v.push_back(2);
    7. 	v.push_back(3);
    8. 	v.push_back(4);
    9. 	v.push_back(5);
    10. 	v.push_back(6);
    11.  
    12. 	// 假设我要3的前面插入600
    13. 	//vector::iterator pos = find(v.begin(), v.end(), 3);
    14. 	//上面的类型可以直接用auto去推算：
    15. 	auto pos = find(v.begin(), v.end(), 3);
    16. 	if (pos != v.end())
    17. 	{
    18. 		cout << "找到" << endl;
    19. 		v.insert(pos, 600);
    20. 	}
    21. 	else
    22. 	{
    23. 		cout << "未找到" << endl;
    24. 	}
    25.  
    26. 	for (auto e : v) 
    27. 	{
    28. 		cout << e << " "; //结果： 1 2 600 3 4 5 6
    29. 	}
    30.  
    31. 	return 0;
    32. }

    🍉sort

    sort 函数  和  find 函数  一样，在vector里面没有明确给出，需要用std库里面的：

    也需要包头文件

    1）默认升序：

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.push_back(7);
    6. 	v.push_back(1);
    7. 	v.push_back(0);
    8. 	v.push_back(-1);
    9. 	v.push_back(9);
    10. 	v.push_back(3);
    11.  
    12. 	// 默认排升序
    13. 	sort(v.begin(), v.end());
    14.  
    15. 	// 打印
    16. 	for (auto e : v)
    17. 	{
    18. 		cout << e << " ";
    19. 	}
    20.  
    21. 	return 0;
    22. }

    2）降序

    排降序需要用到仿函数，就要包仿函数的头文件： #include  

    1. int main()
    2. {
    3. 	vector<int> v;
    4.  
    5. 	v.push_back(7);
    6. 	v.push_back(1);
    7. 	v.push_back(0);
    8. 	v.push_back(-1);
    9. 	v.push_back(9);
    10. 	v.push_back(3);
    11.  
    12. 	// 排降序，需要包上仿函数的头文件 #include  
    13. 	sort(v.begin(), v.end(), greater<int>());
    14.  
    15. 	for (auto e : v)
    16. 	{
    17. 		cout << e << " ";
    18. 	}
    19.  
    20. 	return 0;
    21. }

    7.vector的迭代器失效问题

    说了这么多的迭代器，那么迭代器到底是个什么东西呢？

    其实迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector 的迭代器就是原生指针 T*

    因此，迭代器失效，就是迭代器底层对应指针所指向的空间别销毁了，而使用一块已经被销毁的空间，则会导致程序崩溃

    🍉情况1：迭代器指向的位置意义改变

    看下面这段代码：

    1. int main()
    2. {
    3. 	vector<int> v;
    4. 	v.push_back(1);
    5. 	v.push_back(2);
    6. 	v.push_back(3);
    7. 	v.push_back(4);
    8. 	v.push_back(5);
    9.  
    10. 	vector<int>::iterator pos = find(v.begin(), v.end(), 3); //获取值为3的元素的迭代器
    11.  
    12. 	// 1 2 60 3 4 5
    13. 	v.insert(pos, 60); // 在3的位置前插入60
    14.  
    15. 	// 删除pos位置的数据，我们会认为pos仍指向3，所以删除后的结果为：1 2 60 4 5
    16. 	v.erase(pos); 
    17.  
    18.     //但是实际上，会在再次范文pos时出错
    19.  
    20.  
    21. 	return 0;
    22. }

     这时VS的assert（）的强制检查报错

    原因如下：

    我们给数组：1 2 3 4 5 中 3 前面插入 60，我们需要先用迭代器来接受 find 找到的值
    此时pos的位置如下：

    我们在用easer删除元素3，此时就会报错

     

    可以看到，我们认为插入后pos应该还指向 ‘ 3 ’ ，但是，实际上pos以及指向了60，这时pos的被改变了，如果我们再进行其他操作，系统检测到pos指向的不是3，那么VS就会强制报错，导致程序崩溃

    如果我们需要删除元素3，就需要更新pos的值，解决方法如下：

    1. int main()
    2. {
    3. 	vector<int> v;
    4. 	v.push_back(1);
    5. 	v.push_back(2);
    6. 	v.push_back(3);
    7. 	v.push_back(4);
    8. 	v.push_back(5);
    9.  
    10. 	vector<int>::iterator pos = find(v.begin(), v.end(), 3); //获取值为3的元素的迭代器
    11.  
    12. 	// 1 2 60 3 4 5
    13. 	pos = v.insert(pos, 60); // 在3的位置前插入60，并更新 pos 的值
    14.  
    15. 	v.erase(pos+1); 
    16.  
    17.     //也可以：pos = find(v.begin(), v.end(), 3);  v.erase(pos); 
    18.  
    19. 	for (auto e : v)
    20. 	{
    21. 		cout << e << " ";
    22. 	}
    23.  
    24.     //结果： 1 2 60 4 5
    25.  
    26. 	return 0;
    27. }

    再设计insert、erase这种会改变数组的函数时，制作人考虑到了迭代器会发生改变，所以就给其加了返回值，返回新的迭代器

    用 pos = v.insert(pos, 60); 来更新pos，此时pos指向的就应该为60的元素

    insert是在其前面插入，所以这时元素3就在pos指向的后面

    所以用  v.erase(pos+1);  就能删除元素 ‘3’

     

    也可以再用  pos = find(v.begin(), v.end(), 3);  更新pos的值，使其指向3

    然后用  v.erase(pos);  删除pos位置的值

     

    🍉情况2：扩容、缩容，导致迭代器的野指针，使其失效

    看如下代码：

    1. int main()
    2. {
    3. 	vector<int> v;
    4. 	v.push_back(1);
    5. 	v.push_back(2);
    6. 	v.push_back(3);
    7. 	v.push_back(4);
    8.  
    9. 	auto it = v.begin();
    10.  
    11. 	v.reserve(10);
    12.  
    13. 	//vector::iterator it = v.begin();
    14. 	//用迭代器进行打印
    15. 	while (it != v.end()) 
    16. 	{
    17. 		cout << *it << " ";
    18. 		it++;
    19. 	}
    20.  
    21. 	return 0;
    22. }

    会报错：

     

    我们通过调试来看：

    扩容之前，it指向的空间就是其 v.begin() 的空间，

    再扩容之后，it指向的空间不变，但是扩容是异地扩，导致it迭代器失效，所以后面进行打印操作时，会发生报错

    这就是扩容导致的迭代器失效

    解决方法：再扩容之后更新迭代器：

    1. int main()
    2. {
    3. 	vector<int> v;
    4. 	v.push_back(1);
    5. 	v.push_back(2);
    6. 	v.push_back(3);
    7. 	v.push_back(4);
    8.  
    9. 	auto it = v.begin();
    10.  
    11. 	v.reserve(10);
    12.  
    13. 	//由于扩容，所以需要更新迭代器
    14. 	it = v.begin();
    15.  
    16. 	//vector::iterator it = v.begin();
    17. 	//用迭代器进行打印
    18. 	while (it != v.end()) 
    19. 	{
    20. 		cout << *it << " ";
    21. 		it++;
    22. 	}
    23.  
    24. 	return 0;
    25. }

    8.总结：

    通过上面的学习我们发现 vector 常用的接口更多是插入和遍历

    遍历更喜欢用数组 operator[ i ] 的形式访问，因为这样便捷

  • 相关阅读:
    分布式事务 —— SpringCloud Alibaba Seata
    单片机通用Bootloader框架-优化
    PCB 各层定义
    数据结构与算法之美 复杂度分析(下)
    通过 chatgpt 协助完成网站数据破解
    包含漏洞-读写文件以及执行命令
    smartmontools-5.43交叉编译Smartctl
    ES 数据库
    Conmi的正确答案——Ubuntu修改国内源（阿里云 aliyun）
    二进制安装Kubernetes（k8s）v1.30.1
  • 原文地址：https://blog.csdn.net/weixin_60630270/article/details/130905392