【C++】详解C++的模板

东洛的克莱斯韦克

已于 2024-08-30 18:05:02 修改

阅读量1.2k

点赞数 43

分类专栏： C++ 文章标签： c++ 算法开发语言模板

于 2024-05-14 20:23:50 首次发布

本文链接：https://blog.csdn.net/2301_79796701/article/details/138844019

版权

C++ 专栏收录该内容

23 篇文章 2 订阅

订阅专栏

概念

模板是C++中非常厉害的设计，模板把通用的逻辑剥离出来，让不同的数据类型可以复用同一种模板的逻辑，甚至可以让不同的逻辑复用同一种模板逻辑（仿函数的设计）

【C++】详解STL的适配器容器之一：优先级队列 priority_queue-CSDN博客

模板可以帮助我们实现代码的重用和泛化，提高代码的灵活性和可维护性。

STL的容器就是对模板很好的运用，可参考

【C++】详解STL容器之一的 vector-CSDN博客

【C++】详解STL的容器之一：list-CSDN博客

语法

template <typename T> //可以写成template <class T> 
class MyClass {
    // ...
};

template <typename T> //可以写成template <class T> 
T add(T a, T b) {
    return a + b;
}

在上面的示例中，MyClass 是一个类模板，add 是一个函数模板。通过使用 typename 或 class 关键字声明模板参数，T 就是未知类型

函数模板

通过使用函数模板，我们可以定义一种通用的函数，可以根据实际需要传不同的数据复用函数模板

函数模板的语法格式如下：

template <typename T>
返回类型 函数名(参数列表) {
    // 函数体
}

其中，template关键字表示这是一个函数模板，<typename T>表示定义了一个类型参数T，可以根据需要使用不同的类型来替换T，返回类型表示函数的返回类型，函数名表示函数的名称，参数列表表示函数的参数列表。

在函数模板中，可以使用类型参数T作为函数的参数类型、返回类型或局部变量的类型。例如：

template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

上述代码定义了一个函数模板max，它接受两个参数a和b，这两个参数的类型都是T，并且返回类型也是T

使用函数模板时，需要在函数名后面加上尖括号<>，并在其中指定具体的类型。例如：

int result1 = max<int>(3, 5); // 使用int类型实例化函数模板
double result2 = max<double>(3.14, 2.71); // 使用double类型实例化函数模板

max<int>表示使用`int`类型实例化max函数模板，max<double>表示使用double类型实例化max函数模板。传不同的参数示例化的函数是不同的

函数模板还可以有多个类型参数，可以使用逗号分隔它们。例如：

template <typename T1, typename T2>
void printPair(T1 a, T2 b) {
    cout << "(" << a << ", " << b << ")" << endl;
}

使用函数模板时，需要指定每个类型参数的具体类型。例如：

printPair<int, double>(3, 3.14); // 使用int和double类型实例化函数模板

在上述代码中，printPair<int, double>表示使用int类型和double类型实例化printPair函数模板。

总结起来，函数模板是一种通用的函数定义，可以用于多种不同类型的参数。通过使用函数模板，可以编写一次代码，然后在不同的地方使用不同的数据类型进行调用。

类模板

通过使用类模板，我们可以定义一种通用的类模板，可以根据实际需要在不同场景下传入不同的类型实例化出不同的类。

类模板的语法格式如下：

template <typename T> //可以写成template <class T>
class 类名 {
    // 成员变量和成员函数的定义
};

在类模板中，可以使用类型参数T作为成员变量的类型、成员函数的参数类型或返回类型。例如：

template <typename T>
class Stack {
private:
    T* data;
    int size;
public:
    Stack(int capacity) {
        data = new T[capacity];
        size = 0;
    }
    
    void push(T value) {
        data[size++] = value;
    }
    
    T pop() {
        return data[--size];
    }
};

上述代码定义了一个类模板Stack，它有一个私有成员变量data和size，分别表示存储数据的数组和当前栈的大小。类模板还有两个公有成员函数push和pop，分别用于向栈中压入元素和弹出栈顶元素。

使用类模板时，需要在类名后面加上尖括号<>，并在其中指定具体的类型。例如：

Stack<int> intStack(10); // 使用int类型实例化类模板
Stack<double> doubleStack(5); // 使用double类型实例化类模板

不然会报如下错误

Stack<int>表示使用int类型实例化Stack类模板，Stack<double>表示使用double类型实例化Stack类模板。根据实际的类型参数，编译器会生成相应的类定义。

类模板还可以有多个类型参数，可以使用逗号分隔它们。例如：

template <typename T1, typename T2>
class Pair {
private:
    T1 first;
    T2 second;
public:
    Pair(T1 a, T2 b) {
        first = a;
        second = b;
    }
    
    void print() {
        cout << "(" << first << ", " << second << ")" << endl;
    }
};

使用类模板时，需要指定每个类型参数的具体类型。例如：

Pair<int, double> p1(3, 3.14); // 使用int和double类型实例化类模板
Pair<string, int> p2("Hello", 5); // 使用string和int类型实例化类模板

非类型模板参数

模板参数分为：类型形参与非类型形参

类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称

非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用

// 定义一个模板类型的静态数组
 template<class T, size_t N = 10>
 class array
 {
 public:
 T& operator[](size_t index){return _array[index];}
 const T& operator[](size_t index)const{return _array[index];}
 
 size_t size()const{return _size;}
 bool empty()const{return 0 == _size;}
 
 private:
 T _array[N];
 size_t _size;
 }；

浮点数、类对象以及字符串是不允许作为非类型模板参数的。

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

模板的特化

概念：

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

函数模板特化

必须要先有一个基础的函数模板

关键字 template 后面接一对空的尖括号 <>

函数名后跟一对尖括号，尖括号中指定需要特化的类型

函数形参表 : 必须要和模板函数的基础参数类型完全相同

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
 return left < right;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right) //Date是日期类
{
 return *left < *right;
}

下面是测试

关于日期类小编也写了一篇文章：【C++】如何用C++写一个日期计算器-CSDN博客

类模板特化

全特化

全特化即是将模板参数列表中所有的参数都确定化

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

下面是测试

偏特化

任何针对模版参数进一步进行条件限制设计的特化版本

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

部分特化

特化一部分参数

下面是测试代码

template<class T1, class T2>
class Data
{
public:
 Data() {cout<<"Data<T1, T2>" <<endl;}
private:
 T1 _d1;
 T2 _d2;
};
template <class T1>
class Data<T1, int>
{
public:
 Data() {cout<<"Data<T1, int>" <<endl;}
private:
 T1 _d1;
 int _d2;
};

限制参数

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

下面是测试代码

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