C++模板语法和原理

最新推荐文章于 2024-05-24 06:49:35 发布

伞兵一号ahui

最新推荐文章于 2024-05-24 06:49:35 发布

阅读量300

点赞数

文章标签： c++ java 算法

本文链接：https://blog.csdn.net/ahui_is_so_cool/article/details/127819109

版权

为什么要有模板

模板(Template)指的是C++程序设计语言中采用类型作为参数的程序设计,支持通用程序设计。 C++的标准库的函数大多结合了模板的概念，如STL以及IO Stream。模板是C++支持参数化多态的工具，使用模板可以使编译器自动推导内部参数的类型，具有提高代码复用性，提高开发效率的特点。模板通常有两种形式：函数模板和类模板 函数模板针对仅此参数类型不同的函数如 swap 类模板针对仅数据成员和成员函数类型不同的类如 stack

上面是模板的定义，那么为什么模板可以做到呢，总不能是你说有他就有吧，证据呢？

我们先不急得在这里体现为什么需要有类模板，我相信大家看完本文后，自然会明白为何要有模板，定义中的特点体现在哪里

函数模板

函数模板语法

以swap函数为例

template<class T>
void swap(T& a, T& b)
{
    T tmp = a;
    a = b;
    b = a;
}

其中template和class是关键字，class可以用typename关键字代替，在这里class和typename没有任何区别，<>括号中的参数叫做模板形参，此处一般用 T 或 Ty，用户可以自己起名，模板形参不能为空，并且可以有多个形参。

在调用swap函数时，如果用户没有指定，系统会根据使用自动推导T的类型，而不会发生隐士类型转换。

例如以下代码

#include <iostream>
using std::cout;
using std::endl;

template<class T>
void swap(T& a, T& b)
{
    T tmp = a;
    a = b;
    b = a;
    if (typeid(T) == typeid(int))
    {
        cout << "T is int" << endl;
    }
    else if(typeid(T) == typeid(double))
    {
        cout << "T is double" << endl;
    }
    else
    {
        cout << "T is not int or double" << endl;
    }
}

int main()
{
    double d1 = 11.1;
    double d2 = 22.2;
    int i1 = 10;
    int i2 = 20;
    swap(d1, d2);

    swap(i1, i2);

    return 0;
}

此处d1,d2都是double类型，所以T是double，i1，i2都是int类型所以T是int

如果此时对d1和i1进行交换则会报错

编译器报错：没有与参数列表匹配的函数模板实例，因为他的参数一个是int，一个是double，编译器无法根据参数的类型推导出T的类型，但我们可以给T一个类型具体指定我们需要调用的函数

例如：

而当我们指定T为double时，编译器依然报错，无法将参数2从int转换位T&,此时我们知道这个T就是double

所以编译器报的错误应当是无法将int转换位double&，当然这是肯定的，因为int在向double转换时会进行数据的提升，也就是int转换的double是一个临时变量，是一个常量，必须用const进行修饰，我们对其进行以下修改

此时编译器报错无法给a，b常量赋值，这是很正常的，因为const修饰的变量不能修改其存储的值，但我们看到函数调用时，已经可以匹配到具体的函数了，这就说明我们可以显示的指定具体调用的函数。

多模板形参的函数模板

上面我们说了函数模板可以有多个参数，那么我们可否通过多个参数来实现上面的代码呢？

答案是可以的，上面swap不能执行的原因就是因为T无法被正确推导，或指定后进行转换的参数变为常量无法被修改，那么我们就可以使用两个模板参数来解决这个问题

#include <iostream>
using std::cout;
using std::endl;

template<class T1, class T2>
void swap(T1& a, T2& b)
{
    T1 tmp = a;
    a = b;
    b = tmp;
}

int main()
{
    double d1 = 11.1;
    double d2 = 22.2;
    int i1 = 10;
    int i2 = 20;
    swap(d1, i1);
    cout << i1 << " " << d1;
    return 0;
}

我们可以看到此处的程序运行出了我们想看到的结果，将11.1赋值给int类型的变量由于数据截断，导致小数位丢失。

虽然这个可以解决我们所遇到的问题，但我们最好还是不要这样写代码，因为将两个不同类型的数据进行交换本身就是不合理的。

类模板

为什么要有类模板

上面我们说完了函数模板，接下来我们来说说类模板

看完了上面的函数模板，我相信大家也知道如何去写类模板了

我们以一个链表为例

template<class T>
class List
{
  T _data;
  List* _next;
  //.....
};

可以看到该类我只写了它的一些属性，我将其数据域部分指定为T类型，这样就可以使我们的链表存储应用的更广泛，并且不用进行修改，为了方便理解，下面给出不使用类模板的两种写法

typename int DataType;
class List
{
    DataType _data;
    List* _next;
    //...
};

class List
{
    void* _data;
    List* _next;
}

我们可以看到如果我们不是用类模板可以通过typedef来给变量重命名来间接的达到复用的特征，但在每次的DataType不同时，我们还需要修改DataType的类型，不方便，而且如果在一个代码中出现了一个字符链表和一个整数链表，我们就没有任何办法，只能将原链表拷一份，修改名字才能使用。

而第二种办法虽然不用修改类型，在面对不同数据时也不需要多拷几份修改，但我们却需要根据不同的类型写出对应的数据处理的回调函数，否则这个链表将无法解析我们的数据。

使用类模板

大家看完上面之后应该对于类模板的定义有了了解，但是他是如何使用的呢？是跟我们的模板函数的用法相同还是有所区别呢？

接下来我就带大家看一下类模板是如何使用的

#include <iostream>
using std::cout;
using std::endl;

template<class T>
class List
{
private:
    T _data;
    List* _next;
public:
    List(const T& data = { 0 }, List* next = nullptr) :_data(data), _next(next)
    {
    }
    void push_back(const T& val)
    {
        List* tmp = this;
        while (tmp->_next != nullptr)
        {
            tmp = tmp->_next;
        }
        tmp->_next = new List(val);
    }
    void push_front(const T& val)
    {
        List* tmp = _next;
        _next = new List(val);
        _next->_next = tmp;
    }
    void show()
    {
        List* tmp = _next;
        while (tmp != nullptr)
        {
            cout << tmp->_data << " ";
            tmp = tmp->_next;
        }
        cout << endl;
    }
};

int main()
{
    List<int> l1;
    l1.push_back(1);
    l1.push_front(2);
    l1.show();
    return 0;
}

我们可以看到，我们在创建对应的对象时需要显示的指定其中T的类型，而如果我们不指定T的类型，则会报以下错误