c++提高编程（1、模板）复习结束，学习新内容的开始

最新推荐文章于 2024-01-21 22:03:11 发布

feidong_unknow

最新推荐文章于 2024-01-21 22:03:11 发布

阅读量86

点赞数

文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/feidong_unknow/article/details/125387649

版权

本文详细介绍了C++中的模板概念，包括函数模板和类模板。探讨了模板的作用，如提高代码复用性和为STL学习奠定基础。讲解了函数模板的语法、注意事项、调用规则及局限性，并通过案例展示了如何使用模板进行排序。同时，对比了函数模板与普通函数的差异。接着，文章讨论了类模板的特点，如成员函数的创建时机、作为函数参数的使用以及与继承的关系。最后，总结了类模板中成员函数的类外实现、分文件编写和友元的处理方式。

摘要由CSDN通过智能技术生成

模板的好处是非常大，一方面是为了增加复用性，另一方面为了学习STL打下基础。

简单来说，我认为模板和class的继承和重载有一定想象，先说重载，因为c语言不能自动处理多数据类型。所以需要重载，手动告诉编译器如何操作。

模板也是相同，可以指定数据类型，让一个模板处理多种数据。

继承上，首先模板就是功能加强和规范化的函数和类，因此二者功能和特性都是有的，因此类的一些特性直接能在模板上体现，在处理数据上，二者也有一定相同，可以参考类学习的思路

学习模板并不是为了写模板，而是在STL能够运用系统提供的模板，这句话我感觉太重要了

模板的概念

模板就是建立通用的模具，大大提高复用性

例如生活中的模板：一寸照片模板！PPT模板等

主要目的是大幅度降低手敲函数，可以直接抄，为什么要自己写？

函数模板

C++另一种编程思想称为 ==泛型编程== ，主要利用的技术就是模板

C++提供两种模板机制:函数模板和类模板

函数模板语法

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>
函数声明或定义

template --- 声明创建模板

typename --- 表面其后面的符号是一种数据类型，可以用class代替

T --- 通用的数据类型，名称可以替换，通常为大写字母

传统的交换代码

#include <iostream>
#include<string>
using namespace std;
void swap_int(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}

//交换两个浮点型函数
void swap_double(double& a, double& b)
{
	double temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	int b = 20;

	swap_int(a, b);
	cout << "初始状态下1=10；b=20；" << a << endl;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

	double c = 1.11;
	double d = 2.2222;
	swap_double(c, d);

	cout << "初始状态下c=1.11；d=2.222；" << endl;
	cout << "交换后；" << endl;
	cout << "c=" << c << endl;
	cout << "d=" << d << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

这一个个写过于麻烦，要知道数据类型有八种之多，所以这个时候使用模板来写更合适

函数模板

template<typename T >
//声明一个模板，告诉编译器后面代码中紧跟着的t不要报错，T是一个通用的数据类型
void my_swap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

调用模板有两种方法，一种自动识别，一种是指定

void test02()
{
	int a = 10;
	int b = 20;

	my_swap(a, b);

	//利用模板实现交换
	// 两种方式
	//1、自动类型推导,编译器自动识别数据类型
	cout << "初始状态下1=10；b=20；" << endl;
	cout << "交换后；" << endl;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	//2、显示指定类型

	my_swap<int>(a, b);
	cout << "初始状态下1=10；b=20；" << endl;
	cout << "交换后（指定型）；" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;


}

函数模板利用关键字 template
使用函数模板有两种方式：自动类型推导、显示指定类型
模板的目的是为了提高复用性，将类型参数化

函数模板注意事项

注意事项：

自动类型推导，必须推导出一致的数据类型T,才可以使用

看，这上面是两个int类型的数据，但如果说一个是int，一个是char类型的呢？

就无法识别了

模板必须要确定出T的数据类型，才可以使用

这是为什么呢？因为没有指定T，为什么二者之间构建联系，我不知道，但是注释掉template后，就可以运行了

至于为什么报错，因为编译器无法推导出应该给你配什么样的数据类型

因此纠正后，指定一个数据类型

#include<iostream>
#include<string>
using namespace std;
//函数模板注意事项
template<typename  T>//typename可以替换成class
void my_swap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}
//1、自动动类型退到，必须推导出一只的数据类型T才可以使用
void test01()
{
	int a = 10;
	int b = 20;
	//上面两个是int
	char c = 'c';

	my_swap(a, b);//正确的写法
	//my_swap(a, c);
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

}

//2、必须指定类型才可以使用

template<class T>
void func()
{
	cout << "func的调用" << endl;
}

void test02()
{
	func<double>();
}

int main()
{
	test01();
	test02();

	system("pause");
	return 0;
}

使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

函数模板案例

案例描述：

利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
排序规则从大到小，排序算法为选择排序
分别利用char数组和int数组进行测试

首先先写上交换代码，在传入数据类型的时候使用T

需要注意的是，在模板中写错变量，是不报错的

这样就可以测试传入数据了

第一次统一传入char，数组，第二次统一传入int数组

可能我电脑原因，多次内存溢出

#include<iostream>
#include<string>

using namespace std;
//实现通用，对数组进行排序的函数
//规则，从大到小
//算法 萱蕚
//测试 选择
//测试 char数组、int数组

template<class T>
void my_swap(T&a,T&b)
{
	T temp = a;
	a = b;
	b = temp;
}

//排序算法
template<class T>
void my_sort(T arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		//认定i下标，就是第一个就是最大的
		int max = i;
		for (int j = i+1; j < len; j++)
		{//认定的最大值，比便利出的数值，要小，说明j下标才是最大的，直接而换
			if (arr[max] < arr[j])
			{
				max = j;//更新最大值下标
			}
		}
		//根据更新的下标交换元素
		if (max != i)
		{
			my_swap(arr[max], arr[i]);
		}
	}
}
//提供打印数组的模板
template<class T>
void print_arry(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << "   " ;
	}
	cout << endl;
}
void test01()
{
	//测试char数组
	char char_arr[] = "abcdsfjaf";
	int num = sizeof(char_arr) / sizeof(char);
	my_sort(char_arr, num);
	print_arry(char_arr, num);
}

void test02()
{
	//测试int数组
	int intArr[] = { 7, 5, 8, 1, 3, 9, 2, 4, 6 };
	int num = sizeof(intArr) / sizeof(int);
	my_sort(intArr, num);
	print_arry(intArr, num);
}

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

普通函数与函数模板的区别

普通函数与函数模板区别：

普通函数调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式，可以发生隐式类型转换

能调用，因为ASCII码，c的ASCII码是99，编译器自动给你转换了

报错，使用自动类型推导时，不会发生隐式类型转换

但如果指定输入类型，就可以了

//普通函数
int my_add01(int a,int b)
{
return a + b;
}


//函数模板
template<class T>
T my_add02(T a, T b)
{
return a + b;
}

void test01()
{
int a = 10;
int b = 20;
char c = 'c';//你猜猜能不能调用？
cout << my_add01(a, b) << endl;
cout << my_add01(a, c) << endl;

//但是模板就不行,他必须统一,因为它既可以是char型数据，也可以是int型，没有默认
//my_add02(a, c);

cout << my_add02<int>(a, c) << endl;

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

建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

普通函数与函数模板的调用规则

调用规则如下：

如果函数模板和普通函数都可以实现，优先调用普通函数
可以通过空模板参数列表来强制调用函数模板
函数模板也可以发生重载
如果函数模板可以产生更好的匹配,优先调用函数模板

如果空实现能运行嘛？不能，会报错

这样就可以强制调用了

调用函数重载的模板

有点厉害，我还以为要写个operator+

注意：如果函数模板产生更好的匹配，优先调用函数模板

模板的局限性

局限性：

模板的通用性并不是万能的
```
template<class T>
	void f(T a, T b)
	{ 
    	a = b;
    }
```
在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

template<class T>
	void f(T a, T b)
	{ 
    	if(a > b) { ... }
    }

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

普通模板调用

//对比两个数据是否相等函数
template <class	T>
bool my_compare(T& a, T& b)
{
	if (a == b)
	{
		return true;
	}
	else 
	{
		return false;
	}
		
}
void test01()
{
	int a = 10;
	int b = 20;

	bool ret = my_compare(a, b);
	if (ret)
	{
		cout << "a==b" << endl;
	}
	else
	{
		cout << "a!=b" << endl;
	}
}

自定义数据类型

class person
{
public:
	person(string name,int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;

};
//自定义数据类型的对比
void test02()
{
	person p1("tom", 10);
	person p2("tom", 10);

	bool ret = my_compare(p1, p2);
	//自定义数据类型，不会调用普通的函数模板
	
	if (ret)
	{
		cout << "p1==p2" << endl;
	}
	else
	{
		cout << "p1!=p2" << endl;
	}
	
}

运行后会报错，运行前不报错，这是因为编译器未运行，不知道你调用的数据类型能否进入

于是需要使用类似于重载的做法

创建具体化的Person数据类型的模板，用于特殊处理这个类型

template<> bool my_compare(person& p1, person& p2)
{
	if (p1.m_name == p2.m_name && p1.m_age == p2.m_age)
	{
		return true;
	}
	else
	{
		return false;
	}
}

这样就可以了

下面为源代码

#include<iostream>
#include<string>

using namespace std;
class person
{
public:
	person(string name,int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;

};

//对比两个数据是否相等函数
template <class	T>
bool my_compare(T& a, T& b)
{
	if (a == b)
	{
		return true;
	}
	else 
	{
		return false;
	}
		
}

void test01()
{
	int a = 10;
	int b = 20;

	bool ret = my_compare(a, b);
	if (ret)
	{
		cout << "a==b" << endl;
	}
	else
	{
		cout << "a!=b" << endl;
	}
}
//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
template<> bool my_compare(person& p1, person& p2)
{
	if (p1.m_name == p2.m_name && p1.m_age == p2.m_age)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//自定义数据类型的对比
void test02()
{
	person p1("tom", 10);
	person p2("tom", 10);

	bool ret = my_compare(p1, p2);
	//自定义数据类型，不会调用普通的函数模板
	
	if (ret)
	{
		cout << "p1==p2" << endl;
	}
	else
	{
		cout << "p1!=p2" << endl;
	}
	
}
int main()
{
	test02();

system("pause");
return 0;
}

利用具体化的模板，可以解决自定义类型的通用化
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板，这句话我感觉太重要了

类模板

就是建立一个通用的类，，，感觉像是父类啊

类模板语法

template<typename T>
类

自定义数据类型挺爽的

#include<iostream>
#include<string>

using namespace std;


template <class name_type,class age_type>
class person
{
public:
	//赋初值
	person(name_type name,age_type age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void show_person()
	{
		cout << "name; " << this->m_name << "age:" << this->m_age << endl;
	}
	name_type m_name;
	age_type m_age;
};

void test01()
{
	person <string, int>p1("赵四", 29);
	p1.show_person();
}

int main()
{
	test01();

system("pause");
return 0;
}

类模板与函数模板区别

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

类模板没有自动类型推导的使用方式
类模板在模板参数列表中可以有默认参数

这里重在理解

#include <string>
//类模板
template<class NameType, class AgeType = int> 
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

//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();

	system("pause");

	return 0;
}

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

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

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

普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建，这里是指在程序运行阶段的调用

怎么理解呢？就是一开始你可以去写任何一个类模板，只要语法正确，就不会报错，但是你要是运行，就会调用类模板，就给停止错误。原理在代码中有写。

//类模板中成员函数什么时候创建？
//类模板中成员函数应在调用时才去创建
class person1
{
public:
	void show_person1()
	{
		cout << "person01 show" << endl;
	}
};
class person2
{
public:
	void show_person2()
	{
		cout << "person02 show" << endl;
	}
};

template <class T>
class my_class
{
public:
	T obj;

	//类模板中成员函数
	void func1()
	{
		obj.show_person1();//非调用不创建，是否错误不会被发现
	}
	void func2()
	{
		obj.show_person2();
	}
};
void test01()
{
	my_class<person1>m;
	//如果不写别的，直接调用，会出错，因为person2可以替换成person1的数据类型，但是perosn1没有person2 的数据
	m.func1();
	//m.func2();//编译会出错，说明函数调用才会去创建成员函数
}
int main()
{
	test01();

system("pause");
return 0;
}

类模板中的成员函数并不是一开始就创建的，在调用时才去创建

类模板对象做函数参数

学习目标：

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

一共有三种传入方式：

指定传入的类型 --- 直接显示对象的数据类型
参数模板化 --- 将对象中的参数变为模板进行传递
整个类模板化 --- 将这个对象类型模板化进行传递

这个一定要练习，才能理解

先创建一个类模板

//类模板对象做函数参数
//创建一个类模板
template<class T1,class T2>
class person
{
public:
	person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}

	void show_person()
	{
		cout << "姓名： " << this->m_name << "年龄:" << this->m_age << endl;
	}

	T1 m_name;
	T2 m_age;
};

1、指定传入类型

这是直接指定类型传值，我感觉这种后来者也能看的很好啊

//1、指定传入类型
void print_person1(person<string, int>& p)
//类模板的对象做函数中的参数
{
	p.show_person();
}
void test01()
{
	person<string, int>p("赵四", 88);
	print_person1(p);
}

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

//2、参数模板化
template<class T1,class T2>
void print_person2(person<T1, T2>& p)

{
	p.show_person();
//这两行用看编译器推到出来数据类型
	//cout << "T1的类型是： " << typeid(T1).name() << endl;
	//cout << "T2的类型是： " << typeid(T2).name() << endl;
}
void test02()
{
	person<string, int>p("猪八戒", 90);
	print_person2(p);
}

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

template <class T>
void print_person03(T &p)
{
	p.show_person();
}
void test03()
{
	person<string, int>p("张三", 20);
	print_person03(p);
}

代码


//类模板对象做函数参数
//创建一个类模板
template<class T1,class T2>
class person
{
public:
	person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}

	void show_person()
	{
		cout << "姓名： " << this->m_name << "年龄:" << this->m_age << endl;
	}

	T1 m_name;
	T2 m_age;
};
//1、指定传入类型
void print_person1(person<string, int>& p)
//类模板的对象做函数中的参数
{
	p.show_person();
}
void test01()
{
	person<string, int>p("赵四", 88);
	print_person1(p);
}


//2、参数模板化
template<class T1,class T2>
void print_person2(person<T1, T2>& p)

{
	p.show_person();
	//这两行用看编译器推到出来数据类型
	cout << "T1的类型是： " << typeid(T1).name() << endl;
	cout << "T2的类型是： " << typeid(T2).name() << endl;
}
void test02()
{
	person<string, int>p("猪八戒", 90);
	print_person2(p);
}

//3、整个类模板化
template <class T>
void print_person03(T &p)
{
	p.show_person();
	cout << "T的数据类型是： " << typeid(T).name() << endl;
}
void test03()
{
	person<string, int>p("张三", 20);
	print_person03(p);
}


int main()
{
	test01();
	test02();
	test03();
system("pause");
return 0;
}

最常用的还是第一个，制定传参数类型，简单易懂

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

类模板与继承

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

当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需变为类模板

如果指定两个呢

template <class T>
class base
{
	T m;
};

class son :public base<int>
{

};

void test01()
{
	son s1;
}
//如果想灵活的指定父类中T的类型，子类也需要变成类模板
template<class T1,class T2>
class son2:public base<T2>
{
	T1 OBJ;
};
void test02()
{
	son2<int,char>s2;
}
int main()
{
	
system("pause");
return 0;
}

如果父类是类模板，子类需要指定出父类中T的数据类型

类模板成员函数类外实现

类内声明加实现

template<class T1,class T2>
class person
{
public:
	person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void show_person()
	{
		cout << "姓名： " << this->m_name << "  " << "年龄:  " << this->m_age << endl;
	}
	T1 m_name;
	T2 m_age;
};

类外实现

现在类内声明

using namespace std;
template<class T1,class T2>
class person
{
public:
	person(T1 name, T2 age);
	
	void show_person();

	T1 m_name;
	T2 m_age;
};

类外实现

//构造函数类外实现
template<class T1,class T2>
person <T1, T2>::person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}

成员函数的类外实现

//成员函数类外实现
template<class T1, class T2>
void person<T1, T2>::show_person()
{
		cout << "姓名： " << this->m_name << "  " << "年龄:  " << this->m_age << endl;
		
}

template<class T1,class T2>
class person
{
public:
	person(T1 name, T2 age);
		//{
		//	this->m_name = name;
		//	this->m_age = age;
		//}
		void show_person();
	//{
	//	cout << "姓名： " << this->m_name << "  " << "年龄:  " << this->m_age << endl;
	//}
	T1 m_name;
	T2 m_age;
};


//构造函数类外实现
template<class T1,class T2>
person <T1, T2>::person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}
//成员函数类外实现
template<class T1, class T2>
void person<T1, T2>::show_person()
{
		cout << "姓名： " << this->m_name << "  " << "年龄:  " << this->m_age << endl;
		
}

//测试
void test01()
{
	person<string, int>p("张三",19);
	p.show_person();
}

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

总结：类模板中成员函数类外实现时，需要加上模板参数列表

类模板分文件编写

学习目标：

掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：

类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

PS：这就有点头大了，记不住就完了呀

解决：

解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

原始代码

template <class T1,class T2>
class person
{
public:
	person(T1 name, T2 age);
	 
	void show_person();

	T1 m_name;
	T2 m_age;
};

template <class T1, class T2>
person<T1,T2>::person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}

template <class T1, class T2>
void person<T1, T2>::show_person()
{
	cout << "姓名 " << this->m_name << "   " << "年龄：" << this->m_age << endl;
}

void test01()
{
	person<string, int> p("jeke", 19);
	p.show_person();
}
int main()
{
	test01();
system("pause");
return 0;
}

在.h文件中

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


template <class T1, class T2>
class person
{
public:
	person(T1 name, T2 age);

	void show_person();

	T1 m_name;
	T2 m_age;
};

在.cpp文件中

template <class T1, class T2>
person<T1, T2>::person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}

template <class T1, class T2>
void person<T1, T2>::show_person()
{
	cout << "姓名 " << this->m_name << "   " << "年龄：" << this->m_age << endl;
}

源文件中

注意这里调用的是.cpp文件，像以前一样，调用.h文件就报错


#include<iostream>
#include<string>
using namespace std;
#include"person.cpp"//注意这里调用的是.cpp文件，像以前一样，调用.h文件就报错

void test01()
{
	person<string, int> p("jeke", 19);
	p.show_person();
}
int main()
{
	test01();
system("pause");
return 0;
}

但是这种比较少

因此用第二种，将声明和实现写到一起，文件后缀名改为.hpp

创建一个.h文件，后缀名改为.hpp，将声明和实现写到一起

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


template <class T1, class T2>
class person
{
public:
	person(T1 name, T2 age);

	void show_person();

	T1 m_name;
	T2 m_age;
};
template <class T1, class T2>
person<T1, T2>::person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}

template <class T1, class T2>
void person<T1, T2>::show_person()
{
	cout << "姓名 " << this->m_name << "   " << "年龄：" << this->m_age << endl;
}

在源文件调用

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

#include"person.hpp"

void test01()
{
	person<string, int> p("jeke", 19);
	p.show_person();
}
int main()
{
	test01();
system("pause");
return 0;
}

类模板与友元

全局函数类内实现 - 直接在类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

全局函数类内实现

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

template<class T1,class T2>
class person
{
	//全局函数 类内实现
	friend void print_person(person <T1, T2>p)
	{
		cout << "姓名： " << p.m_name << "   年龄： " << p.m_age << endl;
	}

public:
	person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}

private:
	T1 m_name;
	T2 m_age;
};

void test01()
{
	person <string, int>p("tom", 20);
	print_person(p);//我这边报错了，，教程上没有
}

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

类外实现

class类内的声明

第一，需要加上一个空模板的<>参数列表

	//全局函数 类外实现
	//要加一个空模板的参数列表
	//如果我们的全局函数，是类外实现，需要让编译器提前知道这个函数的存在

	friend void print_person02<>(person <T1, T2>p);

第二实现，

但是是现有个问题，他不用加上域，他只要加上模板参数就行


//全局函数 类外实现
//要把实现代码写到最上方，为了让编译器先看到他
template<class T1, class T2>
void print_person02(person <T1, T2>p)
{
	cout << "姓名： " << p.m_name << "   年龄： " << p.m_age << endl;
}

而且，为了让编译器先认识他，要写在上面。不这样干就报错

但是又出现个问题，print_person02是在类内里的，在逻辑上，编译器更要先认识class person

//但是又出现个问题，print_person02是在类内里的，在逻辑上，编译器更要先认识class person
template<class T1, class T2>
class person;

因此最终的效果就很，，诧异

//但是又出现个问题，print_person02是在类内里的，在逻辑上，编译器更要先认识class person
template<class T1, class T2>
class person;

//全局函数 类外实现
//要把实现代码写到最上方，为了让编译器先看到他
template<class T1, class T2>
void print_person02(person <T1, T2>p)
{
	cout << "姓名： " << p.m_name << "   年龄： " << p.m_age << endl;
}

template<class T1,class T2>
class person
{
	//全局函数 类内实现
	//friend void print_person(person <T1, T2>p)
	//{
	//	cout << "姓名： " << p.m_name << "   年龄： " << p.m_age << endl;
	//}
	
	//全局函数 类外实现
	//要加一个空模板的参数列表
	//如果我们的全局函数，是类外实现，需要让编译器提前知道这个函数的存在

	friend void print_person02<>(person <T1, T2>p);

public:
	person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}

private:
	T1 m_name;
	T2 m_age;
};

void test01()
{
	person <string, int>p("tom", 20);
	print_person02(p);//我这边报错了，，教程上没有
}

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