【C++之模板进阶知识】

C++之模板进阶知识

前言：
前面篇章学习了C++对于各类容器的基本使用以及常用接口的认识，接下来继续学习，C++的模板进阶等相关知识。
/知识点汇总/

1、C++模板的简单介绍

C++模板是泛型编程的基础，它允许程序员编写与类型无关的代码，从而提高了代码的重用性和灵活性。

2、C++模板的分类

C++提供了两种主要的模板类型：函数模板和类模板。

2.1、函数模板

函数模板允许程序员定义一个函数，该函数能够处理多种数据类型，而无需为每种数据类型都编写一个单独的函数。
函数模板的语法允许你定义一个函数，其中函数返回类型和参数类型可以是虚拟的类型（模板参数），然后用具体的类型来实例化这个模板。
函数模板在编译时确定具体的数据类型，从而生成针对特定类型的函数。
函数模板支持隐式实例化和显式实例化。
函数模板还可以进行重载，即定义多个具有不同模板参数的函数模板。

2.2、类模板

类模板允许程序员定义一个类，该类可以与多种数据类型一起使用，而无需为每种数据类型都编写一个单独的类。
类模板的定义语法允许你指定一个或多个类型参数，这些参数将在创建类的实例时确定。
使用类模板创建对象时，必须指明具体的数据类型。
类模板的实例化与函数模板类似，也是在编译时确定具体的数据类型。

3、C++模板的优缺点

3.1、C++模板的主要优点包括

灵活性、可重用性和可扩展性：

模板允许你编写与类型无关的代码，从而提高了代码的重用性和灵活性。

减少开发时间：

通过使用模板，你可以将同一个算法应用于不同类型的数据，而无需为每个类型都编写一个单独的版本。

模拟多态的效率：

模板模拟多态的效率通常比使用C++类继承实现多态要高，因为它避免了虚函数和继承的开销。

3.2、C++模板存在的一些缺点包括

易读性较差：

模板代码相对于普通代码来说可能更难阅读和理解。

调试困难：

由于模板在编译时生成具体的代码，因此调试模板代码可能会更加困难。

编译时间较长：

当工程较大时，包含大量基于模板算法的实现可能会导致编译时间增加。

4、模板参数

在C++模板中，模板参数是用于指定模板类型或值的参数。模板参数可以是类型参数（type parameters）或非类型参数（non-type parameters），它们在模板定义中被声明，并在模板实例化时提供具体的值或类型。

4.1、类型参数

类型参数用于指定模板中类型的占位符。在模板实例化时，这些占位符将被具体的类型所替代。类型参数通常在尖括号（<

）中声明，并且可以使用任何有效的C++类型。

template <typename T> // 声明一个类型参数T  
class MyClass {  
public:  
    T value;  
    MyClass(T v) : value(v) {}  
    void printValue() {  
        std::cout << value << std::endl;  
    }  
};  
  
// 实例化模板类MyClass，T被int替代  
MyClass<int> myInt(42);  
myInt.printValue(); // 输出：42  
  
// 实例化模板类MyClass，T被std::string替代  
MyClass<std::string> myString("Hello, World!");  
myString.printValue(); // 输出：Hello, World!

4.2、非类型参数

非类型参数允许你在模板中指定非类型的值，如整数、枚举值或指针等。非类型参数在模板实例化时必须是一个常量表达式，并且它们的类型必须允许在编译时计算其值。

template <int N> // 声明一个非类型参数N  
class Array {  
public:  
    int data[N];  
    // ...其他成员函数...  
};  
  
// 实例化模板类Array，N被5替代  
Array<5> myArray; // 创建一个包含5个int的数组  
  
// 注意：非类型参数不能是引用类型或浮点数类型  
// 因为它们不能在编译时计算其值或大小

4.3、默认模板参数（缺省参数）

你可以为模板参数提供默认值，以便在模板实例化时省略这些参数。这可以增加模板的灵活性，使得模板的使用更加简洁。

template <typename T = int> // 声明一个类型参数T，并提供默认值为int  
class DefaultClass {  
public:  
    T value;  
    // ...其他成员函数...  
};  
  
// 实例化模板类DefaultClass，省略类型参数T，使用默认值int  
DefaultClass<> defaultInt; // T被int替代  
  
// 实例化模板类DefaultClass，指定类型参数T为double  
DefaultClass<double> defaultDouble; // T被double替代

4.4、多个模板参数

模板可以拥有多个类型参数和非类型参数，这些参数之间用逗号分隔。

template <typename T, typename U, int N> // 声明两个类型参数T和U，以及一个非类型参数N  
class PairArray {  
public:  
    T first[N];  
    U second[N];  
    // ...其他成员函数...  
};  
  
// 实例化模板类PairArray，T被int替代，U被double替代，N被5替代  
PairArray<int, double, 5> myPairArray;

4.4、模板参数小结

模板参数是C++模板编程的核心，它们使得模板能够处理不同类型和值的代码，从而提高了代码的重用性和灵活性。
注意：
1.浮点数、类对象以及字符串是不允许作为非类型模板参数的
2.非类型的模板参数必须在编译期间就能确认结果。

5、库中的array与常用数组的区别

#include <iostream>
#include <array>
#include <vector>
using namespace std;

int main()
{
	std::array<int, 10> a1;
	int a2[10];
	//库中封装的array的区别在于，优化了越界检查

	//越界读,检查不出来
	a2[10];
	cout << a2[10] << endl;
	//越界写，属于抽查
	a2[10] = 1;
	cout << a2[10] << endl;
	a2[15] = 1;//没被抽查到越界
	cout << a2[15] << endl;

	//对于库的越界检查，优化了这个问题
	//越界读，断言
	a1[10];
	cout << a1[10] << endl;
	//越界写，断言
	a1[10] = 1;
	cout << a1[10] << endl;

	//但是实际上，在具体的应用层面上，实际上这个优化并没有多大用处，完全可以使用vector解决，并且还能顺便初始化
	vector<int> v(10, 0);
	cout << v[9] << endl;
	cout << v[10] << endl;//断言检查

	//另外，还可能存在栈溢出的问题，因为静态数组是在栈区上开辟空间的。
	array<int, 1000000> a3;
	cout << sizeof(a3) << endl;
	//但是交给vector就不会溢出
	vector<int> v2(1000000, 0);
	cout << sizeof(v2) << endl;
	return 0;
}

6、模板对于按需实例化问题

在一些场景并不会报错，因为没有调用operator[],所以operator[]有调用参数不匹配，没有检查出来的情况。
一旦调用就会实例化，才会细致检查语法的错误，参数错误等。

//按需实例化：
//调用哪个成员函数编译器就实例化哪个成员函数
T& operator[](size_t index)
{
	return _array[index];
}
const T& operator[](size_t index) const
{
	assert(index < N);
	size(1);//按需实例化问题
	return _array[index];
}

7、模板的特化

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果；需要特殊处理，比如专门实现进行小于比较的模板。

#include <iostream>
using namespace std;

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

//类模板的特化 --- 单独写特化是不行的
template<>
bool Less<int*>(int* left, int* right)
{
	return left < right;
}

//半特化
template<class T1>
bool Less(T1* left, int* right)
{
	return left < right;  
}


int main()
{
	int a = 1;
	int b = 2;
	cout << Less(a, b) << endl;
	return 0;
}

8、模板的分离编译

什么是分离编译？

一个程序由若干个源文件共同实现，而每一个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行的过程称为分离编译模式。

#include <iostream>
#include "array.h"
using namespace std;

int main()
{
	/*
	bit::array<int> a;
	cout << a.size() << endl;
	//编译size和func时都只有声明，编译时，检查一下函数名和参数匹配就暂且通过，
	//而它的定义在其他.cpp文件中，链接时再去其他文件中找函数的地址。
	//当链接时，找不到函数地址就报链接错误
	bit::Func();
	//func和size现在都有声明和定义了
	//为什么链接时，func能找到，而size还是找不到呢？
	//本质就是调用size时，编译器不知道该怎么实例化。size有两个模板参数，且拿不到地址

	//解决1：显示实例化(比较局限)
	bit::array<double> a2;
	cout << a2.size() << endl;
	*/

	//解决2：利用模板的特性，声明和定义放入同一个.h文件中
	bit2::array<int> a3;
	cout << a3.size() << endl;
	bit2::array<double> a4;
	cout << a4.size() << endl;

	//为什么模板的定义放到.h就不会报错呢？
	//因为.h预处理展开后，实例化模板时，既有声明也有定义，直接就实例化，
	//所以编译时，有函数的定义，直接就有地址，不需要等链接再去找地址了。
	return 0;
}

9、模板总结

模板的优点：
1.模板复用了代码，节省了资源，更快的迭代开发，C++的标准模板库(STL)因此产生。
2.模板增强了代码的灵活性。
模板的缺点：
1.模板容易导致代码膨胀的问题，也会导致编译的时间长的问题。
2.出现模板编译出错时，错误信息凌乱，不易调试和定位解决错误。