c++类模板

类模板作用:

●建立一个通用类,类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。

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)
		{
			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;
};
 void test01()
 {
 	Person<string,int>p1("孙悟空",99);#include<iostream>
#include<string>
using namespace std;

//类模板
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("猪八戒",999);
 	p.showPerson(); 
 }
  int main()
  {
  	test01();
  	test02();
  }
 	p1.showPerson();
  } 
  int main()
  {
  	test01();
  }

模板与函数模板区别

类模板与函数模板区别主要有两点:

1.类模板没有自动类型推导的使用方式

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

#include<iostream>
#include<string>
using namespace std;

//类模板
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("猪八戒",999);
 	p.showPerson(); 
 }
  int main()
  {
  	test01();
  	test02();
  }

#include<iostream>
#include<string>
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<<"姓名："<<this->m_Name <<"年龄："<<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("孙悟空",100);
 	printPerson1(p);
  } 
  //2.参数模板化
  template<class T1,class T2>
  void printPerson2(Person<T1,T2>&p)
  {
  	p.showPerson() ;
  }
  void test02()
  {
  	Person<string,int>p("猪八戒",90);
  	printPerson2(p);
   } 
   //3.整个类模板化
   template<class T>
   void printPerson3(T &p)
   {
   	p.showPerson();
   }
   void test03()
   {
   	Person<string,int>p("唐僧",30);
   	printPerson3(p);
	} 
   int main()
   {
   	test01();
   	test02();
   	test03();
   }
  

类模板对象做函数参数

一共有三种传入方式:

1.指定传入的类型——直接显示对象的数据类型

2.参数模板化——将对象中的参数变为模板进行传递

3.整个类模板化—— 将这个对象类型模板化进行传递

#include<iostream>
#include<string>
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<<"姓名："<<this->m_Name <<"年龄："<<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("孙悟空",100);
 	printPerson1(p);
  } 
  //2.参数模板化
  template<class T1,class T2>
  void printPerson2(Person<T1,T2>&p)
  {
  	p.showPerson() ;
  }
  void test02()
  {
  	Person<string,int>p("猪八戒",90);
  	printPerson2(p);
   } 
   //3.整个类模板化
   template<class T>
   void printPerson3(T &p)
   {
   	p.showPerson();
   }
   void test03()
   {
   	Person<string,int>p("唐僧",30);
   	printPerson3(p);
	} 
   int main()
   {
   	test01();
   	test02();
   	test03();
   }