C++day 16 类模板（类模板分文件编写（未完成））

类模板作用：建立一个通用类，类中的成员，数据类型可以不具体指定，用一个虚拟的类型来代表

语法：

template<class T>

类

template<class nametype,class agetype>  //因为有两个不同类型的值
class person
{
public:
	person(nametype name, agetype age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	nametype m_name;
	agetype m_age;
};

void test1()
{
	person<string, int> p1("阿萨德", 14);  //指定模板类型
	cout << p1.m_age << p1.m_name << endl;
}

2.类模板与函数模板的区别

• 类模板没有自动类型推导
• 类模板在模板参数列表有默认参数

template<class nametype,class agetype = int>  //有默认参数，下面可以不指定
class person
{
public:
	person(nametype name, agetype age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	nametype m_name;
	agetype m_age;
};

void test1()
{
	//无自动推导
	person<string> p1("阿萨德", 14);  //指定模板类型，int为上面默认参数。只有类模板能用
	cout << p1.m_age << p1.m_name << endl;
}

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

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

class first
{
public:
	void showfirst()
	{
		cout << "first" << endl;
	}
};

class second
{
public:
	void showsecond()
	{
		cout << "second" << endl;
	}
};

template<class T>
class person
{
public:
	T obj;
	
	void fun1()   //因为不确定T的类型，所以在没确定前，这两个函数都不会创建。调用时再创建
	{
		obj.showsecond();
	}
	void fun2()
	{
		obj.showfirst();
	}

};

void test1()
{
	int a = 10;
	person<first> p;//类模板是person，obj现在设置为first类型
	p.fun2();  //所以first类型的obj可以调用first类中的showfirst函数。
	//p.fun1(); //这里对象的类型与second不匹配，所以不能调用
}

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

类模板实例化的对象，向函数传参的方式

三种

1. 指定传入的类型   -直接显示对象的数据类型（最常用）
2. 参数模板化   -将对象中的参数变为模板进行传递
3. 整个类模板化  -将这个对象类型模板化进行传递

template<class nametype,class agetype>
class person
{
public:
	person(nametype name, agetype age)
	{
		this->m_name = name;
		this->m_age = age;
	}

	void showperson()
	{
		cout << m_name << "   " << m_age << endl;
	}
	nametype m_name;
	agetype m_age;
};

//1.指定传入类型
void printperson1(person<string, int> &p) //直接指明类型，并且用引用直接修改本体
{
	p.showperson();
}

//2.参数模板化
template<class T1, class T2>
void printperson2(person<T1, T2> &p) //用模板替代,系统推导出对象的类型
{
	p.showperson();
	cout << typeid(T1).name() << endl; //可以查看系统推导的类型对不对
}

//3.整个类模板化
template<class T>   //直接将类模板化,系统自动推导出数据类型
void printperson3(T &p)
{
	p.showperson();
	cout << typeid(T).name() << endl;
}

void test1()
{
	person<string, int> p("阿萨德", 15);
	printperson3(p);  //将对象传输	
}

int main()
{
	test1();
	system("pause");
	return 0;
}

5.类模板与继承

注意

• 当子类继承的父类是一个类模板时，子类在声明的时候要指出父类中的类型
• 如果不指定，程序无法给子类 分配内存
• 如果想灵活指出父类中T的类型，子类也必须类模板

注意：如果子类在继承时也变成了类模板，则类模板子类实例化对象时指定的类型就变成了父类中参数的类型，并且未变成类模板的子类继承后调用父类参数时也是这个类型。

template<class nametype,class agetype>
class person
{
public:
	nametype m_name;
	agetype m_age;
};

class anima:public person<string,int> //必须指定父类中的参数类型，但这样指定数据类型不灵活
{
public:

};

//如果想灵活指定数据类型，子类也要变成类模板
template<class T1,class T2>
class bill :public person<T1, T2>
{
public:
	T1 obj;  //obj的数据类型由实例化对象 b指定的类型确定	
};

void test1()
{
	anima a;//致命父类模板的类型后子类就可以实例化一个对象了
	bill<string, int> b; //char = T1，int = T2，则父类中的参数，类型由子类对象指定.age已变成int类型
						//此时anima 实例化的对象调用父类参数时，类型也是这个
	b.m_age = 18; b.m_name = " 啊sfd  ";
	b.obj = "  水电费"; 
	a.m_age = 15;//此时anima 实例化的对象调用父类参数时，类型也是这个
	cout << b.m_name << b.m_age << b.obj << endl;
	cout << a.m_age << endl;
}

6.类模板成员函数的类外实现

template<class nametype,class agetype>
class person
{
public:
    person(nametype name, agetype age);
    /*{
        this->m_name = name;
        this->m_age = age;
    }*/

    void showperson();
    /*{
        cout << m_name << "   " << m_age << endl;
    }*/
    nametype m_name;
    agetype m_age;
};

//类模板成员函数类外实现
template<class nametype, class agetype>    //前加模板
void person<nametype, agetype>::showperson() //注意：类型写在person后
{
    cout << m_name << "   " << m_age << endl;
}

//构造函数类外实现
template<class nametype, class agetype>    //前加模板
person<nametype, agetype>::person(nametype name, agetype age) //作用域加模板类型
{
    this->m_name = name;
    this->m_age = age;
}

void test1()
{
    person<string, int> p("阿萨德",14);
    p.showperson();
}
7.类模板分文件编写（未完成）

8.类模板与友元（未完成）

9.案例