C++知识点总结: 快速跳转

1. 泛型编程

泛型编程最初诞生于C++中。目的是为了实现C++的STL（标准模板库）。其语言支持机制就是模板（Templates）。模板的精神其实很简单：参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数T。（参考自Baidu）

1.1 模板

• 模板就是建立同用的模具，以提高复用性，将类型参数化
• 只是一个框架，不能直接使用
• C++提供两种模板机制
  • 函数模板
  • 类模板

1.2 函数模板

建立一个通用函数，其函数返回值和参数类型可以不具体指定，用一个虚拟的类型代替

1.2.1 语法

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

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

1.2.2 使用函数模板方式

• 自动类型推导（必须推导出一致的数据类型T，才能使用）
• 显示指定类型（模板必须确定T的数据类型才能使用）

eg:

template<class T>//使用模板实现交换函数，T可用是int、float等
void swap(T& a,T& b){
	T temp = a;
	a = b;
	b = temp;
}
int main(){
	int a = 99;
	int b = 100;
	//1.自动类型推导
	swap(a,b);
	//2.显示指定类型
	swap<int>(a,b);
	
}

1.2.3 普通函数和函数模板的区别

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

//函数模板
template<class T>
T Add01(T a,T b){
	return a + b;
}
//普通函数
int Add02(int a,int b){
	return a + b;
}

int main(){
	int a = 99;
	int b = 100;
	char c = 'c';
	
	cout << Add01(a,c) << endl;//报错，自动类型推导，不发生隐式转换
	cout << Add01<int>(a,c) << endl;//正确，可发生隐式转换
	cout << Add02(a,c) << endl;//正确，普通函数：char类型的'c'隐式转换为int类型
	
	return 0;
}

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

• 函数模板和普通函数都能实现的情况下，优先调用普通函数
• 可通过空模板参数列表来强制调用函数模板（swap<>(a, b);）
• 函数模板可以发生重载
• 若函数模板可用产生更好的匹配，优先调用函数模板

注意：提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

1.2.5 模板的局限性

若参数提供的是数组或者自定义数据类型，可能实现不了，可利用模板重载来实现特定类型

class Person{
public:
	Num(string name,int age){
		this->m_name = name;
		this->m_age = age;
	}
	int m_age;
	string m_name;
};
//普通模板
template<class T>
bool Compare(T& a, T& b)
{
	if (a == b)
		return true;
	else return false;
}
//具体化，显示具体化的原型和定义以template<>开头，并通过名称来指定类型，一般优于常规模板
template<> bool Compare(Person &p1,Person &p2){
	if(p1.m_name == p2.m_name && p1.m_age == p2.m_age)
		return true;
	else return false;
}

void test(){
	int a = 10；
	int b = 20;
	bool ret = Compare(a,b);//内置数据类型可用之间使用通用函数模板
	Person("Tom",10);
	Person("Jerry",10);
	bool ret = Compare(p1,p2);//自定义数据类型不会调用普通的函数模板
}

1.3 类模板

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

1.3.1 语法

template<class DataType>
类

1.3.2 类模板与函数模板区别

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

//类模板
template<class NmaeType,class AgaType = int>
class Person{
public:
	Person(NameType name,AgeType age){
		this->m_name = name;
		this->m_age = age;
	}
	AgeType m_age;
	NameType m_name;	
};

void test(){
	//Person p("Tom",10);//错误，类模板使用时，没有自动类型推导
	Person <string ,int>p("Tom",10);//显示指定类型使用类模板
	Person <string>p("Jerry",10);//使用默认参数
}

1.3.3 类模板中成员函数创建时期

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

1.3.4 类模板对象做函数参数

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

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

//参数模板化
template <class T1,class T2>
void printPerson2(Person<T1,T2>&p){
    p.showPerson();
    cout << "T的类型为："<< typeid(T1).name() <<endl;
    cout << "T的类型为："<< typeid(T2).name() <<endl;
}
//整个类模板化
template<class T>
void printPerson3(T &p){
    p.showPerson();
    cout << "T的类型为："<< typeid(T).name() <<endl;
}

1.3.5 类模板与继承

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

template<class T>
class Base{
	T m;
}; 
//class Son:public Base{//错误,未指定类型

}
class Son:public Base<int>{//必须指定类型

}
//类模板继承类模板，可用T2指定父类中的T类型
template<class T1,class T2>
class Son2:public Base<T2>{

};

1.3.6 类模板成员类外实现

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

//构造函数
tempalte<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age){

}
//成员函数
template<class T1,class T2>
Person<T1,T2>::showPerson(){

}

1.3.7 类模板与友元

• 全局函数类内实现 - 直接在类内声明友元即可
• 全局函数类外实现 - 需要提前让编译器知道全局函数的存在

template<class T1, class T2> class Person;//函数模板声明
template<class T1, class T2> void printPerson2(Person<T1, T2> & p);//函数实现

参考

黑马程序员c++