范型编程

环境：ide：Mac+clion

视频链接：
https://www.bilibili.com/video/BV1Hb411Y7E5?p=5

c++范型编程，利用模版技术：函数模版和类模版

T 通用类型，虚拟类型。
自动类型推导,一致的数据类型才可以使用。
函数声明和定义。typename 可以用class 替换。

//template<typename T>//typename 可以用class 替换
template<class T>
void sheikSwap(T &a,T &b){//自动类型推导,一致的数据类型才可以使用。
    T temp;
    temp = a;
    a = b;
    b = temp;
}

void test(){
    int a = 10;
    int b = 20;
    cout << "swap 前："<<a <<","<<b<<endl;//10  20 
    sheikSwap(a,b);
    cout << "swap 后："<<a <<","<<b<<endl;//20 10
}

1.普通函数和模版函数重载，优先调用普通函数。
2.如果强制调用重载模版类，用空模版空参数列表<>来调用。

void myPrint(string a){
    cout << "普通函数打印调用"<<endl;
}
template<class T>
void myPrint(T a){
    cout << "范型函数打印调用"<<endl;
}

int main()
{
    //test();
    string a = "";
    myPrint(a);//普通函数打印调用
    myPrint<string>(a);//范型函数打印调用，显示制定类型
    myPrint<>(a);//范型函数打印调用，隐士调用。
    return 0;
}

模版的局限性

针对自定义的对象进行判等 等操作，可以通过重载==进行解决。

class Person{
public:
    string m_Name;
    int m_Age;
};

template<class T>
bool myCompare(T &a, T &b) {
    cout << "myCompare 模版 "<<endl;
    if (a == b) {
        return true;
    }
    return false;
}

template<> bool myCompare(Person &p1,Person &p2){
    cout << "myCompare 重新实现"<<endl;
    if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age){
        return true;
    }
    return false;
}
void test() {
    Person p1 ;
    p1.m_Name = "sheik";
    p1.m_Age = 10;
    Person p2 ;
    p2.m_Name = "sheik";
    p2.m_Age = 10;
    cout << myCompare(p1,p2)<<endl;//输出的是1
};

类模版 与 函数模版的区别

类模版没有自动推导功能，只能显示调用。

template<class NameType,class AgeType = int>//类模版,这里可以进行确定类型。也可以不进行确定。类模版独有。
//template<class NameType,class AgeType>//类模版
class Person{
public:
    Person(NameType name,AgeType age){
        this->m_Name = name;
        this->m_Age = age;
    }
    NameType m_Name;
    AgeType m_Age;
};

void test(){
    Person<string,int> person("sheik",20);
    cout << person.m_Name << ","<<person.m_Age<<endl;
}

类的成员函数，类创建的时候，就创建出来了。模版函数是函数调用的时候才创建出来。

class Person1 {
public:
    void showPerson1() {
        cout << "showPerson1 call" << endl;
    }
};


template<class T>
class Person {
public:
    T t;
    Person(T t):t(t){

    }
    void showPerson() {
        t.showPerson1();//这里可以编译通过，只能说是在调用的时候创建。
    }

    void showInfo() {
        cout << "模版类的showInfo()进行调用!" << endl;
    };
};

void test(Person<Person1> &person) {
    person.showPerson();
    person.showInfo();
}

int main() {
    Person1 person1;
    Person<Person1>person(person1);
    test(person);
    return 0;
}

通过参数模版化进行传递,当参数通过范型来传递的时候，可以通过typeid(T).name 来查看T的类型。

template<class T>
void test(Person<T> &p){
    p.showInfo();
    cout << typeid(T).name()<<endl;
}

整个类进行模版化

template<class T>
void test1(T &p){//这里把整个Person 类进行模版
    p.showInfo();
    cout << typeid(T).name()<<endl;
}