C++泛型编程：模板详解与使用
本文详细介绍了C++中的模板编程，包括模板的特点、使用方式、注意事项，涉及函数模板、类模板、继承、友元等内容，展示了模板在泛型编程中的重要性。
概要
模板（针对泛型编程和STL技术，C++另一种编程思想为泛型编程，主要利用的技术就是模板）
模板特点：
（1）模板不可以直接使用，它只是个框架（参考PPT模板）；
（2）模板的通用不是万能的。
技术细节
template<typename T>
template—声明创建模板
typename—表示后面是一种数据类型，可以用class代替，比较严谨的人函数模板会用typename，类模板会用class，但class既可以表示函数模板也可以表示类模板
T—通用数据类型，名称可以替换通常为大写字母
模板使用方式一：
创建一个函数模板：
template<typename T> //声明一个函数模板告诉编译器后面代码中的T不要报错，T是一个通用数据类型
void Swap(T& a, T& b)
{
T tmp;
tmp = a;
a = b;
b = tmp;
}
int main()
{
int a = 10;
int b = 20;
//两种方式使用函数模板
//第一种，自动推导型
Swap(a, b);
//第二种，显示指定类型
Swap<int>(a, b);
return 0;
}
注意事项：
（1）自动类型推导：必须推导一致的数据类型T才可以使用
（2）显示指定类型：模板必须要确定T的数据类型，才可以使用
模板使用方式二：
template<class T>
void fun()
{
cout << "没有用到T的函数模板" << endl;
}
int main()
{
fun<int>(); //就算没有用到数据类型T，但在调用函数模板时必须指定T类型
return 0;
}
注意事项：
fun()函数没有用到通用数据类型，那么自动类型推导方式就用不了，只能用显示指定类型，必须要先确定T类型才能调用函数模板，就算没有用到T也要确定类型。
模板使用方式三：
普通函数和函数模板的区别：
（1）普通函数可以发生隐式类型转换；
（2）函数模板用自动类型推导，不可以发生隐式类型转换；
（3）函数模板用显示指定类型，可以发生隐式类型转换；
普通函数发生隐式类型转换：
int Add(int a, int b)
{
return a + b;
}
int main()
{
cout << Add(1, 2.5) << endl; //3
}
函数模板发生隐式类型转换：
template<class T>
int Add(T a, T b)
{
return a + b;
}
int main()
{
cout << Add<int>(1, 2.5) << endl; //3
}
2.5自动转换为2
模板使用方式四：
普通函数和函数模板调用规则：
（1）如果函数模板和普通函数都可以实现，优先调用普通函数
（2）可以通过空模板参数列表来强制调用函数模板
（3）函数模板也可以发生重载
（4）如果函数模板可以产生更好的匹配，优先调用函数模板
条件（1）（3）案例：
template<class T>
void Add(T a, T b)
{
cout << "函数模板" << endl;
}
//函数模板和普通函数发生重载
void Add(int a, int b)
{
cout << "普通函数" << endl;
}
int main()
{
Add(1, 2); //普通函数
}
条件（2）案例：
template<class T>
void Add(T a, T b)
{
cout << "函数模板" << endl;
}
void Add(int a, int b)
{
cout << "普通函数" << endl;
}
int main()
{
Add<>(1, 2); //函数模板
}
条件（4）案例：
template<class T>
void Add(T a, T b)
{
cout << "函数模板" << endl;
}
void Add(int a, int b)
{
cout << "普通函数" << endl;
}
int main()
{
char a = 'a';
char b = 'b';
Add(a, b); //函数模板
}
如果是普通函数还需要把char类型隐式转换为int类型，而直接调用函数模板会直接以char类型传入
当函数模板发生重载，会优先调用具体化的模板：
class Person {};
template<class T>
void Compare(T& p1, T& p2)
{
cout << "函数模板" << endl;
}
//具体化模板重载
template<> void Compare(Person& p1, Person& p2)
{
cout << "具体化模板" << endl;
}
int main()
{
Person p1;
Person p2;
Compare(p1, p2); //具体化模板
}
模板使用方式五：
类模板使用：
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->name = name;
this->age = age;
}
T1 name;
T2 age;
};
int main()
{
//确定类模板参数列表，string和int
//不能用自动推导型，因为自动推导型需要所有参数都是同一类型
Person<string, int>("张三", 20);
return 0;
}
类模板和函数模板区别：
1、类模板没有自动推导的使用方式，只能用指定显示类型
2、类模板在模板参数列表中可以有默认参数
template<class T1, class T2 = int>
class Person
{
public:
Person(T1 name, T2 age)
{
this->name = name;
this->age = age;
}
T1 name;
T2 age;
};
int main()
{
//确定类模板参数列表，string和int(已有默认参数)
Person<string>("张三", 20);
return 0;
}
类模板中成员函数创建时机：
1、普通类中的成员函数一开始就可以创建
2、类模板成员函数在调用时才可以创建
class Student
{
public:
void func()
{
cout << "普通成员函数" << endl;
}
};
template<class T1>
class Person
{
public:
T1 obj;
void fun()
{
obj.func();
}
};
编译是没问题的，为啥没有报错，不知道obj是啥，到底是对象还是其他类型，原因在于类模板成员函数在调用的时候才创建，也就是说编译的时候遇到类模板直接会忽略类模板成员函数的存在。
模板使用方式六：
类不是模板，但成员函数是模板（声明和实现都要放到头文件）
class Person
{
public:
template<class T1>
void fun();
};
template<class T1>
inline void Person::fun()
{
}
模板使用方式七：
类模板对象作为函数参数：
（1）指定传入类型
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->name = name;
this->age = age;
}
void fun()
{
cout << name << " " << age << endl;
}
T1 name;
T2 age;
};
//指定传入类型，string和int
void func(Person<string, int>& p)
{
p.fun();
}
int main()
{
Person<string, int> p("张三", 20);
func(p);
return 0;
}
（2）参数模板化
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->name = name;
this->age = age;
}
void fun()
{
cout << name << " " << age << endl;
}
T1 name;
T2 age;
};
//参数模板化
template<class T1, class T2>
void func(Person<T1, T2>& p)
{
p.fun();
}
int main()
{
Person<string, int> p("张三", 20);
func(p);
return 0;
}
(3)整个类模板化
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->name = name;
this->age = age;
}
void fun()
{
cout << name << " " << age << endl;
}
T1 name;
T2 age;
};
//整个类模板化
//T1为Person类型
template<class T1>
void func(T1& p)
{
p.fun();
}
int main()
{
Person<string, int> p("张三", 20);
func(p);
return 0;
}
模板使用方式八：
类模板与继承：
1、当子类继承的父类是一个类模板，子类在声明的时候，要指定出父类中的T的类型
2、如果不指定，编译器无法给子类分配内存
3、如果想灵活指定出父类中的T类型，子类也需变为类模板
第一种方式不太灵活，每次继承时需要指定父类T的类型
template<class T1>
class Person1
{
public:
T1 age;
};
class student : public Person1<int>
{
};
第二种方式把子类变为模板，创建对象时可以指定任意类型，主推！
template<class T1>
class Person1
{
public:
T1 age;
};
template<class T, class T1>
class student : public Person1<T1>
{
public:
T name;
};
int main()
{
//相当于父类的T定义为int类型，子类的T定义为string类型
student<string, int> p;
return 0;
}
模板使用方式九：
类模板成员函数类外实现：
template<class T1>
class Person2
{
public:
Person2(T1 age);
void fun(T1 a);
T1 age;
};
template<class T1>
Person2<T1>::Person2(T1 age)
{
this->age = age;
}
template<class T1>
void Person2<T1>::fun(T1 a)
{
cout << a << endl;
}
int main()
{
Person2<int> p(50);
p.fun(3);
return 0;
}
类模板使用方式十：
类模板和友元 ：
1、全局函数类内实现
template<class T1, class T2>
class Person
{
//全局函数做友元，并在类内实现
friend void fun(Person<T1, T2>& p)
{
cout << p.name << " " << p.age << endl;
}
public:
Person(T1 name, T2 age)
{
this->name = name;
this->age = age;
}
T1 name;
T2 age;
};
int main()
{
Person<string, int> p("张三", 20);
fun(p);
return 0;
}
2、全局函数类外实现
template<class T1, class T2>
class Person;
template<class T1, class T2>
void fun(Person<T1, T2>& p)
{
cout << p.name << " " << p.age << endl;
}
template<class T1, class T2>
class Person
{
friend void fun<>(Person<T1, T2>& p);
public:
Person(T1 name, T2 age)
{
this->name = name;
this->age = age;
}
T1 name;
T2 age;
};
int main()
{
Person<string, int> p("张三", 20);
fun(p);
return 0;
}
全局函数类外实现
（1）声明友元的时候需要加空模板参数列表；
（2）因为在Person中声明了fun函数，故需要提前让Person知道这个函数的存在，所以需要把函数模板放在Person类的前面；
（3）由于函数模板的实现在Person类的前面，同时函数的传入参数中引入了Person类模板，编译器不知道Person的存在，所以要在函数实现前面声明下Person类模板，提前让fun函数知道传入的参数是存在的。
小结
类模板分文件编写：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时调用不到。
解决办法：
1、直接包含.cpp文件（很少用）
2、将声明和实现写在同一个文件中，并更改后缀名为.hpp，hpp是约定的名称并不是强制，以后一看到hpp的文件就知道该文件存放的是类模板
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
