类模板下

类模板可定义多个类型参数

template<typename T1, typename T2>
class Test
{
public:
    void add(T1 a, T2 b)
    {
        cout<<(a + b)<<endl;
    }
};

int main(int argc, char *argv[])
{
    Test<double, int> t;
    t.add(10.0001, 8);
    return EXIT_SUCCESS;
}

结果：18.0001
——————/
类模板可被局部特化（优先选择）
若有俩局部特化都可匹配，则报错

template<typename T1, typename T2>
class Test
{
public:
    void add(T1 a, T2 b)
    {
        cout<<(a + b)<<endl;
    }
};

template<typename T>
class Test<T, int>
{
public:
    void add(T a, int b)
    {
        cout<<"add(T a, int b)"<<endl;
        cout<<a + b<<endl;
    }
};

template<typename T1, typename T2>
class Test<T1*, T2*>
{
public:
    void add(T1* a, T2* b)
    {
        cout<<"add(T1* a, T2* b)"<<endl;
    }
};

int main(int argc, char *argv[])
{
	int i = 0,j=0;
    Test<double, int> t; // <T, int>
    Test<long, long> ti; // <T1, T2>
    Test<int*, int*> tp; // <T*, T*>
    t.add(10.0001, 8);
    ti.add(2, 3);
    tp.add(&i, &j);
    return EXIT_SUCCESS;
}

结果：
add(T a, int b)
18.0001
5
add(T1* a, T2* b)
为什么要特化，而不重新定义类？
特化和重新定义类没本质区别，但若定义新类，则产生一类模板和一新类，使用时需考虑究竟用哪个；而特化可使用统一方式使用…，编译器优先选择特化类
——————/
函数模板和类模板模板参数可以是普通数值

template<typename T, int N>
void func()
{
    T array[N] = {0};
    for(int i = 0; i < N; i++)
    {
        array[i] = i + 1; 
        cout<<array[i]<<" ";
    }
    cout<<endl;
}

int main(int argc, char *argv[])
{
    func<int, 5>();
    func<float, 10>();
    return EXIT_SUCCESS;
}

——————/
非类型模板参数与特化
题：1+2+3+…=？速度最快

template<int N>
class Sum
{
public:
static const int VALUE = Sum<N - 1>::VALUE + N;  //递归迭代思想
//只有static const可在类中赋初值，放入符号表，不分配内存
};

template<>
class Sum<1>  //特化类，避免死循环
{
public:
    static const int VALUE = 1;
};

int main(int argc, char *argv[])
{
    cout<<Sum<100>::VALUE<<endl;  //值编译时已计算好
    return EXIT_SUCCESS;
}

非类型模板参数的限制：
变量、浮点数、类对象、全局指针不能作为模板参数
编译器的推导过程是在编译阶段完成，因此必须依赖于特化类，否则推导过程无法结束
——————/
内存泄漏和内存多次释放常发生于指针使用过程中
解决方案：智能指针
工程中，要求开发者使用预先编写的智能指针类对象代替C原生指针

工程中智能指针是一类模板
通过构造函数申请堆内存
通过析构函数确保堆内存被及时释放
通过重载指针运算符 . 和 -> 模拟指针行为
通过重载比较运算符 == 和 != 模拟指针比较

数组类和智能指针可最大限度避免内存相关bug

#ifndef _SMARTPOINTER_H_
#define _SMARTPOINTER_H_
template<typename T>
class SmartPointer
{
protected:
    T* m_pointer;
public:
    SmartPointer();
    ~SmartPointer();
    SmartPointer(const T* pointer);
    T* operator->();
    T& operator*();
};
#endif
——/
#ifndef _SMARTPOINTER_DEF_H_
#define _SMARTPOINTER_DEF_H_
#include "SmartPointer.h"

template<typename T>
SmartPointer<T>::SmartPointer()
{
    m_pointer = NULL;
}

template<typename T>
SmartPointer<T>::SmartPointer(const T* pointer)
{
    m_pointer = const_cast<T*>(pointer);
}

template<typename T>
SmartPointer<T>::~SmartPointer()
{
    delete m_pointer;
}

template<typename T>
T* SmartPointer<T>::operator->()
{
    return m_pointer;
}

template<typename T>
T& SmartPointer<T>::operator*()
{
    return *m_pointer;    
}    
#endif
——/
class Test
{
public:
    int i;
    void print()
    {
        cout<<i<<endl;
    }
};

int main(int argc, char *argv[])
{
    SmartPointer<int> pi = new int(5);
    SmartPointer<Test> pt = new Test();
    cout<<*pi<<endl;
    *pi = 10;
    cout<<*pi<<endl;
    pt->i = 20;
    pt->print();
    return EXIT_SUCCESS;
}