c++模板编程与泛型编程

模板编程

1.函数模板
template<typename T1,…>

//对char和int的数组经行排序   从大到小    利用选择排序

template <class T>//一定要紧跟着下方的函数或者类（紧跟着的一个）
void mySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

template <class T>
void mySort(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		int max = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[max] < arr[j])
			{
				//交换下表
				max = j;
			}
		}
		if (max != i)
		{
			mySwap(arr[max], arr[i]);
		}
	}
}
//输出数组元素的模板
template<class T>
void printArray(T arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
 }



void test01()
{
	//字符数组的排序
	char charArr[] = "helloworld";
	int num = sizeof(charArr) / sizeof(char);//求字符数组的长度的大小
	mySort(charArr, num);

	printArray(charArr, num);

	//整型数组的排序
	int intArr[] = { 1,2,3,5,9,4,7,6,2,5,7,6 };
	int num1 = sizeof(intArr) / sizeof(int);//求整型数组的长度大小
	mySort(intArr,num1);

	printArray(intArr, num1);

}

当编程中出现普通函数和与之相同的模板函数

//普通函数
void myPrint(int a,int b){}
//模板函数
template<class T1,class T2>
void myPrint(T1 a,T2 b){}

则实行如下的规则

void test02()
{
	int a = 10;
	int b = 20;
	//1.如果出现重载 优先使用普通函数(如果没有实现，会出现错误)
	myPrint(a, b);


	//2.如果想强制使用模板，那么可以使用空参数列表
	myPrint<>(a, b);

	//3.函数模板也可以重载
	int c = 20;
	myPrint(a,b,c);

	//4.如果函数模板可以产生更好的匹配，则优先调用函数模板
	char e = 'e';
	char d = 'd';
	myPrint(e, d);
}

2.类模板（在类中使用模板参数）
template<class T1,…>//在定义的时候也可以指定参数
1.自动类型推导，类模板，不支持，在使用的时候必须指定给定的类型
2.上述代码告诉编译器，下面的代码出现了T1不要报错，T是一个通用的类型
3.类模板中成员函数 一开始不会创建出来，而是在运行时才去创建

类模板做函数的参数

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


//类模板
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 << "姓名：" << this->m_Name << "  年龄：" << this->m_Age << endl;//反问参数要用->,不能用.
	}

	NameType m_Name;
	AgeType m_Age;

};


//1 指定传入类型
void doWork(Person<string, int> & p)
{
	p.showPerson();
}

void test01()
{
	Person<string, int> p("MT",10);
	doWork(p);
}

//2.参数模板化
template <class T1,class T2>
void doWork2(Person<T1, T2> & p)
{

	cout << typeid(T1).name() << endl;	//如何查看类型
	cout << typeid(T2).name() << endl;	//如何查看类型
	p.showPerson();
}

void test02()
{
	Person<string, int> p("WW",100);
	doWork2(p);
}

//3.整体类型化
template<class T>
void doWork3(T &p)
{
	cout << typeid(T).name() << endl;	//如何查看类型
	p.showPerson();
}

void test03()
{
	Person<string, int> p("野人", 66);
	doWork3(p);
}

int main()
{
	test01();

	test02();

	test03();
	system("pause");
	return EXIT_SUCCESS;
}

类模板碰到继承

在继承的时候一定要指定，类模板的类型
或者使用模板来让编译器推断，例如：class Child2 :public Base

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;


template<class T>
class Base
{
public:
	T m_A;
};

//child继承于base,必须要告诉base中的T的类型，否则T无法分配内存
class Child :public Base<int>
{

};


//child2也是模板类
template <class T1,class T2>
class Child2 :public Base<T2>
{
public:
	Child2()
	{
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
	T1 m_B;
};

void test02()
{
	Child2<int, double>child;//由用户指定的类型
}

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

类模板类外实现函数

类内实现和普通的函数一致
实现的上方要加上模板，同时类的作用域上也要加上模板

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

//类外实现成员函数
//要加上类的声明<T1,T2>
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>::showPerson()
{
	cout << "姓名：=" << this->m_Name << "  年龄：=" << this->m_Age << endl;
}


void test01()
{
	Person<string, int> p1("李东",15);
	p1.showPerson();
}

类模板与友元函数

1.友元函数的类内实现
与成员函数的写法基本一致，只是要在函数的前方加上friend，则默认为全局函数。类内声明，类内实现

template <class T1,class T2>
class Person
{
	//友元函数类内实现
	//下方默认为全局函数，在类内声明，类内实现。
	friend void printPerson(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;
	}


	T1 m_Name;
	T2 m_Age;
};

void test01()
{
	Person<string, int> p1("李东",45);
	printPerson(p1);

}

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

2.友元函数的类外实现

• 先写类的模板声明
• 再写友元函数的模板声明
• 再类内书写友元函数的声明
• 内外实现友元函数

//1.让编译器提前看到printPerson声明

//2.让编译器看到Person类声明
template<class T1, class T2> class Person;
template<class T1, class T2> void printPerson(Person<T1, T2> & p);

template <class T1, class T2>
class Person
{
	//3.友元函数类内实现  利用空参数列表 告诉编译器 模板函数的声明
	friend void printPerson<>(Person<T1, T2> & p); //普通函数 声明
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}


	T1 m_Name;
	T2 m_Age;
};

//4.类外实现
template<class T1,class T2>
void printPerson(Person<T1, T2> & p)
{
	cout << "姓名：" << p.m_Name << "  年龄： " << p.m_Age << endl;
}



void test01()
{
	Person<string, int> p1("李东", 45);
	printPerson(p1);

}