2021-11-15 C++模板的相关知识和代码分析

最新推荐文章于 2024-10-17 15:47:06 发布

爱抖腿的小松鼠

最新推荐文章于 2024-10-17 15:47:06 发布

阅读量640

点赞数

分类专栏： C++ 文章标签： c++ 开发语言后端

本文链接：https://blog.csdn.net/u011514176/article/details/121341276

版权

C++ 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1 模板

1.1模板的概念

模板就是建立通用的模具，大大提高复用性！
在这里插入图片描述

1.2函数模板

函数模板作用:
建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。
语法:
1 template
2函数声明或定义
解释:
template —声明创建模板
typename —表面其后面的符号是一种数据类型，可以用class代替T —通用的数据类型，名称可以替换，通常为大写字母

1.2.1 函数模板语法

#include<iostream>
using namespace std;
// c++另一种编程思想称为泛型编程，主要技术就是模板
// c++提供两种模板机制：：函数模板和类模板
//函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。

//两个整形交换函数
void swapint(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
//交换两个浮点型函数
void swapdouble(double& a, double& b)
{
	double temp = a;
	a = b;
	b = temp;
}

//函数模板
template <typename T>  //声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void myswap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	int b = 20;
	//swapint(a, b);
	//用函数模板交换
	//两种方式使用函数模板
	//1. 自动类型推导
	//myswap(a, b);
	
	//2. 显示指定类型
	myswap<int>(a, b);

	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

	//double c = 10.1;
	//double d = 20.2;
	//swapdouble(c, d);
	//cout << "c=" << c << endl;
	//cout << "d=" << d << endl;
}

int main() {
	test01();
	system("pause");
	return 0;
}

1.2.2 函数模板注意事项

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

#include<iostream>
using namespace std;
//函数模板注意事项
template <typename T>  //typename可以替换成class
void myswap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}
//1.自动类型推导，必须推导出一致的数据类型T才可以使用
void test01()
{
	int a = 10;
	int b = 20;
	string c = "c";

	myswap(a, b);  //正确
	//myswap(a, c);  //错误  ,推导不出一致的T类型

	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
}

//2.模板必须要确定出T的数据类型，才可以使用 
template <class T>  //typename可以替换成class
void func()
{
	cout <<"func调用" << endl; //没用到T
}
void test02()
{
	func();  //错误！必须确定T的类型
	func<int>();  //必须确定T的类型
}
int main() {
	test02();
	system("pause");
	return 0;
}

1.2.3 函数模板案例

案例描述:
利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序·
排序规则从大到小，排序算法为选择排序
分别利用char数组和int数组进行测试

#include<iostream>
using namespace std;
//案例描述
//利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
//排序规则从大到小，排序算法为选择排序
//分别利用char数组和int数组进行测试

//实现一个通用的 对数组进行排序的函数

//交换函数模板
template <class T>
void myswap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}
//排序算法
template <class T>
void mysort(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		int max = i; //设定最大值的下标
		for (int j = 1 + i; j < len; j++)
		{
			//认定的最大值 比  遍历出的数值 要小， 说明  j下标的元素才是最大值
			if (arr[max] < arr[j])
			{
				max = j;  //更新最大值下标
			}
		}
		if (max != i)
		{
			//交换max和i元素
			myswap(arr[max], arr[i]);
		}
	}
}

//提供打印数组的模板
template <class T>
void printarray(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] <<"  ";
	}
	cout << endl;
}

void test01()
{
	//测试char数组
	char chararr[] = "badcfe";
	int num = sizeof(chararr) / sizeof(char);
	mysort(chararr, num);
	printarray(chararr, num);
}

void test02()
{
	//测试int数组
	int chararr[] = {22,33,1,2,5,7,3,1,55,22,11,555,22222,33};
	int num = sizeof(chararr) / sizeof(int);
	mysort(chararr, num);
	printarray(chararr, num);
}

int main() {
	test02();
	system("pause");
	return 0;
}

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

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

#include<iostream>
using namespace std;
//普通函数和函数模板的区别

//1. 普通函数调用可以发生隐式类型转换
//2. 函数模板 用自动类型推导  不可以发生隐式类型转换
//3. 函数模板 用显示指定类型  可以发生隐式类型转换

//普通函数
int myadd01(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 << myadd01(a,c) <<endl;

	//1. 自动类型推导
	cout<<myadd02(a, c) << endl;  // c 的类型就..函数模板 用自动类型推导  不可以发生隐式类型转换  ，错误，他不知道到底转换成int还是char
	//2.显示指定类型
	cout << myadd02<int>(a,c) <<endl;  //这样子可以了，直接强制指明给我转换！！！！！！！！！！！！！！
}

int main() {
	test01();
	system("pause");
	return 0;
}

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

#include<iostream>
using namespace std;

//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 = 20;

	//1. 如果函数模板和普通函数都可以调用，优先调用普通函数
	//myprint(a, b); //调哪个呢？？两个函数，名字都一样！

	//2. 可以通过空模板参数列表  强制调用 函数模板
	myprint<>(a, b);

	//3. 函数模板可以发生函数重载
	myprint(a, b, 100);

	//4. 如果函数模板可以产生更好的匹配，优先调用函数模板
	char c1 = 'a';
	char c2 = 'b';     //字符类型一致，函数模板也可以调用
	myprint(c1, c2);  //普通函数需要隐式类型转换两步走，而函数模板只需要转换成T
}
int main() {
	test01();
	//总结：既然提供了函数模板，就不要用普通函数了，以免出现二义性。
	system("pause");
	return 0;
}

1.2.6 模板的局限性

在这里插入图片描述
因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

#include<iostream>
using namespace std;

//模板不是万能的，有些特定数据类型，需要用具体化方式做特殊实现
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)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//重载模板
//利用具体化person的版本实现代码，具体化优先调用
template<> bool mycompare(person& p1, person& p2)
{
	if (p1.m_name == p2.m_name && p1.m_age == p2.m_age)
	{
		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", 10);
	person p2("tom", 10);

	bool ret = mycompare(p1, p2);
	if (ret)
	{
		cout << "a==b" << endl;
	}
	else
	{
		cout << "a!=b" << endl;
	}
}

int main() {
	test02();
	system("pause");
	return 0;
}

1.3 类模板

类模板作用:
·建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。
语法:
template
解释:
template —声明创建模板
typename —表面其后面的符号是一种数据类型，可以用class代替T —通用的数据类型，名称可以替换，通常为大写字母

1.3.1 类模板语法

#include<iostream>
using namespace std;
//
template <class Nametype, class Agetype>
class person
{
public:
	person(Nametype name, Agetype age)
	{
		this->m_name = name;
		this->m_age = age;
	}

	void showperson()
	{
		cout << "name: " << this->m_name << "\nage: " << this->m_age;
		cout<< endl;
	}
	Nametype m_name;
	Agetype m_age;
};

void test01()
{
	person<string, int> p1("穆久涛", 999);
	p1.showperson();
}

int main() {
	test01();
	system("pause");
	return 0;
}

1.3.2 类模板与函数模板区别

类模板与函数模板区别主要有两点:
1.类模板没有自动类型推导的使用方式
2.类模板在模板参数列表中可以有默认参数

#include<iostream>
using namespace std;
//this是实例对象的指针
//类模板没有自动类型推导的使用方式
//类模板在模板参数列表中可以有默认参数

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: " << this->m_name << "age= " << this->m_age << endl;
	}
	
	nametype m_name;
	agetype m_age;
};
//1 类模板没有自动类型推导的使用方式
void test01()
{
	//person p("孙悟空", 1000);  错误的，无法自动类型推导
	person<string, int>p("孙悟空", 1000);

	p.showperson();
}
//2 类模板在模板参数列表中可以有默认参数
void test02()
{
	person<string>p("猪八戒", 99);
	p.showperson();
}
int main() {
	test01();
	system("pause");
	return 0;
}

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

类模板中成员函数和普通类中成员函数创建时机是有区别的:
普通类中的成员函数—开始就可以创建
类模板中的成员函数在调用时才创建

#include<iostream>
using namespace std;
//类模板中成员函数的创建时机
//类模板中成员函数在调用时才去创建

class person1
{
public:
	void showperson1()
	{
		cout << "person1 show" << endl;
	}
};

class person2
{
public:
	void showperson2()
	{
		cout << "person2 show" << endl;
	}
};

template <class T>
class myclass
{
public:
	T obj;
	//类模板中的成员函数
	void func1()
	{
		obj.showperson1();
	}
	//类模板中的成员函数
	void func2()
	{
		obj.showperson2();
	}
};

void test01()
{
	myclass<person1> m;
	m.func1();
	//m.func2()   编译时候会出错。说明函数调用时才会去创建成员函数
}
int main() {
	test01();
	system("pause");
	return 0;
}

1.3.4 类模板对象做函数参数

学习目标:
类模板实例化出的对象，向函数传参的方式
—共有三种传入方式:
1.指定传入的类型—直接显示对象的数据类型
⒉参数模板化—将对象中的参数变为模板进行传递
3.整个类模板化—将这个对象类型模板化进行传递

#include<iostream>
using namespace std;

//类模板对象作函数参数
template <class T1, class T2>
class person
{
public:
	person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void showperson()
	{
		cout << "name: " << this->m_name << "   age= " << this->m_age << endl;
	}

	T1 m_name;
	T2 m_age;
};
//1 指定传入类型  直接显示对象的数据类型
void printperson1(person<string,int>&p)  //将模板的参数列表也传进去
{
	p.showperson();
}
void test01()
{
	person<string, int>p("孙悟空", 1000);
	printperson1(p);
}

//2 参数模板化   将对象中的参数变为模板进行传递
template<class T1,class T2>
void printperson2(person<T1, T2>&p)
{
	p.showperson();
	cout << "T1类型为" << typeid(T1).name() << endl;
	cout << "T2类型为" << typeid(T2).name() << endl;
}
void test02()
{
	person<string, int>p("猪八戒", 3000);
	printperson2(p);
}

//3 整个类模板化   将这个对象类型 模板化进行传递
template <class T>
void printperson3(T &p)
{
	p.showperson();
	cout << "T类型为" << typeid(T).name() << endl;
}
void test03()
{
	person<string, int>p("唐僧", 30);
	printperson3(p);
}

int main() {
	test03();
	system("pause");
	return 0;
}

1.3.5 类模板与继承

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

#include<iostream>
using namespace std;
//类模板碰到继承时，需要注意一下几点：
//当子类继承的父类是一个类模板时，子类在声明的时候，要指出父类中T的类型
//如果不指定，编译器无法给子类分配内存
//如果想要灵活指出父类中T的类型，子类也需要变为类模板

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

//class son :public base  //错误的，必须要知道父类中的T的数据类型，才能继承给子类
class son :public base<int>
{

};

void test01()
{
	son s1;
}

//如果想要灵活指定父类中的T的类型，子类也需要变成类模板   儿子决定爸爸的类型
template <class T1, class T2>
class son2 :public base<T2>
{ 
public:
	son2()
	{
		cout << "T1类型为" << typeid(T1).name() << endl;
		cout << "T2类型为" << typeid(T2).name() << endl;
	}
	T1 obj;
};

void test02()
{
	son2<int, char>s2;
}
int main() {
	test02();
	system("pause");
	return 0;
}

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

#include<iostream>
using namespace std;
//

template<class T1, class T2>
class person
{
public:
	person(T1 name, T2 age);   //类内声明
	//{
	//	this->m_name = name;
	//	this->m_age = age;
	//}
	void showperson();
	//{
	//	cout << "name: " << this->m_name << "age= " << 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;
}

//成员函数的类外实现
template<class T1, class T2>
void person<T1, T2>::showperson()
{
	cout << "name: " << this->m_name << "age= " << this->m_age << endl;
}

void test01()
{
	person<string, int>p("tom", 20);
	p.showperson();
}
int main() {
	test01();
	system("pause");
	return 0;
}

1.3.7 类模板分文件编写

在这里说两句。
一般我们分文件编写，都是.h文件中声明类，.cpp文件写具体函数，但是这个方法在类模板中不可行，因为类模板调用时机是在程序运行过程中的，所以我们可以直接把.h和.cpp的两个文件合到一块，后缀改成.hpp文件就可以了。。。。

#include<iostream>
using namespace std;

//第一种解决方式，直接包含 源文件
#include "180 person.cpp"  //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

第二种解决方式，将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件

//类模板分文件编写问题以及解决
//template<class T1, class T2>
//class person
//{
//public:
//	person(T1 name, T2 age);   //类内声明
//	void showperson();
//
//	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;
//}
//
成员函数的类外实现
//template<class T1, class T2>
//void person<T1, T2>::showperson()
//{
//	cout << "name: " << this->m_name << "age= " << this->m_age << endl;
//}

void test01()
{
	Person<string, int>p("tom", 20);
	p.showperson();
}
int main() {
	test01();

	system("pause");
	return 0;
}

1.3.8 类模板与友元

**学习目标:**掌握类模板配合友元函数的类内和类外实现
全局函数类内实现-直接在类内声明友元即可
全局函数类外实现–需要提前让编译器知道全局函数的存在

#include<iostream>
using namespace std;

//通过全局函数，打印person信息
//全局函数类内实现，直接在类内声明友元即可
//全局函数类外实现，需要提前让编译器知道全局函数的存在

//提前让编译器知道person类的存在
template<class T1, class T2>
class person;

//类外实现
template<class T1, class T2>
void printperson2(person<T1, T2> p)
{
	cout << "类外实现——name: " << this->m_name << "age= " << this->m_age << endl;
}

template<class T1, class T2>
class person
{
public:
	//全局函数类内实现
	friend void printperson(person<T1, T2>p)  //告诉编译器，后面这个全局函数是我的友元，然后编译器去找这个函数的实现，这里比较特殊，我直接类内给实现
	{
		cout << "name: " << this->m_name << "age= " << this->m_age << endl;
	}
	//全局函数类外实现
	//加一个空模板的参数列表，让普通函数变成模板函数
	//如果全局函数是类外实现，需要让编译器提前知道这个函数的存在  1.直接把类外实现的函数放到最上面
	friend void printperson2<>(person<T1, T2> p);         

	person(T1 name, T2 age)   //类内声明
	{
		this->m_name = name;
		this->m_age = age;
	}
private:
	T1 m_name;
	T2 m_age;
};


//1. 全局函数类内实现
void test01()
{
	person<string, int>p("tom", 20);
	printperson(p);
}

//2. 全局函数类外实现
void test02()
{
	person<string, int>p("jerry", 20);
	printperson2(p);
}

int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

1.3.9 类模板案例

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

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

.hpp文件中的内容

//自己通用的数组类
#pragma once
#include <iostream>
using namespace  std;
#include <vector>

template<class T>
class myarray
{
public:
	//有参构造 参数 容量
	myarray(int capacity)
	{
		cout << "myarray 的 有参调用" << endl;
		this->m_capacity = capacity;
		this->m_size = 0;
		this->paddress = new T [this->m_capacity];
	}

	//析构函数，堆区开辟了这个数据，手动开辟手动释放
	~myarray()
	{
		cout << "myarray 的 析构函数调用" << endl;
		if (this->paddress != NULL)
		{
			delete[] this->paddress;
			this->paddress;
		}
	}

	//拷贝构造函数，需要自己写，因为为了防止浅拷贝
	myarray(const myarray & arr)
	{
		cout << "myarray 的 拷贝构造调用" << 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)
	{
		cout << "myarray 的 operator调用" << endl;
		//先判断原来堆区是否有数据，如果有先释放
		if (this->paddress != NULL)
		{
			delete[] this->paddress;
			this->paddress = NULL;
			this->m_capacity = 0;
			this->m_size = 0;
			cout << "赋值堆区释放" << endl;
		}

		//深拷贝
		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--;
	}

	//通过下标方式访问数组中的元素  arr[0]  =  100
	T& operator[](int index)
	{
		return this->paddress[index];
	}

	//返回数组容量
	int getcapacity()
	{
		return this->m_capacity;
	}
	//返回数组大小
	int getsize()
	{
		return this->m_size;
	}

private:
	T * paddress;  //指针指向堆区开辟的真实数组

	int m_capacity;//数组容量
	int m_size; //数组大小
};

.cpp文件中的内容

#include<iostream>
using namespace std;
#include "182-184 类模板封装案例.hpp"
//实现一个通用的数组类，要求如下：
//可以对内置数据类型和自定义数据类型的数据进行存储
//将数组中的数据存储到堆区
//构造函数中可以传入数组的容量
//提供对应的拷贝构造函数以及operator=防止浅拷贝问题
//提供尾插法和尾删法对数组的数据进行增加和删除
//可以通过下标的方式访问数组中的元素
//可以获取数组中当前元素的个数和数组的容量

//打印函数
void printinarray(myarray <int>& arr)
{
	for (int i = 0; i < arr.getcapacity(); i++)
	{
		cout << arr[i] <<endl;
	}
}
void test01()
{
	//有参构造的测试
	myarray <int>arr1(5);  //有参构造函数构造数组，实例化对象arr1
	for (int i = 0; i < 5; i++)
	{
		//利用尾插法向数组中插入数据
		arr1.push_back(i);
	}
	cout << "arr1的打印输出为" << endl;

	printinarray(arr1);

	cout << "arr1的容量为" <<arr1.getcapacity() <<endl;
	cout << "arr1的大小为" <<arr1.getsize() <<endl;1

	//myarray <int> arr2(arr1);   //拷贝构造的测试
	myarray <int>arr2(5);
	arr2 = arr1;
	cout << "arr2的打印输出为" << endl;
	printinarray(arr2);

	//尾删
    arr2.pop_back();
	cout << "arr2尾删后" << endl;
	cout << "arr2的容量为" << arr2.getcapacity() << endl;
	cout << "arr2的大小为" << arr2.getsize() << endl;

	//myarray<int>arr3(100);
	//arr3 = arr1;
}


//测试自定义数据类型
class person
{
public:
	person() {};
	person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}

	string m_name;
	int m_age;
};

void printpersonarray(myarray<person>& arr)
{
	for (int i = 0; i < arr.getsize(); i++)
	{
		cout << "name: " << arr[i].m_name << "age= " << arr[i].m_age << endl;
	}
}
void test02()
{
	myarray<person> arr(4);

	person p1("孙悟空", 999);
	person p2("韩信", 222);
	person p3("打击", 22);
	person p4("安其拉", 111222);

	//将数据插入到数组中
	arr.push_back(p1);
	arr.push_back(p2);
	arr.push_back(p3);
	arr.push_back(p4);

	//打印数组操作
	printpersonarray(arr);

	//输出容量
	cout << "arr的容量为" << arr.getcapacity() << endl;
	//输出大小
	cout << "arr的大小为" << arr.getcapacity() << endl;
}
int main() {

	test01();

	//test02();

	system("pause");
	return 0;
}