#include<iostream>
#include<string>
using namespace std;

/*类模板*/
template<class NameType,class AgeType>
class Teather
{
public:
    Teather(NameType name,AgeType age)
    {
        this->m_age = age;
        this->m_name = name;
    }
    void show()
    {
        cout << "name = " << this->m_name << " "
              << "age = " << this->m_age << endl;
    }
    NameType m_name;
    AgeType m_age;
};

void test_09()
{
    Teather<string,int> teacher("tom",34);
    teacher.show();

}







/*类模板&函数模板 的区别：

1-类模板：没有自动类型推导
2-类模板在模板的参数列表中有默认参数
*/
template<class NameType,class AgeType = int>
class Dog
{
public:

    Dog(NameType name,AgeType age)
    {
        this->m_age = age;
        this->m_name = name;
    }
    void show()
    {
        cout << "name = " << this->m_name << " "
              << "age = " << this->m_age << endl;
    }
    NameType m_name;
    AgeType m_age;
};
void test_10()
{
    //错 无法自动推导 Dog d("tom",223);
    Dog<string,int> d("狗狗A",2);  //正确 只能用 显示指定类型
    d.show();
    Dog<string> f("哮天犬",12);
    f.show();

}







/*类模板的成员函数 特性
调用时才创建
*/
class Cat
{
public:
    void show()
    {
        cout << "cat 1" <<endl;
    }
};
class Cat2
{
public:
    void show2()
    {
        cout << "cat 2" <<endl;
    }
};

template<class T>
class MyClass
{
public:
    T obj;
    // 成员函数 编译时不创建
    void func01()
    {
        obj.show();
    }
    void func02()
    {
        obj.show2();
    }
};
void test_11()
{
    MyClass<Cat>m;//T的类型确定了，成员函数 就创建了
    m.func01();
    //m.func02();
}






/*类模板对象做函数参数

三种形式 传入
    1-指定传入类型
    2-参数模板化
    3-整个类模板化
*/
template<class T1,class T2>
class Person02
{
public:
    Person02(T1 name,T2 age)
    {
        this->m_name = name;
        this->m_age = age;
    }
    void show()
    {
        cout << "name = " << this->m_name << " " << "age = "<< this->m_age <<endl;
    }
    T1 m_name;
    T2 m_age;
};
//1-指定传入类型
void printPerson02(Person02<string,int> &p)
{
    cout << "1-指定传入类型:"<< endl;
    p.show();
}

//2-参数模板化
template<class T1,class T2>
void printPerson03(Person02<T1,T2> &p)
{
    cout << "2-参数模板化:"<<typeid(T1).name() << endl;
    p.show();
}

//3-整个类模板化
template<class T>
void printPerson04(T &p)
{
    cout << "3-整个类模板化:"<<typeid(T).name() << endl;
    p.show();
}
void test_12()
{
    Person02<string,int>p("tom",100);
    printPerson02(p);//1-指定传入类型

    Person02<string,int>p3("pig",34);
    printPerson03(p3);//2-参数模板化

    Person02<string,int>p4("mause",34);
    printPerson04(p4);//3-整个类模板化
}









/*类模板的继承
1-确定类型才能继承
2-灵活继承-子类也是模板
*/
template<class T>
class Base
{
public:

    T m;
};
//class Son :public Base//错误，知道父类数据类型才行
class Son :public Base<int>
{

};

template<class T1,class T2>
class Son02:public Base<T2>
{
public:
    Son02()
    {
        cout << "T1 type: " << typeid(T1).name() <<endl;
        cout << "T2 type: " << typeid(T2).name() <<endl;
    }
    T1 obj;
};
void test_13()
{
    //Son s1;
    //Son02<int,char>s2;

}



/*类模板成员函数的类外实现*/
template<class T1,class T2>
class Fimly
{
public:
    Fimly(T1 name,T2 age);
    //{
    //    this->m_name = name;
    //    this->m_age = age;
    //}
    void show();
    //{
    //    cout << "name = " << this->m_name << " " << "age = "<< this->m_age <<endl;
    //}
    T1 m_name;
    T2 m_age;
};
//构造函数类外实现
template<class T1,class T2>
Fimly<T1,T2>::Fimly(T1 name,T2 age)
{
    this->m_name = name;
    this->m_age = age;
}
//成员函数类外实现
template<class T1,class T2>
void Fimly<T1,T2>::show()
{
    cout << "name = " << this->m_name << " " << "age = "<< this->m_age <<endl;
}
void test_14()
{
    Fimly<string,int> f("tom",2);
    f.show();
}










int main()
{
    test_09();
    test_10();
    test_11();
    test_12();
    test_13();
    test_14();
}