模板类与函数

#include<iostream>

template <class T1,class T2>
class A
{
public:
    T1 i;
    T2 t;
    A()
    {
        std::cout << "模板A类无参枸造" << std::endl;
    }
    A(T1 i,T2 t) :i(i),t(t)
    {
        std::cout << "模板A类->" << i +t<< std::endl;
    }

    void print()
    {
        std::cout << "模板A类print->" <<  i + t << std::endl;
    }

    void operator()(void)
    {
        std::cout << "模板A类()重载" << std::endl;
    }
};

//一个普通函数 的返回值和形参 都为一个模板类 的具体化版本 
//优先级别是最高
A<int,int>& func(A<int,int>& i) //A<int,int> 为模板类的实际类型
{
    std::cout << "模板类 的具体化版本 ->"<< std::endl;
    i.print();
    return i;
}

//一个普通函数 的返回值和形参 都为一个模板类的完全板板化版本 
//和定义一个模板函数一样 要把这个普通函数 添加一个和模板类一样的模板声时
//模板函数 关键字<typename>
//优先级次之
template <typename T1,typename T2>
A<T1, T2>& func(A<T1, T2>& i)
{
    std::cout << "模板类 的模板化版本 ->" << std::endl;
    i.print();
    return i;
}

//这里实际可以把类看成一个对像 只需要一个模板参数就行了
//优先级最低  但是推荐用此版本 因为他灵活通用 不光可以调用类 还可以调用普通函数
template <typename T>
T& func(T& i)
{
    std::cout << "模板类 的通用化版本 ->" << std::endl;
    i();  
    return i;
}

void print()
{
    std::cout << "普通函数PRINT" << std::endl;
}

int main()
{
    //先创建一个A<INT> 对象
    //这里调用具体化版本 优先级别是最高
    A<int,int> a1(10,10); 
    func(a1);
    //这里调用模板化版本 优先级次之 如果释掉 模板化定义 这里将会调用通用化版本 也说明通用化版本优先级别最低
    A<char, char> a2(10, 10);
    func(a2);

    //这里将普通函数通过模板传送给FUNC
    func(print);
    return 0;
}