C++类与对象（下）

之前我们学习的模板能达到泛型的原因是：使用了“泛型的类型”，但是如果经过后面的“造轮子”（后面会尝试实现一下 STL的一些类模板），就会很明显发现泛型不仅仅是类型的问题，例如：“适配器”的使用（在后面双端队列里有体现），实际上就是一种泛型，对于泛型的理解我们不能仅限于类型。

1.非类型模板

模板除了类型模板，还有非类型模板。

1. 类型模板：出现在模板的参数列表中，跟在class或者typname后的参数类型名称

2. 非类型模板：使用一个常量作为类的一个非类型模板参数，在模板类/模板函数中可以将该参数作为常量来使用，且不能修改。并且，这里非类型模板参数也可以使用缺省值

//没有非类型模板参数
#include <iostream>
using namespace std;
#define NUM 10template<class T>
class Data
{
public://...
private:T _arr[NUM];
};
int main()
{Data<int> a1;//无法修改初始化大小（注意是初始化的时候修改大小）//只能手动调整#define的值//和之前的typedef的问题类似Data<double> a2;
}

这个时候就可以使用非类型模板参数，这个参数是一个常量，更加准确来说是不可被修改的整形常量（包括布尔类型）。

//有非类型模板参数
#include <iostream>
using namespace std;
//#define NUM 10template<class T, size_t N = 50>
class Data
{
public://...
private:T _arr[N];
};
int main()
{Data<int> a1;//默认初始化申请50个空间Data<double, 20> a2;//初始化时申请20个空间
}

您可能会疑惑：为什么不可以初始化先使用new开辟固定的空间，等到后续操作进行扩容操作呢？注意这里只是利用这个例子来简述语法特性，并不是实际的用途（在后续“位图”等知识中有很大的价值）。

补充：除了使用这个常量，还可以将这个常量作为一个类的标识数字来使用。

函数模板也可以使用这一特性。

#include <iostream>
using namespace std;template<class T, size_t N = 50>
class Data
{
public://...
public:T _arr[N];
};
template<class T, long NUM = 50>//演示了其他整形
void function(T& i)
{i = NUM;
}int main()
{Data<int, 10> a1;Data<int, 100> a2;int i = 0;function<int, 200>(i);//演示了函数修改非类型模板参数cout << i << endl;
}

C++ 11搞的新容器：静态数组array，其类模板就是使用了这个非类型模板参数。

#include <iostream>
#include <array>
using namespace std;
int main()
{array<int, 10>arr;for (auto &i : arr){i = 10;}for (auto i : arr){cout << i << " ";}cout << endl;return 0;
}

可惜静态数组不会进行初始化（吐槽：std::array当参数传递仍然要把数组的长度传过去，挺好玩的…），也支持范围for，并且越界检查比较严格（传统数组是抽查，但是静态数组是读写越界全面检查，避免代码崩溃）。

嘛…感觉优势不算很大（大不了使用vector，这也可以查找越界，还可以使用列表初始化）所以推广并不高。这个容器有点为了强迫症而统一STL风格的感觉。

类似deque在list和vector的感觉（后面会讲），静态数组就是传统数组和vector之间的方案。

2.模板特化

通常模板可以实现和类型无关的代码，但是有一些特殊的类型可能会得到一些错误的、不符合预期的结果，因此需要进行特殊处理，这就有了“模板特化”这个概念。

2.1.类模板特化

2.1.1.全特化

#include <iostream>
using namespace std;
template<class T1, class T2>
class Data
{
public:Data(){cout << "Data<T1, T2>" << endl;}
private:T1 _d1;T2 _d2;
};template<>//全特化，必须要写这句
class Data<int, char>//这里指定了特定的类型
{
public:Data(){cout << "Data<int, char>" << endl;}
private:int _d1;char _d2;
};
void TestVector()
{Data<int, int> d1;Data<int, char> d2;//这样就会直接调用全特化的模板，不会再去类模板构造
}
int main()
{TestVector();
}

2.1.2.偏特化

除了全特化，还可以进行偏特化。在下述代码中，我们可以看到偏特化不仅只是做了一些类型的指定，也可以对类型做进一步限制。

#include <iostream>
using namespace std;
template<class T1, class T2>
class Data
{
public:Data(const T1& d1, const T2& d2) : _d1(d1), _d2(d2){ cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};//1.部分类模板参数特化
template <class T1>
class Data<T1, int>
{
public:Data(const T1& d1, const int& d2) : _d1(d1), _d2(d2){ cout << "Data<T1, int>" << endl; }
private:T1 _d1;int _d2;
};//2.1.对两个参数进行进一步限制，偏特化为指针类型
template <typename T1, typename T2>//这里也是必须写，和全特化有些不同
class Data <T1*, T2*>
{
public:Data(const T1& d1, const T2& d2) : _d1(d1), _d2(d2){ cout << "Data<T1*, T2*>" << endl; }
private:T1 _d1;//注意其成员不是指针，仍然是原类型T2 _d2;//注意其成员不是指针，仍然是原类型
};//2.2.对两个参数进行进一步限制，偏特化为引用类型
template <typename T1, typename T2>//这里也是必须写，和全特化有些不同
class Data <T1&, T2&>
{
public:Data(const T1& d1, const T2& d2) : _d1(d1), _d2(d2){cout << "Data<T1&, T2&>" << endl; }
private:T1 _d1;T2 _d2;
};void test()
{Data<int, double> d1(10, 20);//调用基础的类模板Data<int, int> d2(30, 40);//调用偏特化的类模板Data<int*, int*> d3(1, 2);//调用偏特化的指针版本Data<int&, int&> d4(3, 4);//调用偏特化的引用版本
}
int main()
{test();return 0;
}

补充：偏特化会使得特化更加强大，某些程度上来说比全特化更加常用。

因此可以总结类模板的特化语法就是：

//1.原类模板
template<class T1, class T2, /*...*/, class Tn>
class ClassName
{/*...*/};//2.特化类模板
template</*填入仍旧继续使用的泛型（如果都使用可以省略这里）*/>
class ClassName</*指定特定的类型，并且写入仍旧使用的泛型，注意顺序*/>
{/*...*/};

2.2.函数模板特化

#include <iostream>
using namespace std;
//类模板
class Data
{
public:Data(int d) : _d(d) {}bool operator<(const Data& x){ return _d < x._d; }
private:int _d;
};//函数模板
template<class T>
bool Less(T left, T right)
{return left < right;
}//特化函数模板
template<>
bool Less<Data*>(Data* left, Data* right)
{return (*left) < (*right);
}
/*
template<>
bool Less<Data*>(const Data* & left, const Data* & right)//这种写法很特殊，是没有办法通过的，原本是为了使用const修饰引用变量，避免引用变量被修改，但是由于指针和const修饰的特殊性，导致const修饰了*，因此只能改成：(Data* const& left, Data* const& right)这种写法虽然奇怪，但是却是正确的。
{return (*left) < (*right);
}
*/int main()
{cout << Less(1, 2) << endl;//调用了普通的函数模板Data d1(1);Data d2(2);cout << Less(d1, d2) << endl;//调用了普通的函数模板Data* p1 = &d1;Data* p2 = &d2;cout << Less(p1, p2) << endl;//调用特化后的函数模板，虽然这种调用看起来很奇怪return 0;
}

注意1：区分好“匹配”和“特化”和“实例化”。

1. 匹配：是有相匹配的类型，可以使用对应的模板
2. 实例化：是编译器自己做的，将匹配对应的模板进行实例化
3. 特化：特化不是全新的模板，必须依赖模板，不可以单独存在

注意2：实际上特化更加适合类模板一些，实际上函数重载（重载）对比函数模板特化（匹配）更加简单。

3.函数模板声明定义分离

这一点凸显在函数的声明定义的分离上，假设有下面三个文件：

//function.h内声明
#pragma once
#include <iostream>
template<class T>
T Add(const T& left, const T& right);int NoTemplateAdd(const int& left, const int& right);

//function.cpp内定义
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}int NoTemplateAdd(const int& left, const int& right)
{return left + right;
}

//main.cpp内包含头文件并且调用
#include "function.h"
int main()
{std::cout << Add(1, 2);//链接错误std::cout << Add(1.0, 2.0);//链接错误std::cout << NoTemplateAdd(1, 2);//成功调用return 0;
}

可以发现函数模板没有办法声明和定义分离在两个文件中，会显示链接错误（但是普通的函数可以）。

让我们来分析一下这里面的原因：

1. C/C++要运行程序，就需要经历“预处理-编译-汇编-链接”
2. 在编译阶段，会对多份源文件做各自的编译（进行词法、语法、语义分析、错误检查等）并且生成多份的汇编代码（注意头文件是不会参与编译的）这个时候在function.obj或者说function.o中，由于编译器没有看到函数的实例化，因此没有生成具体的加法函数。
3. 而在main.obj或者main.o中，编译器看到有加法函数的调用，但是暂时不知道具体的实现，因此就暂时放进了符号表里等待后续链接
4. 在链接阶段由于没有实例化，因此function.obj或者说function.o中没有加法函数的定义，根本就无法提供加法函数的地址在符号表里供main.obj或者main.o链接

因此后续链接的时候就会报错，即“链接错误”。

如果一定要分离，有两种方法：

1. 进行显示实例化（有缺陷）

   //function.h
   #include <iostream>
   using namespace std;template <typename T>
   void MyFunction(T value);
   

   //function.cpp
   #include "function.h"template <typename T>
   void MyFunction(T value)
   {cout << value << endl;
   }
   //显式实例化int类型的函数模板
   template void MyFunction<int>(int value);
   

   //main.cpp
   #include "function.h"int main() 
   {//调用int版本的函数模板MyFunction(42);return 0;
   }
   

2. 在一个翻译单元里分离，即：干脆直接将定义和声明都写在一个.hpp内，这样做是更加推荐的。