C++ 函数模板 类模板

一、泛型编程

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

以下是一段简短的代码，功能实现两个整形之间的交换

// 测试交换
void Swap(int& px, int& py)
{
    int tmp = px;
    px = py;
    py = tmp;
}

这样的交换只能适应一种类型的交换，不能适应多类型的自适应，使用函数重载虽然可以实现，但是有一下几个不好的地方：

1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数,已然无法实现一个函数适应多类型参数

2. 代码的可维护性比较低，一个出错可能所有的重载均出错

在古代有活字印刷术印刷批量相同的汉字，现在也有打印机了，也有茶具模板，只需提供一个模板就可以复刻出外观性状一样的茶具了。

那么有没有什么方法，可以告诉编译器一个模子，让编译器代替我们去生成参数不同的对应的重载函数的代码呢？答案肯定是有的。那就是模板

模板分为函数模板与类模板

一、 函数模板

函数模板概念：

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

函数模板格式：

template<typename T1, typename T2……typename Tn> //typename也可以换成class，差别不大

返回值类型 函数名 (参数列表) { }

函数模板经历两个过程：模板参数推演-->推演参数实例化

template <typename T>
void Swap(T& px, T& py)
{
    T tmp = px;
    px = py;
    py = tmp;
}
​
int main()
{
    int a = 12, b = 34;
    Swap(a, b);
    char c1 = 'q', c2 = 'p';
    Swap(c1, c2);
    cout << a << b << endl;
    cout << c1 << c2 << endl;
    return 0;
}

当用了函数模板，可以看到只定义了一个Swap函数，而没有单独根据类型再定义多的函数，那么他们用的函数是同一个函数吗？让我们来看一下这段代码的反汇编

可以看到这两个函数的首地址是不相同的，也就是说他们调用的不是同一个函数，而仅仅编译器是通过同一个函数模板生成了不同的函数，就好比同一份内容印刷出了两份相同内容的纸张，但这两张纸本质是不同的纸张，而函数模板也同理。这里实现这种功能的原理就是类型推演，会自适应数据类型。

那么既然能自定义根据参数类型推演形成相应的函数，那么让我们来看以下这4种情况，编译会报错吗？如果不报错，是哪些语句不报错，报错的又是哪些语句呢？

    int a1 = 12, a2 = 13;
    double b1 = 14.11, b2 = 15.11;
    Swap(a1, a2);
    Swap(b1, b2);
    Swap(a1, b1);
    Swap(b2, a1);

可以看到在后两行语句里面出现了错误，出现了类型不明确的错误情况，而之前我们说这类型编译器会类型推演，怎么遇到这种情况就罢工不干了呢？原因是这样的：在该函数里面，只定义了一个类型推演T，而传参过来的却有两种类型，（int，double），那么T一个是用int呢还是double呢？这样编译器就无法智能识别了，就好比你的左手想钓鱼，右手想去爬山，这着实难以实现，就会出现左右互搏，僵持不下的场面。当出现这种场面的时候该怎么解决呢？

实例方法

方法有三种：

// 方法一：两个类型推演  此方法不建议，仅做了解
template <typename T, typename T2>
void Swap(T& px, T2& py)
{
    T tmp = px;
    px = py;
    py = tmp;
}

// 方法二：隐式转换类型（在实参传递过去的时候，会生成中间临时变量，将这个中间临时变量转换成需要的类型即可，就达到了双方类型一直）
// 使用这种方法需要注意的是:函数原型不能使用引用，因为临时变量是个常数，会发生数值上的改变，如果形参处是引用就会造成权限放大
    int a1 = 12, a2 = 13;
    double b1 = 14.11, b2 = 15.11;
    Swap(a1, a2);
    Swap(b1, b2);
    Swap((double)a1, b1);
    Swap((int)b2, a1);

// 方法三：显示转换类型，在函数使用的时候，在函数名后放回用<typeid>写即可
    int a1 = 12, a2 = 13;
    double b1 = 14.11, b2 = 15.11;
    Swap(a1, a2);
    Swap(b1, b2);
    Swap<double> (a1, b1);
    Swap<int> (b2, a1);

模板函数匹配原则

1、一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

那么如果出现了两个函数同名的情况，一个是普通函数，一个是函数模板的这种情况，系统会如何抉择呢？

void Swap(int& px, int& py)
{
    cout << "void Swap(int& px, int& py)" << endl;
    int tmp = px;
    px = py;
    py = tmp;
}
template <typename T>
void Swap(T& px, T& py)
{
    cout << "void Swap(T& px, T& py)" << endl;
    T tmp = px;
    px = py;
    py = tmp;
}

从截图可以看出来，这是选择了普通的函数，那这是为什么呢？说的直白一点：有能直接用的，你不用，是不是傻？还有一句是：前人栽树后人乘凉。编译器也是按照这个原理去执行的，如果提前定义了该类型的函数，那么就会直接使用这个函数，而不会让编译器再去做多余的动作多生成一个同功能函数。

2、对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

// 专门处理int的加法函数
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
    cout << "T1 Add(T1 left, T2 right)" << endl;
    return left + right;
}
void Test5()
{
    Add(1, 2);     // 与非函数模板类型完全匹配，不需要函数模板实例化
    Add(1, 2.0);   // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

二、类模板

template<class T1, class T2, ..., class Tn> 
class 类模板名
{
    // 类内成员定义
};    

注意：在类里面使用模板，类模板的声明与定义也不能分离，此处的分离指的是不能将定义与声明进行分离在不同的文件夹。

这里就以栈来进行举例

​
template<class T>
class Stack
{
public:
    Stack(int capacity = 0)
        :_data(nullptr)
        , _top(0)
        , _capacity(capacity)
    {
        if (capacity > 0)
        {
            _data = new T[capacity];
            _top = 0;
            _capacity = capacity;
        }
    }
    void Push(const T& data)
    {
        assert(_data);
        if (_top == _capacity)
        {
            int _newcapacity = _capacity == 0 ? 4 : _capacity * 2;
            T* tmp = new T[_newcapacity];
            if (_data)
            {
                memcpy(tmp, _data, sizeof(T) * _top);
                delete[] _data;
            }
            cout << "扩容成功" << endl;
            _data = tmp;
            _capacity = _newcapacity;
        }
        _data[_top] = data;
        ++_top;
    }
​
    void Pop()
    {
        assert(_data);
        assert(_top > 0);
​
        --_top;
    }
​
    const T& Top()
    {
        assert(_data);
        assert(_top > 0);
​
        return _data[_top];
    }
    
    int Find(const T& x)
    {
        assert(_data);
        
        for (int i = 0; i < _top; ++i)
        {
            if (_data[i] == x)
            {
                return i;
            }
        }
        return -1;
    }
​
    bool Empty()
    {
        assert(_data);
        return _top == 0;
    }
​
    void print()
    {
        assert(_data);
        for (int i = 0; i < _top; ++i)
            cout << _data[i] << endl;
        cout << endl;
    }
    ~Stack()
    {
        delete[] _data;
        _top = _capacity = 0;
    }
​
private:
    T* _data;
    int _top;
    int _capacity;
};
​
void test(void)
{
    Stack<int> s(4);
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    s.Push(5);
    s.Push(6);
    s.Push(7);
    s.print();
​
    s.Pop();
    s.Pop();
    s.Pop();
    s.print();
​
    cout << " s.Empty()" << s.Empty() << endl;
    s.Push(3);
    s.Push(4);
    s.Push(5);
    cout << " s.Top()" << s.Top() << endl;
    s.Push(3);
    s.Push(4);
    s.Push(5);
    s.print();
​
    cout << " s.Find()" << s.Find(9) << endl;
}