【c++】类模版

1、类模板语法

类模板作用：

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

语法：

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后面加类，此类称为类模板

2、类模板与函数模板区别

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

（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;
}

总结：

类模板使用只能用显示指定类型方式
类模板中的模板参数列表可以有默认参数

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

类模板中成员函数和普通类中成员函数创建时机是有区别的：

普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建

#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();   //编译会出错，说明函数调用才会去创建成员函数
}

4、类模板对象做函数参数

一共有三种传入方式：

（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;
}

总结：

通过类模板创建的对象，可以有三种方式向函数中进行传参
使用比较广泛是第一种：指定传入的类型

5、类模板与继承

当类模板碰到继承时，需要注意一下几点：

当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中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的数据类型

未完待续......

1、类模板语法

2、类模板与函数模板区别

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

4、类模板对象做函数参数

5、类模板与继承

猜你喜欢