C++ 模板、泛型

1. 模板(泛型)的使用

// 1.函数模板
//template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
template<class T> // 也可以把typename 用class 替换

void mySwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

int main(int argc, const char * argv[]) {
    int a = 10;
    int b = 20;
    // 1. 自动类型推导
//    mySwap(a, b);
    
    // 2. 显示指定类型
    mySwap<int>(a, b);
    
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}

2. 模板函数注意事项

1. 自动类型推导中，必须推导出一致的数据类型T才可以使用
2. 模板必须要确定出T的数据类型，才可以使用

3. 排序模板

// 1.函数模板
//template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
template<class T> // 也可以把typename 用class 替换
void mySwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}


// 排序模板
template<class T>
void mySort(T arr[], int len)
{
    for (int i = 0; i < len; i++) {
        int max = i;
        for (int j = i + 1; j < len; j++)
        {
            if (arr[max] < arr[j])
            {
                max = j;
            }
        }
        if (max != i)
        {
            mySwap(arr[max],arr[i]);
        }
    }
}

// 打印模板
template<class T>
void printArr(T arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test01()
{
    char charArr[] = "bacdegjlak";
    int len = sizeof(charArr) / sizeof(char);
    mySort(charArr, len);
    printArr(charArr, len);
}
int main(int argc, const char * argv[]) {
    test01(); // 输出：l k j g e d c b a a 
}

3. 普通函数可以自动发生隐式类型转换

int myAdd(int a, int b) // 普通函数可以发生隐式类型转换
{
    return a + b;
}

int main(int argc, const char * argv[]) {
    int a = 10;
    int b = 20;
    char c = 'a';
    int res = myAdd(a,c);
    cout << "res == " << res << endl; // 输出107  a 对应ASSIC码97
}

4. 普通函数与函数模板的调用规则

• 调用规则如下：

  1. 如果函数模板和普通函数都可以实现，优先调用普通函数
  2. 可以通过空模板参数列表来强制调用函数模板
  3. 函数模板也可以发生重载
  4. 如果函数模板可以产生更好的匹配，优先调用函数模板

• 验证1: 如果函数模板和普通函数都可以实现，优先调用普通函数

void testRule01(int a, int b)
{
    cout << "普通函数" << endl;
}

template<class T>
void testRule01(T a, T b)
{
    cout << "模板函数" << endl;
}

int main(int argc, const char * argv[]) {
    int a = 0, b = 1;
    testRule01(a, b); // 打印结果： 普通函数
}

• 验证2: 可以通过空模板参数列表来强制调用函数模板

void testRule01(int a, int b)
{
    cout << "普通函数" << endl;
}

template<class T>
void testRule01(T a, T b)
{
    cout << "模板函数" << endl;
}

int main(int argc, const char * argv[]) {
    int a = 0, b = 1;
//    testRule01(a, b); // 打印结果： 普通函数
    testRule01<>(a, b); // 打印结果： 模板函数
}

• 验证3: 函数模板也可以发生重载

void testRule01(int a, int b)
{
    cout << "普通函数" << endl;
}

template<class T>
void testRule01(T a, T b)
{
    cout << "模板函数" << endl;
}

template<class T>
void testRule01(T a,T b, T c)
{
    cout << "重载模板函数" << endl;
}

int main(int argc, const char * argv[]) {
    int a = 0, b = 1, c = 2;
//    testRule01(a, b); // 打印结果： 普通函数
//    testRule01<>(a, b); // 打印结果： 模板函数
    testRule01(a, b, c); // 打印结果： 模重载模板函数
}

• 验证4: 如果函数模板可以产生更好的匹配，优先调用函数模板

void testRule01(int a, int b)
{
    cout << "普通函数" << endl;
}

template<class T>
void testRule01(T a, T b)
{
    cout << "模板函数" << endl;
}

template<class T>
void testRule01(T a,T b, T c)
{
    cout << "重载模板函数" << endl;
}

int main(int argc, const char * argv[]) {
    int a = 0, b = 1, c = 2;
//    testRule01(a, b); // 打印结果： 普通函数
//    testRule01<>(a, b); // 打印结果： 模板函数
//    testRule01(a, b, c); // 打印结果： 模重载模板函数
    char d = 'a', e = 'b';
    testRule01(d, e); // // 打印结果： 模板函数
}

5. 模板的知识补充

1. 模板的局限性

// 模板的局限性
// 模板不是万能的
// 例如
template<class T>
bool mycompare(T &a, T &b)
{
//    a = b; //  在这里的赋值操作中，如果传入的a和b是一个数组，就无法实现了
    if (a == b) // 在这里，如果a 和 b 是一个Person对象，对象没有重写 == 比较符，也无法正常运行
    {
        cout << "两者相等" << endl;
        return true;
    }
    else
    {
        cout << "不等" << endl;
        return false;
    }
}
// 因此C++ 为了解决这种问题，提供模板的重载，可以为这些特定类型提供具体化的模板
template<> bool mycompare(Person &a, Person &b)
{
    if (a.age == b.age)
    {
        cout << "ab两者相等" << endl;
        return true;
    }
    else
    {
        cout << "ab不等" << endl;
        return false;
    }
}

int main(int argc, const char * argv[]) {
    Person p1("a", 10);
    Person p2("b", 20);
    mycompare(p1, p2); // 打印：ab不等
    return 0;
}

2. 类模板基本语法

// 类模板
template<class NameType, class AgeType>
class Person
{
public:
    Person(NameType a, AgeType b)
    {
        name = a;
        age = b;
    }
    
    void showPerson()
    {
        cout << "name: " << name << endl;
        cout << "age: " << age << endl;
    }
    
    NameType name;
    AgeType age;
};

void test01()
{
    Person<string, int> p1("张三", 18);
    Person<int, double> p2(1, 0.5);
    
    p1.showPerson();
    p2.showPerson();
}

int main(int argc, const char * argv[]) {
    
    test01();
    
    return 0;
}

3. 类模板与函数模板的区别

4. 类模板中成员函数创建时机

5. 类模板对象做函数参数

6. 类模板与继承

7. 类模板成员函数类外实现

8. 类模板分文件编写

9. 类模板与友元

10. 类模板案例-数组类封装