目录
1.模板
1.1模板概念
1.2.函数模板
1.2.1函数模板语法，函数模板的调用--1.自动类型推导，2.显示指定类型
1.2.2函数模板注意事项
编辑
1.2.3函数模板的案例，选择排序，字符数组，字符串
1.2.4普通函数与函数模板的区别
1.2.5普通函数和函数模板的调用规则，函数模板也可以发生重载
1.2.6模板的局限性，模板的重载,j具体化模板
1.3类模板
1.3.1类模板语法 ，类模板创建对象必须用显式指定类型
1.3.2类模板与函数模板的区别，类模板创建对象必须用显式指定类型
1.3.3类模板中成员函数创建时机--类模板中成员函数在调用时才去创建
1.3.4类模板对象做函数参数，用typeid可以查看模板推出的T的数据类型
1.3.5类模板与继承
1.3.6类模板成员函数类外实现
1.3.7类模板分文件编写
1.3.8类模板与友元，全局函数类内实现，类外实现
1.3.9类模板案例，如果函数调用想作为左值存在，我们要返回引用
1.模板
1.1模板概念
模板不可以直接使用比如一寸照，不能直接不p照片就用。不是万能的，不如不能把小狗的照片p到刚刚一寸照上。
1.2.函数模板
写了模板，下面紧跟了一个函数，这个函数就称为函数模板
1.2.1函数模板语法，函数模板的调用--1.自动类型推导，2.显示指定类型
#include<iostream>
using namespace std;
//交换两个整型的函数
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可以替换为class
//typename表明后面的符号是一种通用的数据类型，T名称可以替换，一般都用T表示
//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据类型
template<typename 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);//<int>指定T是int型
cout << "a = " << a << " b = " << b << endl;
double c = 1.1;
double d = 2.2;
swapDouble(c, d);
cout << "c = " << c << " d = " << d << endl;
}
int main()
{
test01();
system("pause");//按任意键继续
return 0;
}
1.2.2函数模板注意事项
#include<iostream>
using namespace std;
//函数模板注意事项
template<class 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;
char c = 'c';
mySwap(a, b);//正确
//mySwap(a, c);//报错,一个int 一个char 推导不出一致的T类型
cout << "a = " << a << " b = " << b << endl;
}
//2.模板必须要确定出T的数据类型才可以使用
template<class T>
void func()
{
//是一个函数模板
//写了一个模板，下面紧跟了一个函数，是函数模板
cout << "func 调用" << endl;
}
void test02()
{
//func();//报错,没有给出T的数据类型
func<int>();//显示指定类型调用，因为咱的函数体内也没用到T,但是又不能不给T的数据类型
//随便给一个T的类型就好
}
int main()
{
test01();
test02();
system("pause");//按任意键继续
return 0;
}
1.2.3函数模板的案例，选择排序，字符数组，字符串
#include<iostream>
using namespace std;
//实现通用的对数组进行排序的函数
//规则 从大到小
//算法 选择排序
//交换函数模板
template<class T>
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
template<class T>
void mySort(T a[],int len)
{
int max = 0;
for (int i = 0; i < len; i++)
{
max = i;//认定最大值的下标
for (int j = i + 1; j < len; j++)
{
//认定的最大值 比 遍历出的数组 要小 说明j下标的元素才是真正的最大值
if (a[max] < a[j])
{
max = j;//更新最大值下标
}
}
if (max != i)
{
//交换max和i下标的元素
mySwap(a[i], a[max]);
}
}
}
//提供打印数组的模板
template<class T>
void printArray(T* arr, int len)
{
for (int i = 0; i < len; i++)
{
cout << arr[i] << " ";
}
cout << endl;
}
void test01()
{
int a[5] = { 1,2,3,4 };
//int a[] = { 1,2,3,4,0 };
char b[5] = { 'a','b','c','d','e' };
//char b[] = { 'a','b','c','d','e' };
mySort(a, sizeof(a) / sizeof(a[0]));
printArray(a, sizeof(a) / sizeof(a[0]));
mySort(b, sizeof(b) / sizeof(b[0]));
printArray(b, sizeof(b) / sizeof(b[0]));
char ch[] = "badcfe";
mySort(ch, sizeof(ch) / sizeof(ch[0]));
cout << ch << endl;
char ch1[] = { 'b','a','d','c','f','e',0 };
mySort(ch, sizeof(ch1) / sizeof(char));
cout << ch1 << endl;
}
int main()
{
test01();
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';//ASCII c:99
cout << myAdd01(a, b) << endl;
cout << myAdd01(a, c) << endl;//把字符型c转换成了整型
//自动类型推导 不会发生隐式类型转换
cout << myAdd02(a, b) << endl;
//cout << myAdd02(a, c) << endl;//报错,a int c char 没办法推导出一致的T
//显示指定类型
cout << myAdd02<int>(a, c) << endl;//已经明确告诉T就是int，如果不是int的你就给我转成int
}
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;
myPrint(a, b);//普通函数和函数模板都可以调用，优先调用普通函数
//通过空模板的参数列表，强制调用函数模板
myPrint<>(a, b);//<>这个里面什么都不要写，模板的参数列表就是<>,
//如果是空模板的参数列表，那么<>里面就什么都不要写
//3.函数模板也可以发生函数重载
myPrint(a, b,100);
//4.如果函数模板可以产生更好的匹配，优先调用函数模板
char c1 = 'a';
char c2 = 'b';
myPrint(c1, c2);//普通函数和函数模板都可以调用，
//因为普通函数是可以发生强制类型转换(隐式类型转换)的，此时调用的时模板
//编译器认为调用普通函数需要把char转成int ,太麻烦了
//不如直接推导出T就是char
//也就是如果模板不发生隐式类型转换就优先调用模板
}
int main()
{
test01();
system("pause");//按任意键继续
return 0;
}
实际上代码里的普通函数没有必要写，因为你的T可以是int,实际开发中我们也没不会这样写
1.2.6模板的局限性，模板的重载,j具体化模板
运算符重载版本
#include<iostream>
using namespace std;
//模板局限性
//模板不是万能的，有些特定数据类型，需要用具体化方式做特殊实现
class Person
{
public:
Person(string name, int age)
{
m_Name = name;
m_Age = age;
}
bool operator==(Person& p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return true;
}
return false;
}
//姓名
string m_Name;
//年龄
int m_Age;
};
//对比两个数据是否相等
template<class T>
bool myCompare(T& a, T& b)
{
if (a == b)
{
return true;
}
else
{
return false;
}
}
void test01()
{
int a = 10;
int b = 20;
bool ret = myCompare(a, b);
if (ret == 1)
{
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 == 1)
{
cout << "p1==p2" << endl;
}
else
{
cout << "p1!=p2" << endl;
}
//第一种解决方法，运算符重载
}
int main()
{
test01();
test02();
system("pause");//按任意键继续
return 0;
}
具体化的模板
#include<iostream>
using namespace std;
//模板局限性
//模板不是万能的，有些特定数据类型，需要用具体化方式做特殊实现
class Person
{
public:
Person(string name, int age)
{
m_Name = name;
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版本实现代码，具体化优先调用
//以后遇到Person会走下面的代码而不是走上面的
//template<>告诉编译器是模板的重载版本
template<> bool myCompare(Person& a, Person& b)
{
if (a.m_Name == b.m_Name && a.m_Age == a.m_Age)
{
return true;
}
else
{
return false;
}
}
}
void test01()
{
int a = 10;
int b = 20;
bool ret = myCompare(a, b);
if (ret == 1)
{
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 == 1)
{
cout << "p1==p2" << endl;
}
else
{
cout << "p1!=p2" << endl;
}
//第一种解决方法，运算符重载
}
int main()
{
test01();
test02();
system("pause");//按任意键继续
return 0;
}
1.3类模板
1.3.1类模板语法 ，类模板创建对象必须用显式指定类型
#include<iostream>
using namespace std;
//类模板
template<class NameType,class AgeType>
//因为类中两个变量的类型不一样，所以不能像以前一样template<class T>
//只有一个T,如果类型一样可以用一个T
class Person
{
public:
Person(NameType name, AgeType age)
{
m_Name = name;
m_Age = age;
}
void showPerson()
{
cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
}
NameType m_Name;
AgeType m_Age;
};
void test01()
{
Person<string, int>p1("孙悟空", 18);
//<string, int>模板的参数列表,不写会报错
p1.showPerson();
}
int main()
{
test01();
system("pause");//按任意键继续
return 0;
}
1.3.2类模板与函数模板的区别，类模板创建对象必须用显式指定类型
函数模板与类模板在 C++98 一起被引入，因种种原因，类模板可以拥有默认模板参数，而函数模板不可以。从 C++11 开始，这个限制被解除了，即函数模板同样可以拥有默认模板参数。
(3条消息) C++11 函数模板的默认模板参数_恋喵大鲤鱼的博客-CSDN博客
#include<iostream>
using namespace std;
//类模板与函数模板的区别
template<class NameType=string,class AgeType=int>
//<>里面是模板参数列表
class Person
{
public:
Person(NameType name, AgeType age)
{
m_Name = name;
m_Age = age;
}
void showPerson()
{
cout << "姓名：" << m_Name << " 年龄：" << 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("猪八戒", 999);//虽然没指定年龄的类型，但是我们已经默认是int
//传了就是传入的类型，没传就是默认的类型
p.showPerson();
Person<>p1("沙和尚", 998);//即使都用默认也要写<>,不写<>又是自动类型推导了，不能用
p1.showPerson();
}
int main()
{
test01();
test02();
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();
}
//可以编译成功，这俩个成员函数只要不调用就不会创建，为什么不创建？
//因为没办法确定obj的类型
};
void test01()
{
MyClass<Person1>m;
m.func1();
}
int main()
{
test01();
system("pause");//按任意键继续
return 0;
}
1.3.4类模板对象做函数参数，用typeid可以查看模板推出的T的数据类型
#include<iostream>
using namespace std;
//类模板对象做函数参数
template<class T1,class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
m_Name = name;
m_Age = age;
}
void showPerson()
{
cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
}
T1 m_Name;
T2 m_Age;
};
//1.指定传入类型
//常用
void printPerson1(Person<string, int>&p1)//&不用拷贝出来一个副本，直接拿到p的本体
{
p1.showPerson();
}
void test01()
{
Person<string, int>p("孙悟空", 18);
printPerson1(p);
}
//2.参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2>&p)//将Person<string, int>中的参数模板化
{
p.showPerson();
cout << "T1 的类型为:" << typeid(T1).name() << endl;
cout << "T2 的类型为:" << typeid(T2).name() << endl;
}
void test02()
{
Person<string, int>p("猪八戒", 20);
printPerson2(p);
}
//3.整个类模板化
template<class T>
void printPerson3(T &p)//将整个Person类模板化
{
p.showPerson();
cout << "T 的类型为:" << typeid(T).name() << endl;
}
void test03()
{
Person<string, int>p("唐僧", 40);
printPerson3(p);
}
int main()
{
test01();
test02();
test03();
system("pause");//按任意键继续
return 0;
}
1.3.5类模板与继承
#include<iostream>
using namespace std;
//类模板与继承
template<class T>
class Base
{
T m;
};
//class Son:public Base//报错，必须要知道父类中T的类型，才能继承给子类
class Son :public Base<int>//告诉父类中T的数据类型
{
};
//如果想灵活指定父类中T的类型，子类也需要变成类模板
template<class T1,class T2>
class Son2 :public Base<T2>//T2指定出父类中的模板到底是什么数据类型
{
public:
Son2()
{
cout << "T1的类型为：" << typeid(T1).name() << endl;
cout << "T2的类型为：" << typeid(T2).name()<< endl;
//创建对象的时候会调用构造函数
}
T1 obj;
};
void test01()
{
Son2<int,char> s;//类模板创建对象必须用显式指定类型
}
int main()
{
test01();
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);
/*{
m_Name = name;
m_Age = age;
}*/
void showPerson();
/*{
cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
}*/
T1 m_Name;
T2 m_Age;
};
//构造函数的类外实现
template<class T1,class T2>
Person<T1,T2>::Person(T1 name, T2 age)//Person作用域下的构造函数,Person<T1,T2>类模板的类外实现
{
m_Name = name;
m_Age = age;
}
//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
}
void test01()
{
Person<string, int>p("Tom", 20);
p.showPerson();
}
int main()
{
test01();
system("pause");//按任意键继续
return 0;
}
1.3.7类模板分文件编写
下面图片左边第一张会报错，解决办法如右边图片所示
解决方式1
#include<iostream>
using namespace std;
//第一种解决方式 直接包含源文件
//一般没这样做的
#include"person.cpp"
//类模板分文件编写问题及解决
void test01()
{
Person<string, int>p("Jarry", 18);
p.showPersson();
}
int main()
{
test01();
system("pause");//按任意键继续
return 0;
}
//这是因为类模板中的成员函数一开始是不会创建的
//当写#include"person.h"时，编译器看到.h中类里面的
//成员函数是不会创建的，.cpp中的内容编译器看不到
//但是如果写.cpp，编译器会看到cpp中的内容
//#include"person.h"又让编译器看到了.h中的内容解决方式2
#pragma once
#include<iostream>
using namespace std;
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age);
void showPersson();
T1 m_Name;
T2 m_Age;
};
//声明实现都在一个文件中
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
m_Name = name;
m_Age = age;
}
template<class T1, class T2>
void Person<T1, T2>::showPersson()
{
cout << "姓名：" << m_Name << " 年龄：" << m_Age << endl;
}
#include<iostream>
using namespace std;
#include"person.hpp"
//第二种解决办法，将.h和.cpp中的内容写到一起，
// 将后缀名改为.hpp文件
//也就是不要把声明和实现分开去写
// 只要一写.hpp大家约定俗成的就知道这是一个类模板
// hpp不是必须的名称，只不过大家都这样写
//类模板分文件编写问题及解决
void test01()
{
Person<string, int>p("Jarry", 18);
p.showPersson();
}
int main()
{
test01();
system("pause");//按任意键继续
return 0;
}
1.3.8类模板与友元，全局函数类内实现，类外实现
上图是类外实现为什么会报错
#include<iostream>
using namespace std;
//通过全局函数打印Person信息
//提前让编译器知道Person类的存在
template<class T1, class T2>
class Person;//因为printPerson2(Person<T1, T2> p)出现了Person,所以还要声明一下Perosn
//告诉编译器有Person这个类，而且还是模板类
//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2> p)//参数模板化
{
//首先要不要告诉一下是Person作用域下的？
//没必要加作用域，因为这是一个全局函数，没必要多此一举
cout << "类外实现-----姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
template<class T1, class T2>
class Person
{
//全局函数 类内实现
friend void printPerson(Person<T1, T2> &p)//类模板做函数参数，参数模板化
{
cout << "类内实现----姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
//全局函数 类外实现
//类内需要声明
friend void printPerson2<>(Person<T1, T2> p);//参数模板化
//这是一个普通函数的声明
//而下面是一个函数模板的实现
//所以会报错
//修改方法就是加一个空模板参数列表
//如果全局函数是类外实现 需要让编译器提前知道这个函数的存在
//1.第一种方法就是把实现写在类前面
//2.
public:
Person(T1 name, T2 age)
{
m_Name = name;
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>p2("Jerry", 20);
printPerson2(p2);
}
int main()
{
test01();
test02();
system("pause");//按任意键继续
return 0;
}
#include<iostream>
using namespace std;
//通过全局函数打印Person信息
//提前让编译器知道Person类的存在
template<class T1,class T2>
class Person;//因为printPerson2(Person<T1, T2> p)出现了Person,所以还要声明一下Perosn
//告诉编译器有Person这个类，而且还是模板类
template<class T1, class T2>
void printPerson2(Person<T1, T2> p);
template<class T1, class T2>
class Person
{
//全局函数 类内实现
friend void printPerson(Person<T1,T2> p)//类模板做函数参数，参数模板化
{
cout << "类内实现----姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
//全局函数 类外实现
//类内需要声明
friend void printPerson2<>(Person<T1, T2> p);//参数模板化
//这是一个普通函数的声明
//而下面是一个函数模板的实现
//所以会报错
//修改方法就是加一个空模板参数列表
//如果全局函数是类外实现 需要让编译器提前知道这个函数的存在
//1.第一种方法就是把实现写在类前面
//2.第二种方法先声明
public:
Person(T1 name, T2 age)
{
m_Name = name;
m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2> p)//参数模板化
{
//首先要不要告诉一下是Person作用域下的？
//没必要加作用域，因为这是一个全局函数，没必要多此一举
cout << "类外实现-----姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
//1.全局函数在类内实现测试
void test01()
{
Person<string, int>p("Tom", 20);
printPerson(p);
}
//2.全局函数 类外实现测试
void test02()
{
Person<string, int>p2("Jerry", 20);
printPerson2(p2);
}
int main()
{
test01();
test02();
system("pause");//按任意键继续
return 0;
}
1.3.9类模板案例，如果函数调用想作为左值存在，我们要返回引用
#pragma once
//自己通用的数组类
//因为是模板类所以分文件编写时写成.hpp
#include<iostream>
using namespace std;
template<class T>
class MyArray
{
public:
//有参构造
MyArray(int capacity)
{
cout << "MyArray有参构造调用" << endl;
m_Capcity = capacity;
m_Size = 0;
pAddress = new T[capacity];
}
//拷贝构造
MyArray(const MyArray& arr)
{
cout << "MyArray拷贝构造调用" << endl;
m_Capcity = arr.m_Capcity;
m_Size = arr.m_Size;
//pAddress = arr.pAddress;//浅拷贝
//深拷贝
pAddress = new T[arr.m_Capcity];
//将arr中的数据都拷贝过来
for (int i = 0; i < arr.m_Size; i++)
{
pAddress[i] = arr.pAddress[i];
}
}
//operator= 防止浅拷贝问题
MyArray& operator=(const MyArray &arr)
{
cout << "MyArray operator=调用" << endl;
//先判断原来堆区是否有数据，如果有先释放
if (pAddress != NULL)
{
delete[] pAddress;
pAddress = NULL;
}
m_Capcity = arr.m_Capcity;
m_Size = arr.m_Size;
//深拷贝
pAddress = new T[arr.m_Capcity];
//将arr中的数据都拷贝过来
for (int i = 0; i < arr.m_Size; i++)
{
pAddress[i] = arr.pAddress[i];
}
return *this;
}
//析构函数
//堆区数据手动开辟 手动释放
~MyArray()
{
if (pAddress != NULL)
{
cout << "MyArray 析构函数调用" << endl;
delete[] pAddress;
pAddress = NULL;//防止野指针
}
}
private:
T* pAddress;//指针指向堆区开辟的真实数组
int m_Capcity;//数组容量
int m_Size;//数组大小
};
测试
#include<iostream>
using namespace std;
#include"MyArray.hpp"
void test01()
{
MyArray<int>arr1(5);
MyArray<int>arr2(arr1);//拷贝构造
MyArray<int>arr3(100);
arr3 = arr1;
}
int main()
{
test01();//局部变量，放在栈上，test01执行完之后会调用析构
system("pause");//按任意键继续
return 0;
}
#include<iostream>
using namespace std;
#include"MyArray.hpp"
void printIntArray(MyArray<int>& arr)
{
for (int i = 0; i < arr.getSize(); i++)
{
cout << arr[i]<<" ";//等价于arr.[](i)
}
cout << endl;
}
void test01()
{
MyArray<int>arr1(5);
//arr1[0];//报错，这是我们自己写的类哪有[]
for (int i = 0; i < 5; i++)
{
//利用尾插法向数组中插入数据
arr1.Push_Back(i);
}
cout << "arr1的打印输出：" << endl;
printIntArray(arr1);
cout << "arr1容量：" << arr1.getCapacity() << endl;
cout << "arr1大小：" << arr1.getSize() << endl;
MyArray<int>arr2(arr1);
cout << "arr2的打印输出：" << endl;
printIntArray(arr2);
//尾删
arr2.Pop_Back();
cout << "arr2尾删后：" << endl;
cout << "arr2容量：" << arr2.getCapacity() << endl;
cout << "arr2大小：" << arr2.getSize() << endl;
}
//测试自定义的数据类型
class Person
{
public:
Person()
{
}
Person(string name,int age)
{
m_Name = name;
m_Age = age;
}
string m_Name;
int m_Age;
};
void printPerson(MyArray<Person>& arr)
{
for (int i = 0; i < arr.getSize(); i++)
{
cout << "姓名：" << arr[i].m_Name << " 年龄：" << arr[i].m_Age
<< endl;
}
}
void test02()
{
MyArray<Person> arr2(10);
Person p1("孙悟空", 999);
Person p2("猪八戒", 888);
Person p3("沙和尚", 777);
Person p4("唐僧", 1000);
//将数据插入到数组中
arr2.Push_Back(p1);
arr2.Push_Back(p2);
arr2.Push_Back(p3);
arr2.Push_Back(p4);
//打印数组
printPerson(arr2);
//输出容量
cout << "arr2容量：" << arr2.getCapacity() << endl;
//输出大小
cout << "arr2大小：" << arr2.getSize() << endl;
}
int main()
{
test01();
test02();
system("pause");//按任意键继续
return 0;
}
