C++教程(3) 模板和泛型编程

模板

函数模板

通过 template 定义函数模板,T的类型由编译时根据模板函数的使用情况而定 即根据传入的实参推断T的类型.由此模板函数即可处理任何数据类型,而不用为每种数据类型编写重复的函数代码

#include <iostream>
using namespace std;
template <typename T>
int compare(const T &a, const T &b) {
	if(a < b) return -1;
	if(a > b) return 1;
	return 0;
}
int main() {
	int a = 1, b = 5;
	double c = 2, d = -1;
	string e = "A", f = "A";
	std::cout << compare(a, b) << std::endl;
	std::cout << compare(c, d) << std::endl;
	std::cout << compare(e, f) << std::endl;
	getchar();
	return 0;
}
结果: -1 1 0

模板函数返回值

template <typename T>
T compare(const T &a, const T &b) {
	T temp = b;
	....
	return temp;
}

多个模板函数参数

template <typename T,typename U>
int compare(const T &a, const U &b) {
	....
}

内联模板函数

template <typename T>
inline int min(const T &a, const T &b);

类模板

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>
using namespace std;

template <class T>
class Stack {
	private:
		vector<T> elems;
	public:
		void push(T const&); //入栈
		void pop();          //出栈
		T top() const;       //栈顶元素
		bool empty() const {
			return elems.empty();
		}
};

template <class T>
void Stack<T>::push(T const& elem){
	elems.push_back(elem);
}

template <class T>
void Stack<T>::pop(){
	if (elems.empty()) {
		throw out_of_range("Stack<>::pop(): empty stack");
	}
	elems.pop_back();
}

template <class T>
T Stack<T>::top() const{
	if (elems.empty()) {
		throw out_of_range("Stack<>::top(): empty stack");
	}
	return elems.back();
}

int main(){
	try {
		Stack<int>    intStack;  // int 类型的栈 
		Stack<string> stringStack;    // string 类型的栈 

		// 操作 int 类型的栈 
		intStack.push(7);
		cout << intStack.top() << endl;

		// 操作 string 类型的栈 
		stringStack.push("hello");
		cout << stringStack.top() << std::endl;
		stringStack.pop();
		//stringStack.pop();
	}
	catch (exception const& ex) {
		cerr << "Exception: " << ex.what() << endl;
		getchar();
		return -1;
	}
	getchar();
	return 0;
}

Note:T top() const; 表示函数Top()为只读操作,不能对类成员进行修改
默认模板参数

template <class T=int> class Stack {...}

成员模板

普通类里定义模板函数或模板内部类

class Car {
	template <typename T> void run(T &);
};
//定义
template<typename T> void Car::run(T & a,){...}

类模板里定义独立的成员模板

template <typename T> class Car {
	template <typename U> void run (U a, U b);
};
//定义
template<typename T>
template<typename U>
void Car<T>::run(U a, U b){...}

函数模板显式实参

显示模板实参在调用时由用户指出

template <typename T1,typename T2,typename T3>
T3 sum(T1,T2)；//T3为显示模板实参

double a = 2.0,b = 3.0;
auto val = sum<int>(a,b);//指定显示模板实参T3为int，T2,T3由a，b推断得出

可变参数模板

template <typename T,typename ... Args>
void foo(T &t, const Args& ... rest);
foo(1,'A');
foo(1,2,'C');