泛型编程 之模板（template）

    C++另一种编程思想称为 泛型编程，主要利用的技术就是模板

---

        

目录

    C++另一种编程思想称为 泛型编程，主要利用的技术就是模板

          一、概念

          二、函数模板 

        1、语法与使用：

        2、函数模板注意事项

        3、普通函数与函数模板的区别

        4、普通函数与函数模板的调用规则

        5、模板的局限性

         三、类模板

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

1、语法与使用

 2、类模板与函数模板的区别

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

4、类模板对象作函数参数

三种方式：

①指定传入的类型： 直接显示对象的数据类型（主要用的类型）

②参数模板化：        将对象中的参数变为模板进行传递

③整个类 模板化：   将这个对象类型 模板化进行传递

 5、类模板与继承

①当子类继承的父类是一个类模板时，子类在声明时，要指定出父类中T的类型

②如果不指定，编译器无法给子类分配内存，因为不知道父类中成员的大小

③如果想灵活指出父类中T的类型，子类也需要变成类模板

6、类模板成员函数类外实现

①类模板构造函数类外实现

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

7、类模板分文件编写

①直接包含.cpp文件

②将声明与实现写在一个hpp文件中（约定俗成hpp，并不必须）

8、类模板与友元

①全局函数类内实现：直接在类内声明友元即可

②全局函数类外实现：先提取让编译器知道全局函数的存在

 9、类模板案例

 实现一个通用的数组类，要求：

①可以对内置数据类型以及自定义数据类型进行存储

②将数组中的数据存储到堆区

③构造函数中要传入数组的容量

④提供拷贝构造函数以及operator=，以防止浅拷贝问题

⑤提供尾插法与尾删法对数组中数据进行增加与删除

⑥通过下标的方式访问数组中的元素

⑦获取当前数组中元素的个数以及数组的容量

---

        一、概念

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

如拍一寸照片的模板：

 制作PPT的模板

但是注意：模板并不是万能的，如人的1寸照片模板，不能用来拍其他生物的照片

而且，制作PPT时不能直接使用，需要自己加内容啥的

---

因此：

①模板不能直接使用，只是一个框架，需要自己合理使用

②模板是通用的，但不是万能的 

---

          二、函数模板 

作用：建立一个通用函数，其返回值类型与形参类型可以不指定，用一个虚拟的类型来代表

---

        1、语法与使用：

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

template：声明创建模板

typename：表示其后面的符号是一种数据类型，可以用class

T：通用的数据类型，名称可以替换，通常为大写字母T

---

接下来使用交换函数swap来举例：

首先写出int整型交换函数与float浮点型交换函数

// 整型 交换函数
void swapInt(int& x, int& y)
{int tmp = y;y = x;x = tmp;
}
// 浮点型 交换函数
void swapFloat(float& x, float& y)
{float tmp = y;y = x;x = tmp;
}

测试：

int main()
{int a = 10;int b = 20;swapInt(a, b);cout << a <<" " << b << endl;float c = 10.5;float d = 20.5;swapFloat(c, d);cout << c << " " << d << endl;return 0;
}

 可以正常交换并输出

---

但是，想要交换不同的数据，就必须实现不同的函数，改变返回值类型或者形参类型，但是具体代码又类似

因此，我们使用函数模板：

template<typename T>
void Myswap(T& x, T& y)
{T tmp = y;y = x;x = tmp;
}

调用Myswap函数

	int a = 10;int b = 20;Myswap(a, b);cout << a <<" " << b << endl;float c = 10.5;float d = 20.5;Myswap(c, d);cout << c << " " << d << endl;

而我们在调用函数时，并未告知Myswap函数我们传入的类型是什么，使编译器自动推导出类型并实现

这叫做 自动推导类型

---

还有个 显式指定类型

	int e = 100;int f = 20;Myswap<int>(e, f);cout << e << " " << f << endl;

 就是调用函数时，在参数列表前加上<int>，这就相当于告知编译器刚才的类型T等于int

---

       2、函数模板注意事项

①自动推导类型，必须推导出一致的数据类型T，才可以正常使用

以我们上面的交换函数Myswap举例：

template<typename T>
void Myswap1(T& x)
{T tmp = y;y = x;x = tmp;
}

我们写2个不同的数据类型，尝试调用

	int a = 10;float b = 22.4;Myswap1(a, b);

直接报错

 因此不能使用

不过，如果在函数模板里写2个typename，则可以正常调用

template<typename T,typename Y>
void Myswap1(T& x, Y& y)
{Y tmp = y;y = x;x = tmp;
}

2个数据类型

	int a = 10;float b = 22.4;Myswap1(a, b);

 此时可以正常输出，但是输出结果都是int整型

②模板必须要确定T的数据类型，才可以使用

template<typename T>
void test01()
{cout << "ko" << endl;
}

此时函数内未声明T的数据类型

尝试调用

直接报错

因为未确定T的函数类型

---

解决：

在函数调用参数列表前加上<int>，即随便指定个数据类型，因为函数中没有使用具体的类型

 

---

实例1：

使用函数模板实现选择排序对不同数据类型的数组进行降序排序

首先使用模板实现选择排序

template<typename T>
void Select_sort(T arr[],int len)
{int index = 0;for (int i = 0; i < len - 1; i++){index = i;for (int j = i + 1; j < len; j++){    // 我们认定的最大值比数组中某个值小if (arr[index] < arr[j]){   // 交换两者下标index = j;}}if (index != i) // 如果交换了下标（不等于原来的i）{MYswap(arr[index], arr[i]);//进行数组中数据的交换}}
}

最后一步有数据的交换，我们接着使用模板实现交换函数

template<typename T>
void MYswap(T& x, T& y)
{T tmp = x;x = y;y = tmp;
}

这里就完成了，不过为了使数组中内容可以呈现在屏幕上，我再额外实现一个打印函数

template<typename T>
void print(T arr, int len)
{for (int i = 0; i < len; i++){cout << arr[i] << " ";}cout << endl;
}

①int类型数组测试

void int_test()
{// 整型数组测试int arr[] = { 2,4,6,1,3,26,7,1,2,4,9,0,2,3 };int len = sizeof(arr) / sizeof(arr[0]);print(arr, len);Select_sort(arr, len);cout << endl;print(arr, len);
}

②char类型数组测试

void char_test()
{// 字符数组测试char arr2[] = "zcnasijda";int len2 = sizeof(arr2) / sizeof(char);print(arr2, len2);Select_sort(arr2, len2);cout << endl;print(arr2, len2);
}

成功进行降序排序 

---

        3、普通函数与函数模板的区别

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

②函数模板调用时，如果使用自动类型推导，则不会发生隐式类型转换

③函数模板调用时，如果使用显式指定类型，则可以发生隐式类型转换

---

首先创建普通函数

// 普通函数
void add01(int x, int y)
{cout << x + y << endl;
}

调用：

	add01(10, 20);

 创建字符变量c并调用

	char c = 'c';add01(10, c);

 因为c的ASCII码值是99，99+10=109，函数在内部进行隐式类型转换

下面用函数模板实现

template<typename T>
void add02(T x, T y)
{cout << x + y << endl;
}

使用自动类型推导调用10与字符c

 直接报错，因为不能进行隐式类型转换

而我们使用显式指定类型：

 可以正常输出，因为进行了隐式类型转换，无论你传入什么数据，都给你转成int，转不成就报错

---

        4、普通函数与函数模板的调用规则

①如果普通函数与函数模板都可以实现，优先调用普通函数

实现一个大致相同的普通函数与函数模板

void print(int x, int y)
{cout << "普通函数" << endl;
}
template<typename T>
void print(T x, T y)
{cout << "函数模板" << endl;
}

调用生成

② 在情况①下，通过空模板参数列表，可以强制调用函数模板

 即在函数调用的参数列表前加<>

③函数模板也可以发送重载

template<typename T>
void print(T x, T y)
{cout << "函数模板" << endl;
}
template<typename T>
void print(T x, T y,T z) // 重载
{cout << "函数模板" << endl;
}

④如果函数模板可以发生更好的匹配，优先调用函数模板

 2个char类型的变量，传入普通函数需要进行隐式类型转换，而传入函数模板只需要进行自动类型推导，因此优先调用函数模板

---

        5、模板的局限性

局限性：模板的通用并不万能

举例：写一个判断变量是否相等的模板，以及相等输出相等，否则输出不等的函数

template<typename T>
bool My_compare(T a, T b)
{if (a == b){return true;}else{return false;}
}
void judge(bool a)
{if (a){cout << "相等" << endl;}else{cout << "不等" << endl;}
}

测试：

void test01()
{int a = 10;int b = 10;bool ret = My_compare(a, b);judge(ret);
}

很明显，a==b

 但是，如果a和b的类型是一个类class

class person
{
public:person(string name,int age){m_age = age;m_name = name;}int m_age;string m_name;
};void test02()
{person p1("Tim", 22);person p2("Tim", 22);bool ret = My_compare(p1, p2);judge(ret);
}

很明显，p1==p2，但是编译器无法正常运行

 因为person是自定义数据类型，编译器不知道咋办

---

因此，我们使用具体化person的版本实现代码，具体化优先调用

在下面重写一个模板，前面加template<>，后面数据类型写person

template<>bool My_compare(person& p1, person& p2)
{if (p1.m_age == p2.m_age && p1.m_name == p2.m_name){return true;}else{return false;}
}

再次尝试运行

void test02()
{person p1("Tim", 22);person p2("Tim", 22);bool ret = My_compare(p1, p2);judge(ret);
}

成功，而传入数组判断相等也是同样的问题

---

总结：

①利用具体化的模板，可以解决自定义类型的通用化

②学习模板不是为了写模板，而是为了在STL能够运用系统提供的模板

---

三、类模板

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

---

1、语法与使用

template<class T>
类

与函数模板基本相同，只要把typename改成class就行，而且二者可以互换，效果相同

---

例：写一个类模板，其中有属性name与age，不指定类型，调用输出

template<class Name_type,class Age_type >
class person
{
public:person(Name_type name, Age_type age){m_name = name;m_age = age;}void show(){cout << this->m_name << this->m_age << endl;}Name_type m_name;Age_type m_age;
};

测试：

void test01()
{person<string, int> p1("Joyce", 22);p1.show();
}

---

 2、类模板与函数模板的区别

①类模板没有自动类型推导使用方式

对于刚才的类模板

template<class Name_type,class Age_type >
class person
{
public:person(Name_type name, Age_type age){m_name = name;m_age = age;}void show(){cout << this->m_name << this->m_age << endl;}Name_type m_name;Age_type m_age;
};

如果我们使用自动类型推导：

直接报错

 而只能用显式指定类型

②类模板在模板参数列表中可以有默认参数

我们在模板的参数列表中加入默认参数：

 让Age_type直接等于int

void test02()
{person<string> p2("tatina", 22); // 显式指定类型p2.show();
}

 在调用时，我们不用写其类型也可以正常运行

---

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

普通类中：成员函数一开始就可创建

类模板中：成员函数在调用时才创建

---

例：

首先创建2个类，区分为类1与类2，内部分别创建函数输出数字1与2

class person1
{
public:void show1(){cout << "1" << endl;}
};
class person2
{
public:void show2(){cout << "2" << endl;}
};

下面实现类模板

template<class T>
class Myclass
{
public:T obj;void m_show1(){obj.show1();}void m_show2(){obj.show2();}
};

测试：参数列表传person1，调用m_show1函数

void test02()
{Myclass<person1> m;m.m_show1();
}

输出1

---

尝试调用2：

 报错

此时就已经说明类模板中成员函数一开始没有创建，只有在调用了，才能确定对象的类型，才能创建成员函数

而我们类型传入person2，运行结果相反

---

4、类模板对象作函数参数

三种方式：

①指定传入的类型： 直接显示对象的数据类型（日常主要用的类型）

②参数模板化：        将对象中的参数变为模板进行传递

③整个类 模板化：   将这个对象类型 模板化进行传递

---

创建一个类模板，参数类型为T1与T2

template<class T1,class T2>
class person
{
public:person(T1 name, T2 age){m_name = name;m_age = age;}void showinfo(){cout << this->m_name << this->m_age << endl;}T1 m_name;T2 m_age;
};

①指定传入的类型：

void print1(person<string, int>& p)// 直接把下面的类型拿来使用
{p.showinfo();
}
void test01()
{person<string, int> p1("joyce", 21);print1(p1);
}

可见，print1函数参数直接拿p1的数据类型使用，这就是指定传入的类型

---

②参数模板化：

void test02()
{person<string, int> p2("tatina", 20);print2(p2);
}

print2函数

template<class T1, class T2> 
void print2(person<T1, T2>& p2)// 参树模板化为T1与T2
{p2.showinfo();cout << typeid(T1).name() << endl;// 查看T1的类型cout << typeid(T2).name() << endl;// 查看T2的类型
}

就是将参数也模板化为T1与T2

同时，如果想查看数据的类型，可以使用typeid().name()函数

---

③整个类模板化

 同样的测试函数

void test03()
{person<string, int> p3("yomi", 1);print3(p3);
}

然后是print3，将整个类模板化

template<class T>
void print3(T& p)// 直接用T，让编译器推导出类型
{p.showinfo();
}

看一下T的类型

---

 5、类模板与继承

注意：

①当子类继承的父类是一个类模板时，子类在声明时，要指定出父类中T的类型

②如果不指定，编译器无法给子类分配内存，因为不知道父类中成员的大小

③如果想灵活指出父类中T的类型，子类也需要变成类模板

---

首先，创建父类base类模板

template<class T>
class base
{
public:T m_a;
};

---

①尝试创建子类

class son :public base
{;
};

直接报错：

需要指定父类中T的类型

 

 这样就可以

不过此时，父类中的T只能是指定的T类型，为了解决这个问题：

②将子类也类模板

template<class T1,class T2>
class son2 :public base<T2>
{T1 m_a;
};
void test02()
{son2<string,int> s2; // 显式指定类型
}

string就是T1，int就是T2

而T2就是继承父类base，并指定父类中T的类型为int

---

接着我们输出T1与T2的类型

 

---

6、类模板成员函数类外实现

掌握类模板中的成员函数类外实现

---

首先，我们写一个常规的person类模板，其中有属性m_name与m_age，类型分别为T1与T2

带有构造函数与void show函数

template<class T1,class T2>
class person
{
public:person(T1 name,T2 age){this->m_name = name;this->m_age = age;}void show(){cout << this->m_name << " " << this->m_age << endl;}T1 m_name;T2 m_age;
};

①类模板构造函数类外实现

接下来，我们先将类模板中的构造函数的实现部分屏蔽只留下声明，在类模板外实现构造函数

template<class T1,class T2>
person<T1, T2>::person(T1 name, T2 age)
{this->m_name = name;this->m_age = age;
}

即在构造函数person(T1 name, T2 age)前加上作用域person::以及参数列表<T1,T2>

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

template<class T1,class T2>
void person<T1,T2>::show() // 虽未用到T1T2，但由于其是类模板中成员函数，因此仍要写入T1/T2
{cout << this->m_name << " " << this->m_age << endl;
}

一样的加作用域与参数列表

---

测试：

void test01()
{person<string, int> p("joyce",21);p.show();
}

---

7、类模板分文件编写

首先，分文件编写类模板时（类模板.h头文件，其中的成员函数在.cpp源文件实现），成员函数创建时机是在调用阶段，导致编写时链接不到

---

先创建person.h头文件，其中写入person类模板

template<class T1, class T2>
class person
{
public:person(T1 name, T2 age);void show();T1 m_name;T2 m_age;
};

然后创建person.cpp源文件，其中实现person的函数，并包含.h头文件

// 构造函数
template<class T1, class T2>
person<T1, T2>::person(T1 name, T2 age)
{this->m_name = name;this->m_age = age;
}
// 成员函数
template<class T1, class T2>
void person<T1, T2>::show()
{cout << this->m_name << " " << this->m_age << endl;
}

到目前为止，代码运行没有任何问题

 但是，我们在测试函数中调用构造函数与成员函数

#include"person.h"void test01()
{person<string, int> p("joyce",21);p.show();
}

直接报错 ，因为编译器无法链接类模板成员函数的实现cpp文件

---

①直接包含.cpp文件

我们将源文件包含的person.h文件改为person.cpp文件，这样编译器直接链接到了cpp文件与h文件 

成功实现

---

②将声明与实现写在一个hpp文件中（约定俗成名为hpp，并非必须）

 上面是声明，下面是类外实现

 在源文件中包含

成功运行 

---

8、类模板与友元

2种实现：

①全局函数类内实现：直接在类内声明友元即可

②全局函数类外实现：先提前让编译器知道全局函数的存在

---

首先，写一个person类模板，其中有属性m_age与m_name，以及构造函数person

template<class T1, class T2>
class person
{
public:person(T1 name, T2 age){this->m_name = name;this->m_age = age;}private:T1 m_name;T2 m_age;
};

①全局函数类内实现

接下来，在其中加上友元的全局函数

	// 全局函数 类内实现friend void print1(person <T1, T2>p){cout << p.m_name << " " << p.m_age << endl;}

测试：

void test01()
{person<string,int> p("joyce", 21);print1(p);
}

②全局函数类外实现

首先在类内写上声明：

 然后在类外实现：

template<class T1,class T2>
void print2(person <T1, T2>p) // 因为有T1/T2，因此需要加上类模板
{cout << p.m_name << " " << p.m_age << endl;
}

测试：

void test02()
{person<string, int> p("joyce", 21);print2(p);
}

 依然是链接错误，因为类模板内我们写的是普通函数的声明，而下面实现写的是函数模板的实现，二者毫不相干

---

解决：①我们在声明的函数名后加上<>空参数列表

此时，还未完成，仍然无法使用，紧接着：

②先将类外实现部分移动到类模板的最上方

 ③然后在类外实现部分的上面加上类模板的声明

这样下来，才能正确运行

---

 9、类模板案例

 实现一个通用的数组类，要求：

①可以对内置数据类型以及自定义数据类型进行存储

②将数组中的数据存储到堆区

③构造函数中要传入数组的容量

④提供拷贝构造函数以及operator=，以防止浅拷贝问题

⑤提供尾插法与尾删法对数组中数据进行增加与删除

⑥通过下标的方式访问数组中的元素

⑦获取当前数组中元素的个数以及数组的容量

---

首先，创建my_array类模板，包含属性p_array存储开辟的数组，m_capacity数组容量，m_size数组当前大小

template<class T>
class my_array
{
public:// 防止浅拷贝问题的拷贝构造函数与operator=my_array(int capacity);// 有参构造函数my_array(const my_array &p);// 拷贝构造函数my_array& operator=(const my_array& p); // 复制运算符的重载,返回引用才是返回自身void push_back();// 尾插void pop_back();  // 尾删int get_capacity();// 获取容量int get_size();	   // 获取大小~my_array();// 析构函数private:T* p_array;    //	存储开辟的数组int m_capacity;//	数组的容量int m_size;	   //	数组当前大小
};

然后开始实现各个函数

①有参构造函数

	my_array(int capacity)// 有参构造函数{this->m_capacity = capacity;this->m_size = 0;this->p_array = new T[this->m_capacity]; // 开辟堆区空间以存储p_arraycout << "有参构造函数" << endl;}

②拷贝构造函数

	my_array(const my_array &p)// 拷贝构造函数{this->m_capacity = p.m_capacity; this->m_size = p.m_size;//this->p_array = p.p_array;// 带来浅拷贝问题this->p_array = new T(p.m_capacity);// 根据p的大小重新开辟空间以赋值// 将p中的数据也拷贝过来for (int i = 0; i < p.m_size; i++){this->p_array[i] = p.p_array[i];}cout << "拷贝构造函数" << endl;}

③operetor=等号重载

	my_array& operator=(const my_array& p) // 赋值运算符的重载,返回引用才是返回自身{if (this->p_array != NULL) // 判断是否有属性在堆区，有则释放{delete[] this->p_array;this->p_array = NULL;this->m_capacity = 0;this->m_size = 0;}// 深拷贝this->m_capacity = p.m_capacity;this->m_size = p.m_size;this->p_array = new T[p.m_capacity]; // 重新开辟空间for (int i = 0; i < p.m_size; i++) // 数据拷贝{this->p_array[i] = p.p_array[i];}cout << "operator=" << endl;return *this;}

④析构函数

	~my_array()// 析构函数{if (this->p_array != NULL){delete[] this->p_array;this->p_array = NULL;}cout << "析构函数" << endl;}

此时，我们先运行一下各个函数

#include"my_array.hpp"
int main()
{my_array<int> arr1(5); // 有参构造my_array<int> arr2(arr1);// 拷贝构造my_array<int> arr3(100); arr1 = arr3; // 自定义类型=赋值
return0;
}

---

⑤尾插 数据

首先，判断数组当前元素个数size是否等于容量capacity，如果相等则数组满了，直接return。

否则，直接将传入的数据赋给数组第size个元素，arr[size]，因为当前个数为size个，数组下标为0-size-1的元素都有了，下一个为空的就是第size个，因此赋给第size个

	void push_back(const T& val)// 尾插{// 先判断数组是否满if (this->m_size == this->m_capacity){return;/*		int new_capacity = m_capacity + 1;this->p_array = new T(new_capacity);*/}this->p_array[this->m_size ] = val; // 尾插数据this->m_size++;	// 当前大小+1}

⑥尾删 数据

使用户访问不到最后一个元素即可，即 使size-1，这样数组元素就少了一个

	void pop_back()  // 尾删{if (this->m_size == 0){cout << "数组为空！" << endl;return;}this->m_size--;}

⑦以下标方式访问数组元素

由于my_Array是我们自己创建的数组类型，其中的元素数据类型都是T，因此我们不能直接用[]访问到元素，需要我们重载[]运算符

---

我们使用[]下标访问元素是为了获取一个数据，所以我们重载就直接返回一个元素的数据就行

	T& operator[](int index){return this->p_array[index];}

返回值类型就是我们数组my_array中的数据类型T，同时保证返回前后是同一个元素我们用&

---

⑧获取大小与获取容量

直接返回size与capacity即可

	int get_capacity() // 获取容量{return this->m_capacity;}int get_size()	   // 获取大小{return this->m_size;}

---

代码完成，接下来

①我们创建数组，并打印输出

template<class T>
void print(T&arr) // 打印函数
{for (int i = 0; i < 5; i++){cout << arr[i] << " ";}
}
int main()
{my_array<int> arr1(5); // 有参构造for (int i = 0; i < 5; i++){arr1.push_back(i);}print(arr1);return 0;
}

成功输出范围内的数据

② 我们再看一下我们创建数组的容量和大小

	cout << "capacity" << arr1.get_capacity() << endl;cout << "size" << arr1.get_size() << endl;

 ③我们拷贝arr1构造arr2，并尾删数据，再打印输出

void test01()
{my_array<int> arr1(5); // 有参构造for (int i = 0; i < 5; i++){arr1.push_back(i);}print(arr1);cout << "capacity" << arr1.get_capacity() << endl;cout << "size" << arr1.get_size() << endl;my_array<int> arr2(arr1);// 拷贝构造print(arr2);arr2.pop_back();print(arr2);cout << "capacity" << arr2.get_capacity() << endl;cout << "size" << arr2.get_size() << endl;
}

 ④我们创建自定义数据类型，然后使用尾插尾删等的函数

先创建自定义数据类型person

class person
{
public:person() {};person( string name,int age ){this->m_age = age;this->m_name = name;}int m_age;string m_name;
};

创建打印函数print2（以我们自定义数据类型为准来创建）

void print2(my_array<person>& arr)
{for (int i = 0; i < arr.get_size(); i++){cout << arr[i].m_name <<arr[i].m_age<<endl;}cout << endl;
}

创建数组arr并初始化，先输出每个元素的信息与大小容量

然后尾删2个元素后，再次输出每个元素的信息与大小容量

void test02()
{// 创建数组并初始化my_array<person>arr(10);person a1("joyce", 21);person a2("tatina", 20);person a3("knaz", 40);person a4("nana", 20);person a5("yomi", 1);// 尾插到数组中arr.push_back(a1);arr.push_back(a2);arr.push_back(a3);arr.push_back(a4);arr.push_back(a5);// 打印数组中的每个元素的数据与大小容量print2(arr);cout << "capacity" << arr.get_capacity() << endl;cout << "size" << arr.get_size() << endl;// -----------------------------------------------------// 尾删2个元素arr.pop_back();arr.pop_back();// 打印数组中的每个元素的数据与大小容量print2(arr);cout << "capacity" << arr.get_capacity() << endl;cout << "size" << arr.get_size() << endl;
}

---

至此全部完成