类模板作用：
建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。
语法：
template<typename T>
类解释：
template --- 声明创建模板
typename --- 表面其后面的符号是一种数据类型，可以用class代替
T --- 通用的数据类型，名称可以替换，通常为大写字母
#include <iostream>
#include <string>
using namespace std;
template <class nameType,class ageType>
class Person
{
public:
Person(nameType name,ageType age):m_Name(name),m_Age(age)
{}
nameType m_Name;
ageType m_Age;
void printInfo()
{
cout << "姓名是:" << this->m_Name << " 年龄是:" << this->m_Age << endl;
}
};
void test01()
{
//通过类模版来实例化对象
Person <string, int> person("张三", 33);
person.printInfo();
}
int main(void)
{
test01();
system("pause");
return 0;
}
总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板
类模板与函数模板区别主要有两点：
（1）类模板没有自动类型推导的使用方式
（2）类模板在模板参数列表中可以有默认参数
#include <iostream>
#include <string>
using namespace std;
//2. 类模板在模板参数列表中可以有默认参数
template <class nameType,class ageType = int>
class Person2
{
public:
Person2(nameType name,ageType age) :m_Name(name), m_Age(age)
{
}
void showInfo()
{
cout << "name:" << this->m_Name << " age:" << this->m_Age << endl;
}
nameType m_Name;
ageType m_Age;
};
//1. 类模板没有自动类型推导的使用方式
//2. 类模板在模板参数列表中可以有默认参数
void test02()
{
1. 类模板没有自动类型推导的使用方式
//Person2 p("李四",10); 错误：无法进行类型推导
Person2<string, int>person("张三", 11);
person.showInfo();
//2. 类模板在模板参数列表中可以有默认参数
Person2<string>person1("李四", 12);
person1.showInfo();
}
int main(void)
{
test02();
system("pause");
return 0;
}
总结：
类模板使用只能用显示指定类型方式
类模板中的模板参数列表可以有默认参数
类模板中成员函数和普通类中成员函数创建时机是有区别的：
普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建
#include <iostream>
#include <string>
using namespace std;
// 普通类中的成员函数一开始就可以创建
// 类模板中的成员函数在调用时才创建
class Person3
{
public:
void showPerson3()
{
cout << "Person3 show" << endl;
}
};
class Person33
{
public:
void showPerson33()
{
cout << "Person33 show" << endl;
}
};
template<class T>
class MyClass
{
public:
T obj;
//类模版中的成员函数
void func1()
{
obj.showPerson3();
}
void func2()
{
obj.showPerson33();
}
};
int main(void)
{
test03();
system("pause");
return 0;
}这是可以编译成功的。
再加上调用的函数，就会报错，说明类模板中的成员函数在调用时才创建
void test03()
{
MyClass<Person3>p1;
p1.func1();
//p1.func2(); //编译会出错，说明函数调用才会去创建成员函数
}一共有三种传入方式：
（1）指定传入的类型 --- 直接显示对象的数据类型
（2）参数模板化 --- 将对象中的参数变为模板进行传递
（3）整个类模板化 --- 将这个对象类型 模板化进行传递
（1）指定传入的类型 --- 直接显示对象的数据类型
#include <iostream>
#include <string>
using namespace std;
//类模版
template<class T1,class T2>
class Person4
{
public:
//构造函数
Person4(T1 name,T2 age):m_Name(name),m_Age(age)
{
}
//显示函数
void showPerson()
{
cout << "姓名：" << this->m_Name << endl;
cout << "年龄：" << this->m_Age << endl;
}
T1 m_Name;
T2 m_Age;
};
//1、指定传入的类型
void printPerson1(Person4<string,int>&p)
{
p.showPerson();
}
void test04()
{
Person4<string, int>p("孙悟空", 123);
printPerson1(p);
}
int main(void)
{
test04();
system("pause");
return 0;
}
（2）参数模板化 --- 将对象中的参数变为模板进行传递
#include <iostream>
#include <string>
using namespace std;
//类模版
template<class T1,class T2>
class Person4
{
public:
//构造函数
Person4(T1 name,T2 age):m_Name(name),m_Age(age)
{
}
//显示函数
void showPerson()
{
cout << "姓名：" << this->m_Name << endl;
cout << "年龄：" << this->m_Age << endl;
}
T1 m_Name;
T2 m_Age;
};
//2、参数模板化
template<class T1,class T2>
void printPerson004(Person4<T1, T2>&p)
{
p.showPerson();
cout << "T1的类型：" << typeid(T1).name() << endl;
cout << "T2的类型：" << typeid(T2).name() << endl;
}
void test004()
{
Person4<string, int>p("猪八戒", 123);
printPerson004(p);
}
int main(void)
{
test004();
system("pause");
return 0;
}
string名字有点长啊
class std::basic_string<char, struct std::char_traits<char>, class std::allocator<char> >
（3）整个类模板化 --- 将这个对象类型 模板化进行传递
#include <iostream>
#include <string>
using namespace std;
//类模版
template<class T1,class T2>
class Person4
{
public:
//构造函数
Person4(T1 name,T2 age):m_Name(name),m_Age(age)
{
}
//显示函数
void showPerson()
{
cout << "姓名：" << this->m_Name << endl;
cout << "年龄：" << this->m_Age << endl;
}
T1 m_Name;
T2 m_Age;
};
//3、整个类模板化
template<class T>
void printPerson0004(T& p)
{
p.showPerson();
cout << "T的类型为：" << typeid(T).name() << endl;
}
void test0004()
{
Person4<string, int>p("唐僧", 23);
printPerson0004(p);
}
int main(void)
{
test0004();
system("pause");
return 0;
}
总结：
通过类模板创建的对象，可以有三种方式向函数中进行传参
使用比较广泛是第一种：指定传入的类型
当类模板碰到继承时，需要注意一下几点：
当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需变为类模板
#include <iostream>
#include <string>
using namespace std;
//类模版与继承
template<class T>
class Base
{
public:
T m;
};
class Son :public Base
{
};
int main(void)
{
system("pause");
return 0;
}
#include <iostream>
#include <string>
using namespace std;
//类模版与继承
template<class T>
class Base
{
public:
T m;
};
//class Son :public Base 错误，必须要知道父类中T的类型
class Son:public Base<int>
{
};
void test05()
{
Son son;
}
int main(void)
{
system("pause");
return 0;
}如果想灵活指定父类中的T类型，子类也需要变模版
#include <iostream>
#include <string>
using namespace std;
//类模版与继承
template<class T>
class Base
{
public:
T m;
};
//如果想灵活指定父类中的T类型，子类也需要变模版
template<class T1,class T2>
class Son05 :public Base<T2>
{
public:
Son05()
{
cout << "T1的类型：" << typeid(T1).name() << endl;
cout << "T2的类型：" << typeid(T2).name() << endl;
}
T1 s;
};
void test005()
{
Son05<int, char>s2;
}
int main(void)
{
test005();
system("pause");
return 0;
}
总结：如果父类是类模板，子类需要指定出父类中T的数据类型
未完待续......