C++中模板与泛型编程

函数模板

语法：

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

template ，声明创建模板
typename， 表面其后面的符号是—种数据类型，可以用class代替
T ，通用的数据类型，名称可以替换，通常为大写字母

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

函数模板注意事项：

• 自动类型推导，必须推导出一致的数据类型T,才可以使用
• 模板必须要确定出T的数据类型，才可以使用

例如下述代码： 则无法推导出类型

template<typename T>
T myswap(T& a, T& b) 
{
	T temp = a;
	a = b;
	b = temp;
	return a;
}
int main()
{
	int a = 5;
	char b = 'b';
	myswap(a, b);
}

普通函数与函数模板区别

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

template<typename T>
T add(T a, T b)
{
	return a + b;
}
int main()
{
	int a = 0;
	char c = 'c';
	cout << add(a, c);//报错，无法推导出正确类型
	cout << add<int>(a, c) << endl;
}

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

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

#include<iostream>
using namespace std;

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

void myPrint(int a, int b)
{
	cout << "调用的普通函数" << endl;
}
//函数模板
template<typename T>
void myPrint(T a,T b)
{
	cout << "调用的函数模板" << endl;
}

//函数模板
template<typename T>
void myPrint(T a, T b,T c)
{
	cout << "调用的重载的函数模板" << endl;
}


void test01()
{
	int a = 10;
	int b = 20;
	//1.如果函数模板和普通函数都可以实现，优先调用普通函数
	myPrint(a, b);//调用的普通的

	//2.可以通过空模板参数列表来强制调用函数模板
	myPrint<>(a, b);//调用的函数模板

	//3、函数模板也可以发生重载
	myPrint(a, b, 100);

	//4.如果函数模板可以产生更好的匹配, 优先调用函数模板
	char c1 = 'a';
	char c2 = 'b';
	myPrint(c1, c2);
}
int main()
{
	test01();
	return 0;
}

类模板

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

template<typename T>
类

template<class  T>
class person
{
public:
	T name;
	int age;
	person(T _name, int _age)
	{
		this->name = _name;
		this->age = _age;
	}
};
int main()
{
	person<string> test("tom", 10);
}

与函数模板的区别：

• 类模板没有自动类型推导的使用方式，必须显式给出
• 类模板在模板参数列表中可以有默认参数

//T2默认类型为int
template<class  T1,class T2=int>
class person
{
public:
	T1 name;
	T2 age;
	person(T1 _name,T2 _age)
	{
		this->name = _name;
		this->age = _age;
	}
};
int main()
{
	person<string> test("tom", 10);
	person<string, string> test("tom", "10");
}

使用using起别名

由于模板不是一个类型，不能通过typedef取别名。但是新标准允许我们为类模板定义一个类型别名。

template<typename T> using twin = pair<T, T>;
twin<string> authors;
twin<double> areas;
template<typename T>
ostream& operator<<(ostream& cout, twin<T> & num)
{
	cout << num.first << " " << num.second << endl;
	return cout;//返回输出流对象
}
int main()
{
	areas.first = 10;
	areas.second = 20;
	authors.first = "tom";
	authors.second = "TOM";
	cout << areas<<authors;
}

类模板的static成员

类模板中，对于给定类型的对象，共享相同的静态成员。比如在test模板中，test< int > 共享静态变量num，test< string > 共享一个。

template<class T>
class test {
public:
	static int num;
};
template<typename T>
int test<T>::num = 10;
int main()
{
	test<int> s1,s2;
	cout << s1.num << " " << s2.num << endl;
	test<int>::num = 15;
	cout << s1.num << " " << s2.num << endl;
	test<string> s3, s4;
	test<string>::num = 20;
	cout <<"int " <<s1.num << " " << s2.num << endl;
	cout <<"string " <<s3.num << " " << s4.num << endl;
}

模板类中每个static数据成员有且只有一个定义，但类模板的每个实例都有一个独特的static对象。所以我们要将static数据成员也定义为模板。

类模板中成员函数的创建时间

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

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

class test1
{
	void showtest1() { cout << "test1" << endl; }
};
class test2
{
	void showtest2() { cout << "test2" << endl; }
};
template<class T>
class t
{
public:
	T obj;
	void fun1() { obj.showtest1(); }
	void fun2() { obj.showtest2(); }
};
int main()
{
	t<test1> test;
	test.fun1();
	//test.fun2(); 
	//编译会出错，说明函数调用才会去调用
}

类模板做函数对象参数

一共有三种传入方式

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

template<class nametype,class agetype>
class person
{public:
	nametype name;
	agetype age;
	person(nametype _name, agetype _age)
	{
		name = _name, age = _age;
	}
	void show() { cout << name << " " << age << endl; }
};
//指定参与类型
void test1(person<string, int>& p)
{
	p.show();
}
//参数模板化
template<class nametype, class agetype>
void test2(person<nametype, agetype>& p)
{
	p.show();
}
//整个类模板化,但局限性很大
template<class T>
void test3(T& p)
{
	p.show();
}
int main()
{
	person<string, int> p("tom", 10);
	test1(p);
	test2(p);
	test3(p);
}

类模板与继承

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

指定类型继承

template<class T>
class base
{public;
	T data;
};
class test :public base<int>
{
	test(int _data) 
	{
		this->data = _data;
		cout << base::data << endl;
	}
};

子类也是类模板

template<class T>
class base
{public;
	T data;
};
template<class T1,class T2>
class test :public base<T2>
{
};

类模板成员函数类外实现

成员函数需要函数模板

template<class T>
class test { 
public:
	T data;
	test(T _data);
	void show();
};
template<class T>
test<T>::test(T _data)
{
	this->data = _data;
}
template<class T>
void test<T>::show()
{
	cout << this->data << endl;
}
int main()
{
	test<int> s(10);
	s.show();
}

类模板分文件编写

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

c++在写模版函数时（template之类的），头文件不能与cpp文件分离。

解决方法：

• 直接包含.cpp源文件
• 将声明和实现写到同一个文件中，并更改后缀名为.hpp

// “person.cpp”
#include"person.h"
template<class T1, class T2>
person<T1, T2>::person(T1 _age, T2 _name)
{
	this->age = _age;
	this->name = _name;
}
template<class T1, class T2>
void person<T1, T2>::show()
{
	std::cout << age << " " << name << std::endl;
}
// person.h
#pragma once
#include<iostream>
template<class T1,class T2>
class person
{
public:
	T1  age;
	T2 name;
	person(T1 _age,T2 _name);
	void show();
};
// main.cpp
#include<iostream>
#include"person.cpp"
using namespace std;
int main()
{
	person<int, string> test(10, "tom");
	test.show();
}

// "person.hpp"
#include<iostream>
template<class T1,class T2>
class person
{
public:
	T1  age;
	T2 name;
	person(T1 _age,T2 _name);
	void show();
};
template<class T1, class T2>
person<T1, T2>::person(T1 _age, T2 _name)
{
	this->age = _age;
	this->name = _name;
}
template<class T1, class T2>
void person<T1, T2>::show()
{
	std::cout << age << " " << name <<std:: endl;
}
// main.cpp
#include<iostream>
#include"person.hpp"
using namespace std;
int main()
{
	person<int, string> test(10, "tom");
	test.show();
}

类模板与友元

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

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

template<class T>
class test;
template<class T>
void show(test<T>& temp)
{
	cout << temp.data << endl;
}
template<class T >
class test
{
private:
	T data;
public:
	test(T _data);
	friend void show<>(test<T> & temp);
};
template<class T >
test<T>::test(T _data)
{
	this->data = _data;
}
int main()
{
	test<int> t(10);
	show(t);
	test<string> s("tom");
	show(s);
}

控制实例化

当模板被使用时才会进行实例化，这一特性意味着，相同的实例可能出现在多个对象文件中。当两个或多个独立编译的源文件使用了相同的模板，并提供了相同的模板参数时，每个文件中都会有该模板的一个实例。

在大系统中，在多个文件中实例化相同模板的额外开销可能非常严重。在新标准中，我们可以通过显式实例化（explicit instantiation）来避免这种开销。

// 实例化声明
extern template declaration;
// 实例化定义
template declaration;

declaration是一个类或函数声明，其中所有模板参数已被替换为模板实参。

当编译器遇到extern模板声明时，它不会在本文件中生成实例化代码。将一个实例化声明为extern就表示承诺在程序其他位置有该实例化的一个非extern声明（定义）。对于一个给定的实例化版本，可能有多个extern声明，但必须只有一个定义。

由于编译器在使用一个模板时自动对其实例化，因此extern声明必须出现在任何使用此实例化版本的代码之前。