• C++08函数模板

    1.自动推导类型

    在C语言和C++98中，auto 关键字用于修饰变量(自动存储的局部变量)。

    在C++11中，赋予了auto 全新的含义，不再用于修饰的变量，而是作为一个类型指示符，指示编译器在编译时推导auto声明的变量的数据类型。

    在Linux 平台下，编译需要加-std=c++11 参数。

    1. #include 
    2. using namespace std;
    3.  
    4.  
    5. // 如果初始化变量的时候不定义类型，那么会使用auto关键字
    6. // 根据变量赋值，自动推导出相关类型
    7. int main() {
    8. 	auto a = 3; cout << "a=" << a << endl;
    9. 	auto b = 3.3; cout << "b=" << b << endl;
    10. 	auto c = "鲁班"; cout << "c =" << c << endl;
    11. 	system("Pause");
    12. }

     注意事项：

    1. auto声明的变量必须在定义时初始化
    2. 初始化的右值可以是具体的数值，也可以是表达式和函数的返回值等
    3. auto不能作为函数的形参类型
    4. auto不能直接声明数组
    5. auto不能定义类的非静态成员变量

     auto关键字的真正用途：

    1. 代替冗长复杂的变量声明
    2. 在模板中，用于声明依赖模板参数的变量。
    3. 函数模板依赖模板参数的返回值
    4. 用于lambda 表达式中

     auto关键字可以计算两个不同类型的值

    1. #include 
    2. using namespace std;
    3.  
    4. template<typename T1, typename T2>
    5. void func(T1 x, T2 y) {
    6.  
    7. 	auto tmp = x + y;
    8. 	cout << tmp << endl;
    9. }
    10.  
    11. int main() {
    12. 	short a = 1;
    13. 	char b = 2;
    14. 	func(a, b);
    15. 	system("Pause");
    16. 	return 0;
    17. }

    2.函数模板

     先看一段代码：如果我们需要更换两个变量的值，根据变量值的不同，需要不断的重载Swap函数，函数中的tmp变量类型也会改变，其他地方都一样。

    1. #include 
    2. using namespace std;
    3.  
    4. // 交换两int值
    5. void Swap(int &a ,int &b) {
    6. 	int tmp = a;
    7. 	b = a;
    8. 	a = tmp;
    9. }
    10.  
    11. // 交换两double值
    12. void Swap(double& a, double& b) {
    13. 	double tmp = a;
    14. 	b = a;
    15. 	a = tmp;
    16. }
    17.  
    18. // 交换两字符串值
    19. void Swap(string& a, string& b) {
    20. 	string tmp = a;
    21. 	b = a;
    22. 	a = tmp;
    23. }
    24.  
    25.  
    26. int mian() {
    27.  
    28. }

    为了避免这种麻烦，利用模型来生成相应的函数代码，即函数模板：

    1. 函数模板是通用的函数描述，使用任意类型(泛型)来描述函数
    2. 编译的时候，编译器推导实参的数据类型，根据实参的数据类型和函数模板，生成该类型的函数定义
    3. 生成函数定义的过程被称为实例化。

    创建交换两个变量的函数模板:

    1. #include 
    2. using namespace std;
    3.  
    4. // 创建一个函数模板，交换两个变量的值
    5. // 定义模板，这里anytype可以随便取名,但是需要注意和下面一致
    6. // 函数模板用typename  类模板用 class
    7. template <typename T>
    8. void Swap(T& a, T& b) {
    9. 	T tmp = a;
    10. 	a = b;
    11. 	b = tmp;
    12. }
    13.  
    14.  
    15. int main() {
    16. 	int a = 1, b = 2;
    17. 	cout << a << b << endl;
    18. 	Swap(a, b);
    19. 	cout << a << b << endl;
    20. 	system("Pause");
    21. 	return 0;  
    22.  
    23. }

    注意事项：

    1. 可以为类的成员函数创建模板，但不能是虚函数和析构函数
    2. 使用函数模板时，必须明确数据类型，确保实参与函数模板能匹配上
    3. 使用函数模板时，推导的数据类型必须适应函数模板中的代码
    4. 使用函数模板时，如果是自动类型推导，不会发生隐式类型转换，如果显式指定了函数模板的数据类型，可以发生隐式类型转换
    5. 函数模板支持多个通用数据类型的参数
    1. #include 
    2. using namespace std;
    3.  
    4. class Fruit {
    5. public:
    6. 	// 构造函数
    7. 	template <typename T>
    8. 	Fruit(T a) {
    9. 		cout << "a=" << a << endl;
    10. 	}
    11.  
    12. 	// 用到模板的地方在上面都要加这一句
    13. 	template <typename T1,typename T2>
    14. 	void show(T1 b,T2 c) {
    15. 		cout << "b=" << b << endl;
    16. 		cout << "c=" << c << endl;
    17. 	}
    18. };
    19.  
    20. int main() {
    21. 	Fruit apple("烟台红苹果");
    22. 	apple.show("真的甜","好吃");
    23. 	system("Pause");
    24. 	return 0;  
    25.  
    26. }

     函数模板的具体化

    语法：

    template<>void 函数模板名<数据类型>（参数列表）

    template<>void 函数模板名（参数列表）

    {

         // 函数体

    }

    1. #include 
    2. using namespace std;
    3.  
    4. class Fruit {
    5. public:
    6. 	// 构造函数
    7. 	Fruit(const string& f_name,int f_gram) {
    8. 		m_gram = f_gram;
    9. 		m_name = f_name;
    10. 	}
    11.  
    12.  
    13. 	void show_gram() {
    14. 		cout << this->m_name << this->m_gram << endl;
    15. 	}
    16.  
    17. 	string m_name;
    18. 	int m_gram;
    19. };
    20.  
    21. // 函数模板
    22. template<typename T>
    23. void Swap(T& a, T& b) {
    24. 	T tmp = a;
    25. 	a = b;
    26. 	b = tmp;
    27. 	cout << "调用了Swap(T& a, T&b)" << endl;
    28. }
    29.  
    30. //具体化函数
    31. template<>void Swap(Fruit& f1, Fruit& f2) {
    32. 	int tmp = f1.m_gram;
    33. 	f1.m_gram = f2.m_gram;
    34. 	f2.m_gram = tmp;
    35. 	cout << "调用了Swap(Fruit& f1, Fruit& f2)" << endl;
    36. }
    37.  
    38. int main() {
    39. 	Fruit apple("苹果", 12), orange("橘子", 55);
    40. 	apple.show_gram();
    41. 	orange.show_gram();
    42. 	Swap(apple, orange);
    43. 	apple.show_gram();
    44. 	orange.show_gram();
    45. 	system("Pause");
    46. 	return 0;  
    47.  
    48. }

    1. 具体化优先于常规模板，普通函数优先于具体化
    2. 如果希望使用函数模板，可以用空模板参数强制使用函数模板
    3. 如何函数模板能产生更好的匹配，将优先于非函数模板

    声明和定义分开

    函数模板的定义和声明都是在头文件中，普通函数和函数模板的具体化版本是分开的。

    main.cpp

    1. #include 
    2. #include"public.h"
    3. using namespace std;
    4.  
    5. int main() {
    6. 	Swap(1, 1);  // 使用普通函数
    7. 	Swap('c', 'd');  // 使用函数模板
    8. 	Swap<>(1, 1);  // 使用函数模板具体化版本
    9. 	system("Pause");
    10. 	return 0;
    11. }

     头文件public.h：

    1. #pragma once
    2. #include 
    3. using namespace std;
    4.  
    5. void Swap(int a, int b);  // 普通函数
    6.  
    7. template<typename T>   // 函数模板
    8. void Swap(T a, T b) {
    9. 	cout << "使用了函数模板" << endl;
    10. }
    11.  
    12. template<>
    13. void Swap(int a, int b); // 函数模板具体化版本

    源文件public.cpp

    1. #include "public.h"
    2.  
    3. void Swap(int a, int b) {
    4. 	cout << "使用了普通函数" << endl;
    5. }
    6.  
    7. template<>
    8. void Swap(int a, int b) {
    9. 	cout << "使用了具体化的函数模板" << endl;
    10. }

    3.类模板

    template <class T>

    class 类模板名

    {

            类的定义

    }

    1. #include 
    2. using namespace std;
    3.  
    4. template<class T1,class T2>
    5. class AA {
    6. public:
    7. 	T1 m_a;
    8. 	T2 m_b;
    9. 	AA(T1 a, T2 b) :m_a(a), m_b(b){}
    10.  
    11. 	//构造函数
    12. 	AA() {}
    13.  
    14. 	// 可以用于成员函数的返回值
    15. 	// 即a是什么类型，这里geta返回的也是什么类型
    16. 	T1 geta() {
    17. 		T1 num = 2; // 这里也可以定义一个和a相同类型的与a相加
    18. 		return m_a + num;
    19. 	}
    20. 	T2 getb() {
    21. 		T1 num = 2;
    22. 		return m_b;
    23. 	}
    24.  
    25. };
    26.  
    27.  
    28.  
    29. int main() {
    30. 	AA<int, double>a;  // 用模板类AA创建对象
    31. 	a.m_a = 2;
    32. 	a.m_b = 3;
    33. 	cout << "a.geta()=" << a.geta() << endl;
    34. 	cout << "a.getb()=" << a.getb() << endl;
    35. 	system("Pause");
    36. 	return 0;
    37. }

    可以用new创建模板类对象：main函数这么写

    1. int main() {
    2. 	AA<int, double>*a=new AA<int, double>(1,2);  // 用模板类AA创建对象
    3.  
    4. 	cout << "a.geta()=" << a->geta() << endl;
    5. 	cout << "a.getb()=" << a->geta() << endl;
    6.  
    7. 	delete a;
    8. 	system("Pause");
    9. 	return 0;
    10. }

    类模板的具体化

    1. #include 
    2. using namespace std;
    3.  
    4. //类模板
    5. template<class T1,class T2>
    6. class AA {
    7. 	T1 mx;
    8. 	T2 my;
    9.  
    10. 	AA(const T1 x, const T2 y) :mx(x), my(y) { cout << "类模板，构造函数" << endl; }
    11. 	void show()const;//类内声明，类外实现
    12. };
    13.  
    14. // 成员函数类外实现
    15. template<class T1,class T2>
    16. void AA::show()const {
    17. 	cout << "类模板：x=" << mx << ",y=" << my << endl;
    18. };
    19.  
    20. //类模板完全具体化
    21. template<>class AA<int, string> {
    22. public:
    23. 	int mx;
    24. 	string my;
    25.  
    26. 	AA(const int x, const string y) :mx(x), my(y) { cout << "完全具体化：构造函数" << endl; };
    27. 	void show()const;
    28. };
    29.  
    30. void AA<int, string>::show()const {
    31. 	cout << "完全具体化x=" << mx << ",y=" << my << endl;
    32. };
    33.  
    34. //类模板部分显示具体化
    35. template<class T1>
    36. class AA {  // T1通用，string具体
    37. public:
    38. 	T1 mx;
    39. 	string my;
    40.  
    41. 	AA(T1 x, const string y) :mx(x), my(y) { cout << "部分具体化：构造函数 " << endl; };
    42. 	void show()const {
    43. 		cout << "部分具体化x=" << mx << ",y=" << my << endl;
    44. 	};
    45. };
    46.  
    47. int main() {
    48. 	//具体化程度高的类优先于具体化程度低的类，具体化的类优先于没有具体化的类
    49. 	AA<int, string>aa(22, "光头强");
    50. 	aa.show();
    51. 	system("Pause");
    52. 	return 0;
    53. }

    类模板的继承

    1.  模板类继承普通类（常见）

    2. 普通类继承模板类的实例版本

    3. 普通类继承模板类（常见）

    4. 模板类继承模板类

    5. 模板类继承模板参数给出的基类（不能是模板类）

    下面演示第一种：模板类继承普通类

    1. #include 
    2. using namespace std;
    3.  
    4. class AA {  // 普通类AA
    5. public:
    6. 	int m_a;
    7. 	AA(int a) :m_a(a) { cout << "调用AA构造函数" << endl; }
    8. 	void func1() { cout << "调用func1函数：m_a=" << m_a << endl; }
    9.  
    10. };
    11.  
    12. template<class T1,class T2>
    13. class BB:public AA  // 模板类BB
    14. {
    15. public:
    16. 	T1 m_x;
    17. 	T2 m_y;
    18. 	BB(const T1 x, const T2 y,int a):AA(a),m_x(x), m_y(y) { cout << "调用BB构造函数" << endl; }
    19. 	void func2() { cout << "调用func2函数，x+y=" << m_x <<",m_y=" << m_y << endl; }
    20.  
    21.  
    22. };
    23.  
    24. int main() {
    25.  
    26. 	BB<int, string>bb(22, "光头强", 6666);
    27. 	bb.func1();
    28. 	cout << "--------------------" << endl;
    29. 	bb.func2();
    30. 	system("Pause");
    31. 	return 0;
    32. }

    第三种情况：普通类继承模板类：

    1. #include 
    2. using namespace std;
    3.  
    4.  
    5.  
    6. template<class T1,class T2>
    7. class BB  // 模板类BB
    8. {
    9. public:
    10. 	T1 m_x;
    11. 	T2 m_y;
    12. 	BB(const T1 x, const T2 y):m_x(x), m_y(y) { cout << "调用BB构造函数" << endl; }
    13. 	void func2() { cout << "调用func2函数，x+y=" << m_x <<",m_y=" << m_y << endl; }
    14.  
    15.  
    16. };
    17.  
    18. template<class T1, class T2>
    19. class AA:public BB {  // 普通类AA
    20. public:
    21. 	int m_a;
    22. 	AA(int a,const T1 x,const T2 y) :BB(x,y),m_a(a) { cout << "调用AA构造函数" << endl; }
    23. 	void func1() { cout << "调用func1函数：m_a=" << m_a << endl; }
    24.  
    25. };
    26.  
    27. int main() {
    28.  
    29. 	AA<int, string>aa(1,22, "光头强");
    30. 	aa.func1();
    31. 	cout << "--------------------" << endl;
    32. 	aa.func2();
    33. 	system("Pause");
    34. 	return 0;
    35. }

    类模板的成员模板

    1. #include 
    2. using namespace std;
    3.  
    4. template<class T1,class T2>
    5. class AA {
    6. public:
    7. 	T1 m_x;
    8. 	T2 m_y;
    9.  
    10. 	AA(const T1 x,const T2 y):m_x(x),m_y(y){}
    11. 	void show() { cout << "m_x=" << m_x << " m_y=" << m_y << endl; }
    12.  
    13. 	template<class T> // 类模板
    14. 	class BB
    15. 	{
    16. 	public:
    17. 		T m_a;
    18. 		T1 m_b;
    19. 		BB(){}
    20. 		void show() { cout << "m_a=" << m_a << " m_b=" << m_b << endl; }
    21. 	};
    22.  
    23. 	BBbb;  // bb就是类模板AA的一个成员
    24.  
    25. 	//函数模板
    26. 	template<typename TF>
    27. 	void showf(TF tt) { cout << "tt=" << tt << endl; }
    28.  
    29. };
    30.  
    31. int main() {
    32. 	AA<int, string>a(22, "光头强");
    33. 	a.show();
    34. 	a.bb.m_a = "熊大";
    35. 	a.bb.show();
    36. 	a.showf("看我大卫天龙");
    37.  
    38.  
    39. 	system("pause");
    40. 	return 0;
    41. }

  • 相关阅读:
    数字求和（C++）
    第四章：指令系统
    ANR问题分析的一般套路
    Android：实现手机前后摄像头预览同开
    YOLOV:图像对象检测器在视频对象检测方面表现也很不错
    哺乳期哪些事不能做?
    安装nodejs
    16、Pytorch Lightning入门
    Docker实现Redis Cluster集群 哈希槽分区进行亿级数据存储
    反片语 set+哈希表 就C++代码而言，我很短
  • 原文地址：https://blog.csdn.net/weixin_45231460/article/details/128116989