模板没有实例化取内嵌类型报错问题

首先在这里分享一个模板的常见报错问题。就是模板的在没有实例化的情况下去取模板类里面的内嵌类型这时候的报错问题。

报错信息：
error C2760: 语法错误: 意外标记 “标识符”，应为 “;”
error C7510: “const_iterator”: 类型 从属名称的使用必须以“typename”为前缀

错误就在框线里面的哪一行代码，这段代码是使用模板编写的可以打印任意容器内的数据的函数。
报错的原因是在编译的时候，Con作为一个模板参数这时候还没有实例化出具体类型，编译器并不认识Con以及后面这一块是什么东西，因为类型没有实例化也就不能去取Con的内嵌类型。所以这时候就报错了。加上typename就是告诉编译器，Con是一个模板类型，等Con实例化之后再去取Con的内嵌类型。相当于是一个声明。

这里可以类比函数声明，如果调用了一个函数没有声明也没有定义，那么这时候是编译不通过的，报错就是找不到”xxx“标识符，这个错误是在编译的时候进行语法检查的时候检查出来的。如果加上这个函数的声明，那么编译时不会报错的。因为有了声明就告诉了编译器这个函数存在，你等着链接的时候再去找，如果在链接的时候还是找不到就会报错链接错误。
这里以add函数为例：
现在加上函数声明，但是不写函数定义。

这时候报的就是LNK也即是链接错误。

非类型模板参数

以前使用的模板都是将类型定义成模板参数，比如内置类型int等以及自定义类型等等。但是其实常量也是可以作为模板参数的。

#include<iostream>using namespace std;template<class T,size_t N>
class Time
{
public:private:T a[N];
};int main()
{Time<int,100> t1;return 0;
}

如上这里的第二个模板参数就是一个常量，但是非类型模板参数只能是int类型的常量，其他比如：double，字符串或者自定义类型变量那么都是不行的。
在类内部这个非类型模板参数也是当作常量使用的，因为定义数组的大小只能使用常量（不考虑C99中的变长数组）
其次模板必须在编译的时候就能确定模板参数的类型，这也决定了模板不能够分离编译，一旦分离就会报错。

模板的特化

使用模板可以让编译器替我们完成一些重复的工作，同时也可忽略类型，让我们只关注代码逻辑的本身，但是有些特殊情况模板的默认处理逻辑并不能完成我们的需要，这时候就有了模板的特化。

函数模板的特化

比如模板定义了一个比较函数

template<class T> 
void compare(const T& x, const T& y)
{return x > y;
}

可以给这个函数传int，double等等，编译器都会自动生成一份与其匹配的代码，但是当想要比较字符串的时候。比如下面：

template<class T> 
bool compare(const T& x, const T& y)
{return x > y;
}int main()
{//Time<int,100> t1;char arr1[] = "hello kisskernel";char arr2[] = "hello kisskernel";cout << compare(arr1, arr2) << endl;const char* p1 = "hello kisskernel";const char* p2 = "hello kisskernel";cout << compare(p1, p2) << endl;return 0;
}

这时使用模板生成的比较函数，比较的是地址，而不是字符串，所以就需要模板的特化来解决这种特殊情况。
这里有两种解决方案：
1.直接写一个重载函数，对于特殊情况完成特殊处理（推荐使用）。
2.将函数模板根据特殊情况进行特化，也叫做专用化，实际也是自己写一个函数。
并且比写一个重载函数还要复杂，所以一般推荐使用第一种方式解决。

1.重载

bool compare(char* x,char* y)
{return strcmp(x, y) == 0;
}
bool compare(const char* x, const char* y)
{return strcmp(x, y) == 0;
}

针对上面的arr1/arr2类型char重载一个函数，针对const char又重载了一个函数。

2.模板特化

//针对char*类型的参数
template<>
int compare<char*>(char* const& left, char* const& right)
{cout << "compare<char*>" << endl;return strcmp(left, right);
}
//针对const char* 的两种特化方式
template<>
int compare<const char*>(const char* const& left, const char* const& right)
{cout << "compare<const char*>" << endl;return strcmp(left, right);
}
//template < >
//int compare(const char* const& left, const char* const& right)
//{
//	cout << "in special template< >..." << std::endl;
//
//	return strcmp(left, right);
//}

因为C++的函数模板的特化规则过于诡异，很容易就会出现奇怪的报错。
比如下面这句报错：
error C2912: 显式专用化；“int compare<const char*>(const char ,const char )”不是函数模板的专用化
这种错误，不同的时将括号内的参数类型换一下，这些都是因为特化的函数模板没有和基础模板的参数完全相同。
所以这里详细讲解一下特化方式。
函数模板步骤
1.首先必须要有一个基础模板，也即是通用的模板
2.特化的时候template后面必须有尖括号<>
3. 函数形参表: 必须要和模板函数的基础参数类型完全相同
**注意：如果基础的模板参数带有const，比如上面代码通用模板的类型时const T&，我们特化出来的类型目的是将T替换，但是这时候特化后的T应该写在cosnt &的前面不然就会报错。因为如果T指针类型如int，那么const修饰的意义就变了，如果不改变T位置就是：const int& left，const从修饰&变成了修饰指针。之前是a指向的对象不能改变，现在变成int不能改变了，所以要将T改变到const之前，不改变const的修饰意义。intconst &

如果基础模板的参数没有const那就无所谓了，但是如果参数时引用，那么特化后的参数也必须时引用。
下面代码简单演示：

template <class T>
int compare(T& left, T& right)
{std::cout << "in template<class T>..." << std::endl;return strcmp(left, right);
}template<>
int compare<char*>(char*& left, char*& right)
{return 0;
}
template<>
int compare<const char*>(const char*& left, const char*& right)
{return 0;
}

类模板的特化

类模板的特化分为全特化和偏特化。

1.全特化

顾名思义就是将模板参数全部确定化。

template<class T1,class T2>
class Date
{
public:Date(){cout << "template<class T1,class T2>" << endl;}
private:int _year;int _month;int _day;
};template<>
class Date<int,char>
{
public:Date(){cout << "Date<int,char>" << endl;}
private:int _year;int _month;int _day;
};

模板全特化这里就时根据特殊情况来实例化一个类完成特殊化处理。

2.偏特化

偏特化有的书上也叫做半特化，但是很少这样叫。
偏特化就是针对模板参数进行一些限制处理。

template<class T1, class T2,class T3>
class Date
{
public:Date(){cout << "template<class T1,class T2>" << endl;}
private:int _year;int _month;int _day;
};
template<class T1,class T2>
class Date<T1, T2, char>
{
public:Date(){cout << "Date<int,char>" << endl;}
private:int _year;int _month;int _day;
};template<class T1>
class Date<T1, char,int>
{
public:Date(){cout << "Date<int,char>" << endl;}
private:int _year;int _month;int _day;
};

比如这里三个模板参数，可以设置一个参数特化，或者时两个参数特化，但是必须是从右向左，且必须是连续的。这点类似于缺省参数。

偏特化除了限定参数为int，double等等之外还可以限定参数的类型，比如限定为T*或者是T&等。

template<class T1, class T2,class T3>
class Date
{
public:Date(){cout << "template<class T1,class T2>" << endl;}
private:int _year;int _month;int _day;
};template<class T1, class T2, class T3>
class Date<T1*,T2*,T3&>
{
public:Date(){cout << "template<class T1,class T2>" << endl;}
private:int _year;int _month;int _day;
};

比如这种就是模板限定了参数的类型。进行了更进一步的限制。

模板的分离编译

模板之前就说过是不支持分离编译的，会报出链接错误，分离编译的意思就是（声明在.h文件，定义的.cpp文件中）首先先讲为什么要进行分离编译呢？分离编译的优点是：便于维护并且可以增强工程代码的可读性。因为函数的声明，和类的框架都在头文件中。如果只需要了解一下大体框架只需要看头文件就可以了解了。细节内容就可以去cpp文件中查看。

模板为什么不支持分离编译

首先需要了解编译链接的过程，程序要经过预处理，编译，汇编，链接四个过程最后形成可执行文件。模板需要在编译之前推导出T的具体类型，然后实例化出具体的代码，然后再将实例化的代码编译为指令。

但是模板分离编译的时候cpp文件时分开编译的，在最后链接之前互相是独立的。所有此时模板不能推导出T的具体类型就不会实例化出具体代码。但是因为.h文件中包含函数的声明，所以main.cpp调用的地方可以走到链接，在链接的时候去找具体实现，此时因为找不到就会爆出链接错误。因此模板不支持分离编译。

解决方法：

1. 将定义和实现都放在.h文件中。
2. 模板显式实例化，在实现定义的cpp文件中显示指定T的类型。

template
class Test<int>template
void Func<int>(int a, int b)