C++模板进阶

1.非类型模板参数

模板参数分类类型形参与非类型形参。

类型形参即：出现在模板参数列表中，跟在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 N; }
        bool empty()const { return 0 == _size; }
    private:
        T _array[N];
        size_t _size;
    };
}

1.非类型模板参数,跟define不同，根据传的参数N不同，可以实例化不同的对象，将事情交给编译器做，不用再写参数N不同的类了 

2.N是常量，不能改变,并且可以添加缺省参数

3.非类型模板参数在c++20之前只支持整形模板参数，c++20之后支持所有内置类型，但是一定不支持自定义类型做模板参数

2.模板特化

先看一段以下代码：

template<class T>
 void PrintVector(const vector<T>& v)
{
    typename vector<T>::const_iterator it= v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        it++;
    }
    cout << endl;
}

对于这段代码，如果第4行不加上typename的话，编译器会报错，原因是在vector<T>这个类下取的可能是静态变量，也可能是类型名，加上typename相当于告诉编译器是类型 

 概念：使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结 果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板,特化分为函数模板特化和类模板特化

函数模板特化：

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

对于日期类的比较，当我们传的参数是实例化的对象的地址时，这时候比较就会出现问题，我们需要针对特殊类型所进行特殊化，以下是针对Date*的特化

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

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

 类模板特化：

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

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

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

偏特化： 

偏特化又有两种实现方式：

1.部分特化：

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

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

2.参数更进一步的限制，即限定参数类型

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

3.模板的分离编译：

 假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义

func.h:

template<class T1,class T2>
void  func(T1 data1, T2 data2);

func.c:

template<class T1, class T2>
void  func(T1 data1, T2 data2)
{
	cout << "void func (T1 data1,T2 data2)" << endl;
}

 test.c

int main()
{
    func(5,5);
    return 0;
}

其中两个.c文件都包含.h文件，执行后程序会报错

原因是源文件分开编译，在链接过程中出现问题,在func.c编译时没有进行实例化，不会被编译生成指令，进而生成函数地址，而在test.c文件中，进行了实例化，但是只有函数声明，两者进行链接后找不到对应实例化函数的地址，进而报错

解决方法是：1.将声明和定义放到一个.h文件

2.进行显示实例化：

但是不推荐使用，因为需要不断的显示实例化 

template
void func(int data1, int data2);