【C++】模板：非类型模板参数、类模板的特化、模板的分离编译

最新推荐文章于 2024-01-17 15:59:18 发布

好像有点东西

最新推荐文章于 2024-01-17 15:59:18 发布

阅读量124

点赞数

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/muyuteacher/article/details/133964308

版权

C++ 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

在之前的学习中，我们简单了解了类模板和函数的格式和实例化，以及模板的原理，现在来更深入学习模板的相关知识：

一、非类型模板参数

1.1 非类型模板参数的介绍

C++中的模板除了可以使用类型参数外，还可以使用非类型参数。

类型参数是指模板参数列表中，定义在class 或typename之后的参数名。
非类型参数是指模板中可以接受常量表达式作为实参的参数，这些参数可以是整数、布尔值、指针或者引用等数据类型。

定义非类型参数的语法格式如下：

template <typename T, int N>
class MyArray {
    // 类模板实现
};

template <typename T, int N = 10>
class MyArray {
    // 类模板实现
};

其中 T 是类型参数，N 是非类型参数。在实例化模板时，需要给这个参数传递一个常量表达式作为参数，例如 myArray<int, 5>。

1.2 常见的非类型参数使用场景

数组长度：可以使用非类型参数指定数组的长度。

template <typename T, int N = 10> //只支持整型
class MyArray {
public:
    MyArray()
    {}
    T& operator[](int i)
    {
        return _arr[i];
    }
    const T& operator[](int i)const
    {
        return _arr[i];
    }
private:
    T _arr[N];
};

void Test1() {
    MyArray<int, 5> a;//N赋值5，若不赋值N就是缺省值10
    for (int i = 0; i < 5; ++i) {
        a[i] = i;
    }
    for (int i = 0; i < 5; ++i) {
        cout << a[i] << " ";
    }
    cout << endl;
}

枚举类型：枚举类型的值被视为常量表达式，因此可以作为非类型参数。

template <typename T, T val>
class MyValue {
public:
    MyValue()
        : _value(val) 
    {}
    T Get() const 
    { 
        return _value; 
    }
private:
    T _value;
};

void Test2() {
    enum class Color { Red, Green, Blue };
    MyValue<Color, Color::Red> v;
    cout << static_cast<int>(v.Get()) << endl; // 输出 0
}

注：

浮点数、类对象以及字符串是不允许作为非类型模板参数的。
非类型的模板参数必须在编译时就能确认结果。

二、模板的特化

2.1 特化的概念

在C++中，模板特化是一种机制，允许为特定的类型或参数提供定制化的实现。当通用的模板无法满足特定类型或参数的需求时，可以使用模板特化来提供特定的实现。

例如我们可以设置一个用来进行小于的函数模板，int、double类型可以很好的运算，但是在其他特殊场景下就可能得到错误的结果，比如比较日期或其他自定类型。

template<class T>
bool Less(T left, T right)
{
    return left < right;
}
void Test2()
{
    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; // 可以比较，结果错误
}

p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

2.2 函数模板的特化

函数模板的特化步骤：

前提：有一个基础的函数模板。
关键字template后面接一对空的尖括号<>。
函数名后跟一对尖括号，尖括号中指定需要特化的类型。
函数形参表必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

//函数模板特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
    return *left < *right;
}

此时 Less(p1, p2) 函数不走模板生成的，而是调用更匹配的特化后的版本。

注：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出，编译器会使用最匹配的版本。

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

使用这种方法实现简单明了，容易书写，可读性也更高，所以对于一些参数类型复杂的函数模板，不建议使用特化，而是使用函数重载。

2.3 类模板的特化

2.3.1 全特化

全特化是指为模板参数列表中所有的参数提供完全特定的实现。

template <class T1, class T2>
class A
{
public:
    A()
    {
        cout << "A<T1, T2>" << endl;
    }
private:
    T1 _t1;
    T2 _t2;
};

template <>
class A<int, char>
{
public:
    A()
    {
        cout << "A<int, char>" << endl;
    }
private:
    int _i1;
    char _c2;
};

void Test3()
{
    A<int, int> a1;
    A<int, char> a2;
}

2.3.2 偏特化

偏特化是指为模板参数列表的一部分参数进一步进行条件限制。

偏特化有以下两种表现方式：

部分特化。将模板参数类表中的一部分参数特化。

template <class T1>
class A<T1, char>
{
public:
    A()
    {
        cout << "A<T1, char>" << endl;
    }
private:
    T1 _t1;
    char _c2;
};

void Test3()
{
    A<int, int> a1;
    A<int, char> a2;
    A<char, char> a3; //打印 A<T1, char>
}

参数更进一步的限制。偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

template <class T1, class T2>
class A<T1*, T2*>
{
public:
    A()
    {
        cout << "A<T1*, T2*>" << endl;
    }
private:
    T1* _t1;
    T2* _t2;
};
template <class T1, class T2>
class A<T1&, T2&>
{
public:
    A(const T1& t1, const T2& t2)
        :_t1(t1)
        ,_t2(t2)
    {
        cout << "A<T1&, T2&>" << endl;
    }
private:
    const T1& _t1;
    const T2& _t2;
};


void Test3()
{
    A<int, int> a1;
    A<int, char> a2;
    A<char, char> a3;

    A<int*, int*> a4;
    A<int&, int&> a5(5, 5);
}

注：

模板特化只能在命名空间范围内进行，而不能在函数内部进行。
模板特化可以与模板重载结合使用，以提供更多的灵活性。
特化应该谨慎使用，因为过多的特化可能导致代码复杂性增加并降低可读性。

2.4 类模板特化实例

#include <vector>
#include <algorithm>

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

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

void Test4()
{
    Date d1(2023, 10, 1);
    Date d2(2023, 10, 2);
    Date d3(2023, 10, 3);
    vector<Date> v1;
    v1.push_back(d1);
    v1.push_back(d2);
    v1.push_back(d3);
    // 可以直接排序，结果是日期升序
    sort(v1.begin(), v1.end(), Less<Date>());
    for (auto x : v1)
    {
        cout << x;
    }
    cout << endl;

    vector<Date*> v2;
    v2.push_back(&d1);
    v2.push_back(&d2);
    v2.push_back(&d3);
    sort(v2.begin(), v2.end(), Less<Date*>());
    for (auto x : v2)
    {
        cout << *x;
    }
}

如果没有对 Date* 的类模板特化，存放地址的 v2 就会按照地址大小排序，无法达到预期结果。特化之后，在运行上述代码，就可以得到正确的结果。

三、模板的分离编译

3.1 分离编译的概念

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。
模板分离编译是将模板的声明和定义分离，以减少编译时间和二进制文件大小。

3.2 模板分离编译的实现

以下代码会出错：a.h 存放模板的声明，a.cpp 存放模板的实现，test.cpp模板实例化。

// a.h
template<class T>
T Add(const T& left, const T& right);

// a.cpp
template<class T>
T Add(const T& left, const T& right)
{
 return left + right;
}

// test.cpp
#include"a.h"
int main()
{
 Add(1, 2);
 Add(1.0, 2.0);
 
 return 0;
}

原因：

C++程序运行需要经历预处理、编译、汇编、链接四个步骤，其中编译时头文件不参与编译，多个源文件分离开单独编译，直到链接时才将多个编译后的文件合并成一个。
由于编译器遇到模板定义时，并不生成实际的函数或类代码，需要一个实例化的过程，所以test.cpp中Add函数的符号表里没有确切的地址，需要连接器调用，链接时a.cpp生成的.obj文件符号表里面也没有Add函数的地址（因为没有实例化），所以链接时报错。
C++编译器为什么不支持类模板的分离式编译_支持类模板编译器-CSDN博客

解决方法：

将声明和定义放到一个文件里面。推荐使用这种。
这样可以确保在使用模板时，编译器可以直接访问到模板的定义，避免了链接错误。
模板定义的位置显式实例化。这种方法不实用，不推荐使用。
// template.h 
template <typename T>
class MyClass {
    // 模板的定义
};

// template.cpp 
template class MyClass<int>;  // 显式实例化 MyClass<int>

// main.cpp
#include "template.h"

int main() {
    MyClass<int> obj;  // 不再进行模板的实例化，而是使用显式实例化的代码
    // ...
    return 0;
}
一个文件取名后缀为.hpp 说明文件里面大概率有模板，且声明和定义在同一个文件