C++笔记打卡第15天（函数模版）

1.模版

• 模版不可以直接使用，它只是一个框架
• 模版并不是万能的
• C++另一种编程思想称为泛型编程，主要利用的技术就是模版
• C++提供两种模版机制：函数模版和类模版

2.函数模版

• 作用：建立一个通用函数，函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来表示。
• 语法：template(typename T)
• 解释：template—声明创建模版，typename—表明其后面的符号是一种数据类型，可以用class代替，T—通用的数据类型，名称可以替换，通常为大写字母

void swapInt(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

void swapFloat(float &a, float &b)
{
    float temp = a;
    a = b;
    b = temp;
}

// 创建模版
template<typename T>  // 声明一个模版，且T是一个通用的数据类型
void mySwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

void test01()
{
    int a = 10;
    int b = 20;
    // swapInt(a,b);
    // 两种方式使用函数模版

    // 1.自动类型推导
    mySwap(a, b);
    // 2.显示指定类型
    mySwap<int>(a, b);

    cout << a << endl;
    cout << b << endl;
}

1.函数模版利用关键字template

2.使用函数模版有两种方式：自动类型推导、显示指定类型

3.模版的目的是为了提高复用性，将类型参数化

3.函数模版注意事项

• 自动类型推导，必须推导出一致的数据类型T，才可以使用
• 模版必须确定出T的数据类型，才可以使用

// 创建模版
template<class T>  // 声明一个模版，且T是一个通用的数据类型
void mySwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
void test01()
{
    int a = 10;
    int b = 20;
    char c ='c';
    // mySwap(a, c); // 错误，推导不出一致的T类型
}

template<class T>
void fun()
{
    cout << "func调用" << endl;
}
void test02()
{
    //fun(); // 错误，模版必须确定出T的数据类型，才可以使用
    fun<int>();
}

4.函数模版案例

• 利用函数模版封装一个排序的函数，可以对不同数据类型数组进行排序
• 排序规则从大到小，排序算法为选择排序
• 分别利用char数组和int数组进行测试

template<class T> 
void Swap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

// 对数组进行排序
template<class T>  // 声明一个模版，且T是一个通用的数据类型
void Sort(T array[], int len)
{
    for(int i=0; i<len; i++)
    {
        int max = i;
        for (int j=i; j<len ; j++)
        {
            if(array[max]<array[j])
            {
                max = j;
            }
        }
        if(max != i)
        {
            Swap(array[i], array[max]);  // ????
        }
    }
}

template<class T>
void printArray(T array[], int len)
{
    for(int i=0; i<len; i++)
    {
        cout << array[i] << " ";
    }
    cout << endl;
}

void test01()
{
    char charArray[] = "badcfe";
    int len = sizeof(charArray) / sizeof(char);
    Sort<char>(charArray, len);
    printArray<char>(charArray, len);
}

void test02()
{
    int intArray[] = {7,5,8,6,3,4};
    int len = sizeof(intArray) / sizeof(int);
    Sort<int>(intArray, len);
    printArray<int>(intArray, len);
}

5.普通函数和函数模版的区别

• 普通函数调用时可以发生隐式类型转换
• 函数模版调用时，如果利用自动类型推导，不会发生隐式类型转换
• 如果利用显示指定类型的方式，可以发生隐式类型转换

int Add01(int a, int b)
{
    return a + b;
}

template<class T>
T Add02(T a, T b)
{
    return a + b;
}

void test01()
{
   int a = 10;
   int b = 20;
   char c = 'c';  
   cout << Add01(a,c) << endl;  // 普通函数里，字符型'c'可以隐式转换为整型，ASCII码为99

   // 自动类型推导
   cout << Add02(a,c) << endl; // 错误，函数模版调用时，如果利用自动类型推导，不会发生隐式类型转换

   // 显示指定类型
   cout << Add02<int>(a,c) << endl; // 正确，利用显示指定类型的方式，可以发生隐式类型转换
}

建议使用显示指定类型的方式，调用函数模版，因为自己可以确定通用类型T

6.普通函数和函数模版的调用规则

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

void Print(int a, int b)
{
    cout << "调用的是普通函数" << endl;
}

template<class T>
void Print(T a, T b)
{
    cout << "调用的是函数模版" << endl;
}

template<class T>
void Print(T a, T b, T c)
{
    cout << "调用的是重载函数模版" << endl;
}

void test01()
{
   int a = 10;
   int b = 20;
   Print(a, b);  // 1.函数模板和普通函数都可以实现时，优先调用普通函数

   // 2.通过 空模板 参数列表来强制调用函数模板
   Print<>(a, b);
   // 3.函数模板也可以发生重载
   Print(a, b, 100);  // 重载函数模版
   // 4.如果函数模板可以产生更好的匹配，优先调用函数模板
   char c1 = 'a';
   char c2 = 'b';
   Print(c1, c2); // 函数模版
}

7.模版的局限性

• 模版并不是通用的（对自定义数据类型无效）
• 为了解决这种问题，提供模版的重载，C++可以为这些特定的类型提供具体化的模版

class Person
{
public:
    Person(string name, int age)
    {
        m_name = name;
        m_Age = age;
    }
    int m_Age;
    string m_name;
};

// 判断两个数据是否相等
template<class T>
bool Compare(T &a, T &b)
{
    if (a == b)
    {
        return true;
    }
    else
    {
        return false;
    }
}

// 利用具体化Person的版本来实现代码，这种具体化会优先调用
template<> bool Compare(Person &p1, Person &p2)
{
    if (p1.m_name == p2.m_name && p1.m_Age == p2.m_Age)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void test01()
{
   int a = 10;
   int b = 20;
   bool res = Compare(a, b);
   cout << res << endl;
}

void test02()
{
    Person p1("Tom", 10);
    Person p2("Tom", 10);
    bool res = Compare(p1, p2);  // 走具体化的代码
    cout << res << endl;
}

利用具体化的模版，可以解决自定义类型的通用化

学习模版并不是为了写模版，而是在STL能够运用系统提供的模版