c++模板，选择排序，字符数组，字符串
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
目录
1.2.1函数模板语法函数模板的调用--1.自动类型推导2.显示指定类型
1.2.5普通函数和函数模板的调用规则函数模板也可以发生重载
1.3.2类模板与函数模板的区别类模板创建对象必须用显式指定类型
1.3.3类模板中成员函数创建时机--类模板中成员函数在调用时才去创建
1.3.4类模板对象做函数参数用typeid可以查看模板推出的T的数据类型
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;
}