模板与泛型 —— 定义与使用

一、概述

泛型编程是以独立于任何特定类型的方式编写代码。使用泛型编程时，需要提供具体程序实例所操作的类习惯或者值。
模板是泛型编程的基础，模板是创建类或者函数的蓝图或者公式，通过给定蓝图或者公式足够信息，将其真正的转变成具体的类或者函数。这种转变通常发生在编译时。
模板支持将类型作为参数的程序设计方式，从而实现对泛型程序设计的直接支持。（在定义类、函数时，将类型作为参数）

二、函数模板

函数模板的定义

template<typename T>
T Add(T val1, T val2)
{
    T res = val1 + val2;
    return res;
}

<>里面是模板参数列表（模板实参），<>里面至少需要一个模板参数。

函数模板的使用
调用函数模板时，编译器会根据调用函数模板时的实参去推断模板参数列表内的参数（形参）类型。当编译器光凭借函数实参推断不出模板参数时，需要用<>主动提供模板参数。

// 编译器通过调用的实参，推断模板形参类型为 int
int res = Add(1, 2);

// 编译器在推断出模板的形参类型后，实例化了一个特定版本的函数，相当于：
int Add(int val1, int val2)
{
    int res = val1 + val2;
    return res;
}

非类型模板参数
用typename/class 声明的参数，为类型参数。在模板参数列表内，还可以定义非类型参数。非类型参数代表一个数值。非类型参数需要用具体的类型名来声明非类型参数。

// 非类型模板参数定义
template<int S1, int S2>
int Add()
{
    int res = S1 + S2;
    return res;
}

// 非类型模板参数的调用
// 显式指定模板参数
int res = Add<1, 2>();

template<int L1, int L2>
int charscmp(const char(&p1)[L1], const char(&p2)[L2])
{
    return strcmp(p1, p2);
}

// 编译器推断非类型模板参数的值为传入的字符串长度
int res = charscmp("test", "test1");

当模板被实例化时，非类型模板参数的值，可能是调用时指定的，也可能是编译器推断的。
非类型模板参数的值，必须是常量表达式。因为模板实例是在编译器编译时实例化的。
模板的定义并不会使编译器生成代码，只有在具体调用时，编译器实例化一个特定版本的函数，才会生成代码。

二、类模板

概述
可以用类模板实例化一个特定的类。编译器不能为类模板推断模板参数类型，使用类模板必须显式指定模板参数。(比如：vector<int> )
实例化类模板时，必须要有类的全部信息，包括类模板中的成员函数的函数体。所以一般来说，所以类模板信息会放在.h头文件中。
类模板的定义与调用

template<typename T>
class myVector
{
public:
    typedef T* myiterator;  //迭代器

public:
    myVector();
    myVector& operator=(const myVector&);

public:
    myiterator mybegin();
    myiterator myend();

public:
    void myfunc1() // 成员函数体在类模板定义中，被隐式声明为内联函数
    {
        // todo
        return;
    };  
    void myfunc2();
};

// 成员函数体，在类模板定义外
template<typename T>
void myVector<T>::myfunc2()
{
    // todo
    return;
}

template<typename T>
myVector<T>& myVector<T>::operator=(const myVector&) // <T> 表示返回的是一个实例化了的myVector
{
     return *this;
}

int main()
{
  myVector<int> vec;  //调用时，编译器生成具体的类
  return 0;
}

myVector是类模板名，不是一个类名，类模板是用于实例化类用的。
myVector<int> 才是类型名。

类模板的成员函数

类模板成员函数体，写在类模板定义中时，会被隐式声明为inline函数。
类模板的成员函数，具有和这个类模板相同的模板参数。类模板实例化后，模板的不同实例，都有自己版本的成员函数。
类模板实例化时，其成员函数只有在被调用到时，才会被实例化。

非类型模板参数

template<typename T, int size = 10>
class myarray
{
private:
    T arr[size];
public:
    void myfunc();
};

template<typename T, int size>
void myarray<T, size>::myfunc()
{
    // todo
    return;
}

int main()
{
    myarray<int, 100> tmparray1;
    myarray<int> tmparray2;

    return 0
}

非类型模板参数的限制：
(1) 浮点型不能作为非类型模板参数 (double, float)
(2) 类类型不能作为非类型模板参数（非类型一般是基础类型）