模板进阶详解

小灵蛇

发布于 2024-06-06 21:28:17

670

发布于 2024-06-06 21:28:17

文章被收录于专栏：文章部文章部

一.非类型模板参数：

模板参数分为类型形参和非类型形参，非类型形参就是将一个常量作为模板形参，将该参数当做常量来用。

注意：

（1）字符串，浮点数，类对象是不能作为非类型模板参数的

（2）非类型的模板参数必须在编译期间就能确认结果

二.模板的特化

1.概念

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

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

// 函数模板 -- 参数匹配

template<class T>

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

int main()
{
 cout << Less(1, 2) << endl; // 可以比较，结果正确

 
 Date d1(2022, 7, 7);
 Date d2(2022, 7, 8);
 cout << Less(d1, d2) << endl; // 可以比较，结果正确

 
 Date* p1 = &d1;
 Date* p2 = &d2;
 cout << Less(p1, p2) << endl; // 可以比较，结果错误

 
 return 0;
}

可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

2.函数模板的特化：

步骤：

（1）必须有一个基础的函数模板

（2）template后面接一个空的<>

（3）函数名后面跟着一个<>,里面装要特化的具体类型

（4）特化的函数参数列表必须跟模板函数的基础参数类型完全一样。

3.类模板的特化：

（1）全特化

将参数列表中的参数全部确定化

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;
}

（2）偏特化

（a）将模板参数列表一部分确定下来

//将第二个参数特化为int
template <class T1> 
class Data<T1, int>
{
public:
  Data()
  {
    cout<<"Data" <<endl;
  }
private:
  T1 _d1;
  int _d2;
};

（b）参数更进一步的限制

//两个参数偏特化为指针类型 
template <typename T1, typename T2> 
class Data <T1*, T2*> 
{ 
public:
 Data()
 {
   cout<<"Data" <<endl;
 }
 
private:
 T1 _d1;
 T2 _d2; }; 
//两个参数偏特化为引用类型 
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:
        const T1& _d1;
        const T2& _d2;            
}

4.结合顺序

全特化>偏特化>原模板

template<class T1,class T2>
class Data
{
public:
	Data()
	{
		cout << "Date<T1,T2>" << endl;
	}
};
//全特化
template<>
class Data<int, char>
{
public:
	Data()
	{
		cout << "Date<int,char>" << endl;
	}
private:
	int _a1;
	char _a2;
};

template<>
class Data<int, int>
{
public:
	Data()
	{
		cout << "Date<int,int>" << endl;
	}
private:
	int _a1;
	int _a2;
};

//偏特化1：特化部分参数
template<class T1>
class Data<T1, int>
{
public:
	Data()
	{
		cout << "Date<T1,int>" << endl;
	}
private:
	T1 _a1;
	int _a2;
};

//偏特化2：对参数类型进行一定限制，比如：限制是指针或引用等
template<class T1,class T2>
class Data<T1*, T2*>
{
public:
	Data()
	{
		cout << "Date<T1*,T2*>" << endl;
	}
private:
	T1* _a1;
	T2* _a2;
};
//两个参数偏特化为引用类型
template<typename T1,typename T2>
class Data<T1&, T2*>
{
public:
	Data()
	{
		cout << "Date<T1&,T2*>" << endl;
	}
};
int main()
{
	Data<int, int> d1;
	Data<int, char> d2;
	Data<char, int> d3;

	Data<char*, int*> d4;
	Data<int*, int*> d5;
	Data<int&, int*> d6;
	Data<int*, int&> d7;

	return 0;
}

运行结果：

三.模板分离编译

1.概念

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

2.模板的分离编译

// Add.h

template<class T>

T Add(const T& left, const T& right);
 

// Add.cpp
template<class T>

T Add(const T& left, const T& right)
{
 return left + right;
}
 

// main.cpp

#include"a.h"

int main()
{
 Add(1, 2);
 Add(1.0, 2.0);
 
 return 0;
}

运行结果：

究其原因是啥呢？

其实就是在cpp文件中，当调用Add函数时并没有找到对Add函数模板的实例化，那为啥找不到呢？

1.那是因为函数模板其实并不是函数，他不会占用内存，最终生成的函数才会占用内存，所以在编译过程中，编译器会参考模板来生成函数。 2.回到这个问题，在main.cpp中，编译器会去找Add(int,int)的定义，但是在Add.h中只找到了模板函数的声明，却没找到定义，这时，编译器会记录一下，会在后面链接时再尝试去找，但是在Add.cpp中找时，并没有找到Add(int,int)的定义，只有一个未实例化的模板定义，这样就出现了最终的链接错误。