C++提高编程（黑马程序员）

tauriel别太菜

已于 2023-06-17 00:00:33 修改

阅读量353

点赞数 2

文章标签： c++ 算法排序算法

于 2023-06-13 21:09:37 首次发布

本文链接：https://blog.csdn.net/weixin_40451988/article/details/131172688

版权

本阶段主要针对C++泛型编程和STL技术做详细讲解

1.模板

1.1 模板的概念

模板就是建立通用的模具，提高复用性

1.2函数模板

函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可不具体指定，用一个虚拟的类型来代表
语法：

template<typename T>
函数声明或定义

注：
template --声明创建模板
typename --表示其后面的符号是一种数据类型，可以用class代替
T --通用的数据类型，名称可以替换，通常为大写字母

// 两个整型交换
void swapInt(int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}
// 交换两个浮点型
void swapDouble(double &a, double &b)
{
    double tmp = a;
    a = b;
    b = tmp;
}
void test01()
{
    int a = 10;
    int b = 20;
    swapInt(a, b);
    cout << a << endl;
    cout << b << endl;
    double c = 1.1;
    double d = 2.2;
    swapDouble(c, d);
    cout << c << endl;
    cout << d << endl;
}
// 函数模板
template <typename T> // 声明一个模板，后面代码中的T是一个通用的数据类型
void mySwap(T &a, T &b)
{
    T tmp = a;
    a = b;
    b = tmp;
}
void test02()
{
    int a = 10;
    int b = 20;
    // 两种使用模板的方法
    // 1.自动类型推导
    mySwap(a, b);
    cout << a << endl;
    cout << b << endl;
    // 2.显示指定类型
    mySwap<int>(a, b);
    cout << a << endl;
    cout << b << endl;
}

int main()
{
    test02();
}

1.2.2 函数模板注意事项

注意事项：
-自动类型推到，必须导出一致的数据的数据类型T才可以使用
-模板必须要确定出T的数据类型，才可以使用

template <class T> // typename 可以用class替换
void mySwap(T &a, T &b)
{
    T tmp = a;
    a = b;
    b = tmp;
}
void test01()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    mySwap(a, b);
    // 1.自动类型推导，必须推导出一致的数据类型T才可以使用
    // mySwap(a,c); 错误！
    cout << a << endl;
    cout << b << endl;
}
// 2.模板必须要确定T的数据类型才可以使用
template <class>
void func()
{
    cout << "func" << endl;
}
void test02()
{
    // func();//报错，没有给出T
    func<int>(); // 强行给定一个类型
}

int main()
{
    test02();
}

1.2.3 函数模板案例

案例描述：
-利用函数模板封装一个排序函数，可以对不同数据类型数组进行排序
-排序规则从大到小，排序算法为选择排序

分别用char和int数组进行测试

template <class T> // typename 可以用class替换
void mySwap(T &a, T &b)
{
    T tmp = a;
    a = b;
    b = tmp;
}
template <class T> // typename 可以用class替换
void mySort(T arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        int max = i; // 最大值的下标
        for (int j = i + 1; j < len; j++)
        {
            // 认定最大值比遍历的要小，说明j下标是真正的最大值
            if (arr[max] < arr[j])
            {
                max = j;
            }
        }
        if (max != i)
        {
            mySwap(arr[i], arr[max]);
        }
    }
}
template <class T>
void printArray(T arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << arr[i];
    }
}
void test01()
{
    char charArr[] = "badcfe";
    int num = sizeof(charArr) / sizeof(char);
    mySort(charArr, num);
    printArray(charArr, num);
    // int arr[];
}
void test02()
{
    int intArr[] = {2, 5, 1, 7, 8};
    int num = sizeof(intArr) / sizeof(int);
    mySort(intArr, num);
    printArray(intArr, num);
}
int main()
{
    test02();
}

1.2.4 普通函数和函数模板的区别

-普通函数调用时可以发生自动类型转换（隐式类型转换）

函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式，可以发生隐式类型转换

int myAdd(int a, int b)
{
    return a + b;
}
template <class T>
T myAdd02(T a, T b)
{
    return a + b;
}
void test01()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    cout << myAdd(a, b) << endl;   // 30
    cout << myAdd02(a, b) << endl; // 30
    cout << myAdd(a, c) << endl;   // 109,c对应的ASCII码99，相当于把字符型隐式的转换为int型
    // cout << myAdd02(a, c) << endl;错误！不会发生隐式类型转换
    // 显示指定类型
    cout << myAdd02<int>(a, c) << endl; // 109,发生隐式类型转换
}
int main()
{
    test01();
}

1.2.5 普通函数和函数模板的调用规则

1.如果函数模板和普通函数都可以实现，优先调用普通函数
2.可以通过空模板参数列表来强制调用函数模板
3.函数模板也可以发生重载
4.如果函数模板可以产生更好的匹配，优先调用函数模板
注意：如果提供了模板，就不要提供普通函数版本，容易出现二义性

void myPrint(int a, int b)
{
    cout << "普通函数调用" << endl;
}
template <class T>
void myPrint(T a, T b)
{
    cout << "模板调用" << endl;
}
template <class T>
void myPrint(T a, T b, T c)
{
    cout << "重载的模板调用" << endl;
}
void test01()
{
    int a = 10;
    int b = 10;
    int c = 20;
    char d = 'a';
    char e = 'b';
    myPrint(a, b);    // 1.优先调用普通函数调用
    myPrint<>(a, b);  // 2.通过空模板强制调用模板
    myPrint(a, b, c); // 3.函数模板也可以重载
    myPrint(d, e);    // 4.函数模板能产生更好的匹配，优先调用模板
}
int main()
{
    test01();
}

1.2.6 模板的局限性

模板不是万能的，有些特定的数据类型，需要用具体化方式做特殊实现
模板的重载，为特定的类型提供具体化的模板

class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};
template <class T>
bool myCompare(T &a, T &b)
{
    if (a == b) // 方法1：在Person类中对==符号进行重载
    {
        return true;
    }
    else
    {
        return false;
    }
}

// 方法2：利用具体化的Person版本实现代码，具体化优先调用
template <>
bool myCompare(Person &a, Person &b)
{
    if (a.m_Name == b.m_Name && a.m_Age == b.m_Age) // 方法1：在Person类中对==符号进行重载
    {
        return true;
    }
    else
    {
        return false;
    }
}
void test01()
{
    int a = 10;
    int b = 20;
    bool ret = myCompare(a, b);
    if (ret)
    {
        cout << "a=b" << endl;
    }
    else
    {
        cout << "a!=b" << endl;
    }
}
void test02()
{
    Person p1("Tom", 19);
    Person p2("Tom", 19);
    bool ret = myCompare(p1, p2);
    if (ret)
    {
        cout << "a=b" << endl;
    }
    else
    {
        cout << "a!=b" << endl;
    }
}
int main()
{
    test02();
}

1.3 类模板

1.3.1 类模板语法

类模板作用：
-建立一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表

template <class NameType, class AgeType>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    void showPerson()
    {
        cout << this->m_Name << endl;
        cout << this->m_Age << endl;
    }
    NameType m_Name;
    AgeType m_Age;
};
void test01()
{
    Person<string, int> p1("孙悟空", 19);
    p1.showPerson();
}
int main()
{
    test01();
}

1.3.2 类模板与函数模板的区别

1.类模板没有自动类型推导的使用方式，必须显式指定类型
2.类模板在模板参数列表中可以有默认参数

template <class NameType, class AgeType = int> // 默认为int类型
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    void showPerson()
    {
        cout << this->m_Name << endl;
        cout << this->m_Age << endl;
    }
    NameType m_Name;
    AgeType m_Age;
};
// 1.类模板没有自动类型推导
void test01()
{
    // Person p1("孙悟空", 19);报错，不能自动推导类型
    Person<string, int> p1("孙悟空", 19);
    Person<string> p2("猪八戒", 20); // 制定了默认参数类型，因此可以省略int
    p1.showPerson();
    p2.showPerson();
}
int main()
{
    test01();
}

1.3.3 类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有去别的：

普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建

class Person0
{
public:
    void showPerson0()
    {
        cout << "show person0" << endl;
    }
};
class Person1
{
public:
    void showPerson1()
    {
        cout << "show person1" << endl;
    }
};
template <class T> // 默认为int类型
class MyClass
{
public:
    T obj;
    // 类模板的成员函数,没有调用的时候不会创建
    void func1()
    {
        obj.showPerson0();
    }
    void func2()
    {
        obj.showPerson1();
    }
};

// 1.类模板没有自动类型推导
void test01()
{
    // 在执行的时候再创建成员函数，判断是否能运行
    MyClass<Person0> m;
    m.func1();
    // m.func2();报错
    MyClass<Person1> m2;
    m2.func2();
}
int main()
{
    test01();
}

1.3.4 类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式

三种传入方式：
1.指定传入类型，最常用
2.参数模板化
3.整个类模板化

查看类型
cout<<typeid(NameYype).name()<<endl;

template <class NameType, class AgeType> // 默认为int类型
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    void showPerson()
    {
        cout << "Name:\t" << this->m_Name << endl;
        cout << "Age:\t" << this->m_Age << endl;
    }
    NameType m_Name;
    AgeType m_Age;
};
// 1.指定传入类型
void printPerson1(Person<string, int> &p)
{
    p.showPerson();
}
// 2.参数模板发
template <class NameType, class AgeType>
void printPerson2(Person<NameType, AgeType> &p)
{
    p.showPerson();
    cout << "NameType" << typeid(NameType).name() << endl; // 查看type类型
}
// 3.整个类模板化
template <class T>
void printPerson3(T &p)
{
    p.showPerson();
    cout << "NameType:" << typeid(T).name() << endl;
}
void test01()
{
    Person<string, int> p1("sun", 19);
    printPerson1(p1);
    printPerson2(p1);
    printPerson3(p1);
}
int main()
{
    test01();
}

1.3.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定父类中T的类型，子类也需变成类模板

template <class T>
class Base
{
    T m;
};
// class Son : public Base//必须知道父类的T类型，才能继承给子类
class Son : public Base<int>
{
};
// 若想灵活指定类型，子类也需要变类模板
template <class T1, class T2>
class Son2 : public Base<T2> // T2提供给父类，T1提供给子类
{
    T1 n;
};
void test01()
{
    Son s1;
    Son2<int, char> s2;
}
int main()
{
    test01();
}

1.3.6 类模板成员函数类外实现

template <class NameType, class AgeType> // 默认为int类型
class Person
{
public:
    // 类内实现
    // Person(NameType name, AgeType age)
    // {
    //     this->m_Name = name;
    //     this->m_Age = age;
    // }
    // void showPerson()
    // {
    //     cout << "Name:\t" << this->m_Name << endl;
    //     cout << "Age:\t" << this->m_Age << endl;
    // }
    // 类外实现
    Person(NameType name, AgeType age);
    void showPerson();
    NameType m_Name;
    AgeType m_Age;
};
// 构造函数的类外实现
template <class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) // 1.指定作用域 2.要为模板类指定类型
{
    this->m_Name = name;
    this->m_Age = age;
}
template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "Name:\t" << this->m_Name << endl;
    cout << "Age:\t" << this->m_Age << endl;
}
void test01()
{
    Person<string, int> p("tom", 20);
    p.showPerson();
}
int main()
{
    test01();
}

1.3.7 类模板分文件编写

问题：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到。
解决方法：
方法1：直接包含.cpp源文件
方法2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，.hpp是约定的名称，并不是强制

方法1：
main.cpp

#include <iostream>
#include <string>
#include "person.h"
#include"person.cpp"
using namespace std;
void test01()
{
    Person<string, int> p("tom", 20);
    p.showPerson();
}
int main()
{
    test01();
}

person.h

#pragma once
#include<iostream>
using namespace std;

template <class NameType, class AgeType> // 默认为int类型
class Person
{
public:
    // 类外实现
    Person(NameType name, AgeType age);
    void showPerson();
    NameType m_Name;
    AgeType m_Age;
};

person.cpp

#include "person.h"
template <class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) // 1.指定作用域 2.要为模板类指定类型
{
    this->m_Name = name;
    this->m_Age = age;
}
template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "Name:\t" << this->m_Name << endl;
    cout << "Age:\t" << this->m_Age << endl;
}

-方法2：将.h和.cpp内容写到一起，修改后缀名为.hpp文件
main.cpp同上，person.hpp如下：

#pragma once
#include<iostream>
#include<string>
using namespace std;

template <class NameType, class AgeType> // 默认为int类型
class Person
{
public:
    // 类外实现
    Person(NameType name, AgeType age);
    void showPerson();
    NameType m_Name;
    AgeType m_Age;
};

template <class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) // 1.指定作用域 2.要为模板类指定类型
{
    this->m_Name = name;
    this->m_Age = age;
}
template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "Name:\t" << this->m_Name << endl;
    cout << "Age:\t" << this->m_Age << endl;
}

1.3.8 类模板与友元

掌握类模板配合友元函数的类内和类外实现

全局函数类内实现-直接在类内声明友元即可
全局函数类外实现-需要提前让编译器知道全局函数的存在

// 通过全局函数打印Person信息
// 第2种全局函数的实现方法，需要提前让编译器知道Person类的存在，且将函数放到前面，要让类内知道该代码实现
template <class NameType, class AgeType>
class Person;
template <class NameType, class AgeType>
void showPerson2(Person<NameType, AgeType> p)
{
    cout << "Name:\t" << p.m_Name << endl;
    cout << "Age:\t" << p.m_Age << endl;
}
template <class NameType, class AgeType> // 默认为int类型
class Person
{
    // 1.全局函数在类内实现
    friend void showPerson(Person<NameType, AgeType> &p) // friend 保证可以访问到私有元素
    {
        cout << "Name:\t" << p.m_Name << endl;
        cout << "Age:\t" << p.m_Age << endl;
    }
    // 2.全局函数类外实现
    // 函数模板的声明，需要加一个空参数列表<>,需要让编译器提前知道这个函数
    // template <class NameType, class AgeType>
    friend void showPerson2<>(Person<NameType, AgeType> p);

public:
    // 类内实现
    Person(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

private:
    NameType m_Name;
    AgeType m_Age;
};
void test01()
{
    Person<string, int> p("jerry", 20);
    showPerson(p);
    showPerson2(p);
    // p.showPerson();
}
int main()
{
    test01();
}

1.3.9 类模板案例

实现一个通用的数组类：

可以对内置数据类型以及自定义数据类型的数据进行存储
将数组中的数据存储到堆区
构造函数中可以传入数组的容量
提供对应的拷贝构造函数以及operator=防止浅拷贝问题
提供尾法和尾删法对数组中的数据进行增加和删除
可以通过下标的方式访问数组中的元素。
可以获取数组中当前元素个数和数组的容量
示例：
main.cpp

#include <iostream>
#include <string>
#include "MyArray.hpp"
using namespace std;
void printIntArray(MyArray<int> &arr)
{
    for (int i = 0; i < arr.getSize(); i++)
    {
        cout << arr[i] << endl;
    }
}

void test01()
{
    MyArray<int> arr1(5); // 有参构造
    // MyArray<int> arr2(arr1); // 拷贝构造
    // MyArray<int> arr3(100);
    // arr3 = arr1; //=重载
    for (int i = 0; i < 5; i++)
    {
        arr1.Push_Back(i);
    }
    cout << "arr1" << endl;
    printIntArray(arr1);
    cout << "大小：" << arr1.getCapacity() << "容量" << arr1.getSize() << endl;
    arr1.Pop_back();
    cout << "大小：" << arr1.getCapacity() << "容量" << arr1.getSize() << endl;
}
int main()
{
    test01();
}

MyArray.hpp

#pragma once
#include <iostream>
using namespace std;
template <class T>
class MyArray
{
public:
    // 有参构造
    MyArray(int capacity)
    {
        // cout << "有参构造" << endl;
        this->m_Capacity = capacity;
        this->m_Size = 0;
        this->pAddress = new T[this->m_Capacity];
    }
    // 拷贝构造
    MyArray(const MyArray &arr)
    {
        // cout << "拷贝构造" << endl;
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        // this->pAddress=arr.pAddress;编译器写法，但指针不能这样赋值,出现浅拷贝问题
        // 深拷贝
        this->pAddress = new T[arr.m_Capacity];
        // 将arr中的数据拷贝过来
        for (int i = 0; i < this->m_Size; i++)
        {
            this->pAddress[i] = arr.pAddress[i];
        }
    }
    // operator=防止浅拷贝 a=b=c，返回自身的引用，可以进行连等
    MyArray &operator=(const MyArray &arr) // 这个const是防止误调用
    {
        // cout << "=" << endl;
        if (this->pAddress != NULL) // 首先判断原来的堆区里是否有数据，如果有先释放
        {
            delete[] this->pAddress;
            this->pAddress = NULL;
            this->m_Capacity = 0;
            this->m_Size = 0;
        }
        // 深拷贝
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        this->pAddress = new T[arr.m_Capacity];
        for (int i = 0; i < this->m_Size; i++)
        {
            this->pAddress[i] = arr.pAddress[i];
        }
        return *this; // 返回自身
    }
    // 尾插法
    void Push_Back(const T &val)
    {
        // 判断容量
        if (this->m_Capacity == this->m_Size)
        {
            return;
        }
        this->pAddress[this->m_Size] = val;
        this->m_Size++;
    }
    // 尾删法
    void Pop_back()
    {
        // 让用户访问不到最后一个元素
        if (this->m_Size == 0)
        {
            return;
        }
        this->m_Size--;
    }
    // 访问第N个元素
    T &operator[](int index) // 若想要返回可以作为左值，需要加引用！！！
    {
        return this->pAddress[index];
    }
    // 返回容量和大小
    int getCapacity()
    {
        return this->m_Capacity;
    }
    int getSize()
    {
        return this->m_Size;
    }
    // 析构函数
    ~MyArray()
    {
        // cout << "析构函数" << endl;
        if (this->pAddress != NULL)
        {
            delete[] this->pAddress;
            this->pAddress = NULL;
        }
    }

private:
    T *pAddress;
    int m_Capacity;
    int m_Size;
};

2.STL初始

2.1STL诞生

可重复利用的东西
面向对象和泛型编程，目的就是复用性提升
为了建立数据结构和算法的标准，诞生了STL

2.2 STL基本概念

STL（Standard Template Library，标准模板库）
STL分为：容器、算法、迭代器
容器和算法之间通过迭代器无缝衔接
STL几乎所有的代码都采用了模板类或者模板函数

2.3 STL六大组件

1.容器：各种数据结构，如vector、list、deque、set、map
2.算法：常用的算法，如sort、find、copy、for_each
3.迭代器：容器和算法的胶合剂
4.仿函数：行为类似函数，可作为算法的某种策略
5.适配器（配接器）：修饰容器或者仿函数或迭代器的接口
6.空间配置器：负责空间的配置与管理

2.4 STL中容器、算法、迭代器

容器：将运用最广泛的数据结构实现出来
分类为：

序列式容器：强调值的排序，序列式容器中每个元素均有固定的位置
关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系

算法：
分类为：

质变算法：运算过程中会更改元素的内容，例如：拷贝、替换、删除
非质变算法：运算过程不会更改元素，例如：查找、计算、遍历、寻找最值等

迭代器：
提供一种方法能够以此访问某个容器所含的各个元素，可以理解为指针

2.5 容器算法迭代器初识

2.5.1 vector存放内置数据类型

容器：vector
算法：for_each
迭代器：vector::iterator

#include <iostream>
#include <string>
using namespace std;
#include <vector>    //容器的头文件
#include <algorithm> //标准算法的头文件
void myPrint(int val)
{
    cout << val << endl;
}
void test01()
{
    // 创建容器
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    // 第一种遍历方式
    // 通过迭代器访问数据
    vector<int>::iterator itBegin = v.begin(); // 指向第一个元素
    vector<int>::iterator itEnd = v.end();     // 指向最后一个元素的下一个位置
    while (itBegin != itEnd)
    {
        cout << *itBegin << endl;
        itBegin++;
    }
    // 第二种遍历方式，第一种的简化
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << endl;
    }
    // 第三种遍历方式，利用遍历算法，for_each
    for_each(v.begin(), v.end(), myPrint); // 回调函数，回调函数是参数，但是只能用函数指针调用
}
int main()
{
    test01();
}

2.5.2 vector存放自定义数据类型

#include <iostream>
#include <string>
using namespace std;
#include <vector>    //容器的头文件
#include <algorithm> //标准算法的头文件
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};
// 存放自定数据类型
void test01()
{
    vector<Person> v;
    Person p1("aaaa", 1);
    Person p2("bbbb", 2);
    Person p3("cccc", 3);
    Person p4("dddd", 4);
    Person p5("eeee", 5);
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);
    for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << "姓名" << (*it).m_Name << endl;
        cout << "年龄" << (*it).m_Age << endl;
        cout << "name:" << it->m_Name << endl;
        cout << "age:" << it->m_Age << endl;
    }
}
// 存放自定义数据类型的指针
void test02()
{
    vector<Person *> v;
    Person p1("aaaa", 1);
    Person p2("bbbb", 2);
    Person p3("cccc", 3);
    Person p4("dddd", 4);
    Person p5("eeee", 5);
    v.push_back(&p1);
    v.push_back(&p2);
    v.push_back(&p3);
    v.push_back(&p4);
    v.push_back(&p5);
    // 遍历容器
    for (vector<Person *>::iterator it = v.begin(); it != v.end(); it++)
    {
        // it是一个指针，其指向另一个指针(*it)
        cout << (*it)->m_Name << endl;
        cout << (*it)->m_Age << endl;
    }
}
int main()
{
    test02();
}

2.5.4 vector容器嵌套容器

——类似于二维数组

#include <iostream>
#include <string>
using namespace std;
#include <vector>    //容器的头文件
#include <algorithm> //标准算法的头文件
// 容器嵌套容器
void test01()
{
    vector<vector<int>> v;
    vector<int> v1;
    vector<int> v2;
    vector<int> v3;
    vector<int> v4;
    for (int i = 0; i < 4; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 1);
        v3.push_back(i + 2);
        v4.push_back(i + 3);
    }
    // 将小容器插入大容器
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
    v.push_back(v4);
    // 遍历大容器
    for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
    {
        // 此时(*it)仍为一个容器
        for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
        {
            cout << *vit << " ";
        }
        cout << endl;
    }
}
int main()
{
    test01();
}