【C++基础篇】学习C++就看这篇---＞泛型编程之模板

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

void Swap(double& left, double& right)
{
    double temp = left;
    left = right;
    right = temp;
}

void Swap(char& left, char& right)
{
    char temp = left;
    left = right;
    right = temp;
}

template<class T>
template<typename T> //与上述两种方式均可, 模板参数->类型，可以写多个参数根据情况而定
                    //template<typename T1, typename T2,......,typename Tn>

void Swap(T& x1, T& x2)
{
    T x = x1;
    x1 = x2;
    x2 = x//如果此处; 我们不写是不会报错的，因为如果该函数模板 未被实例化，有些编译器是不会对模板内部进行检查的，，但是会对模板的声明做检查
          //即{}或者上面参数部分等描述错误会仍然报错  
}

template<class T>
template<typename T> 
void Swap(T& x1, T& x2)
{
    T x = x1;
    x1 = x2;
    x2 = x;  
}
int main()
{
    int a = 10;
    int b = 20;
    Swap(a, b);
    double c = 1.11;
    double d = 2.21;
    Swap(c, d);
    return 0;
}

template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}
int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Add(a1, a2);//这种就是模板隐式实例化，也就是说是编译器在背后自己推导出类型的
    Add(d1, d2);
    //但如果是这种形式
    //Add(a1, d1);//编译器就无法处理
    // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
    return 0;
}

int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
    Add(a1, (int)d1);
    //或者显式实例化
    Add<int>(a1, d1);// 显式实例化：在函数名后的<>中指定模板参数的实际类型
    return 0;
}

 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
	return left + right;
}

void Test()
{
	Add(1, 2);// 与非模板函数匹配，编译器不需要实例化，也就是说，编译器能调用已经存在的就不会再费劲的去模板实例化
	Add<int>(1, 2);// 调用编译器实例化的Add版本
}

void main()
{
	Add(1, 2);// 与非函数模板类型完全匹配，不需要函数模板实例化
	Add(1, 2.1);// 编译器会优先选择非模板函数int Add(int, int)，而非函数模板。
				//也就是说这要非模板函数能匹配成功，但是这是在模板函数参数不匹配的情况下，我们退其次才选择丢失精度的非模板函数
	            //但如果只要template<class T1， class T2>，Add(T1 left, T2 right)，模板能完全匹配的情况下就不会调用非模板函数
				//即重载决议优先级：完全匹配（模板） > 需要转换的匹配（非模板），编译器优先选择参数类型完全匹配的模板函数
				//编译器会自我判断哪种情况更好
	//模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
}

typedef int StackDataType;
typedef struct Stack
{
    StackDataType* _Array;
    int _top;
    int _capacity;
}Stack; 

template <class T>
class Stack_CPP
{
public:
    Stack_CPP()
    {}
    ~Stack_CPP()
    {}
    void Push(T x)
    {}
private:
    T* _a;
    int _size;
    int _capacity;
};
int main()
{
    Stack_CPP<int> st_cpp_int;//和类实例化的唯一区别就是在类型后面加<模板类型参数>
    st_cpp_int.Push(1);//注意：这里和类实例化没有任何区别，仍然是有两个参数，有个隐含的this指针
    st_cpp_int.Push(2);
    Stack_CPP<double> st_cpp_double;//模板类就可以轻松解决上述问题
    st_cpp_double.Push(1.1);
    st_cpp_double.Push(2.1);
}

template<class T>//只要在类外面定义，每个函数前面都要写template<class T>
void Stack_CPP<T>::push(const T& x)//此时表示域不是Stack_CPP::了，而是Stack_CPP<T>::