函数模板

1.C++模板

1.1 模板概论

c++提供了函数模板(function template.)所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数就成为函数模板。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函数的功能。

• c++提供两种模板机制:函数模板和类模板
• 类属 - 类型参数化，又称参数模板

总结：

l 模板把函数或类要处理的数据类型参数化，表现为参数的多态性，成为类属。

l 模板用于表达逻辑结构相同，但具体数据元素类型不同的数据对象的通用行为。

1.2 函数模板

1.2.1 什么是函数模板？

 

//交换int数据
void SwapInt(int& a,int& b){
    int temp = a;
    a = b;
    b = temp;
}

//交换char数据
void SwapChar(char& a,char& b){
    char temp = a;
    a = b;
    b = temp;
}
//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数
//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度

//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换
//我们有一种技术，可以实现类型的参数化---函数模板


//class 和 typename都是一样的，用哪个都可以
template<class T>
void MySwap(T& a,T& b){
    T temp = a;
    a = b;
    b = temp;
}

void test01(){
    
    int a = 10;
    int b = 20;
    cout << "a:" << a << " b:" << b << endl;
    //1. 这里有个需要注意点，函数模板可以自动推导参数的类型
    MySwap(a,b);
    cout << "a:" << a << " b:" << b << endl;

    char c1 = 'a';
    char c2 = 'b';
    cout << "c1:" << c1 << " c2:" << c2 << endl;
    //2. 函数模板可以自动类型推导，那么也可以显式指定类型
    MySwap<char>(c1, c2);
    cout << "c1:" << c1 << " c2:" << c2 << endl;
}

 

 

用模板是为了实现泛型，可以减轻编程的工作量，增强函数的重用性。

使用函数模板实现对char和int类型数组进行排序？

//选择排序
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 PrintArray(T arr[],int len){
    for (int i = 0; i < len;i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

//模板排序函数
template<class T>
void MySort(T arr[],int len){
    
    for (int i = 0; i < len;i++){
        for (int j = len - 1; j > i;j--){
            if (arr[j] > arr[j - 1]){
                T temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
            }
        }
    }

}

void test(){
    
    //char数组
    char tempChar[] = "aojtifysn";
    int charLen = strlen(tempChar);

    //int数组
    int tempInt[] = {7,4,2,9,8,1};
    int intLen = sizeof(tempInt) / sizeof(int);

    //排序前 打印函数
    PrintArray(tempChar, charLen);
    PrintArray(tempInt, intLen);
    //排序
    MySort(tempChar, charLen);
    MySort(tempInt, intLen);
    //排序后打印
    PrintArray(tempChar, charLen);
    PrintArray(tempInt, intLen);
}

 

1.3 函数模板和普通函数区别

l 函数模板不允许自动类型转化

l 普通函数能够自动进行类型转化

//函数模板
template<class T>
T MyPlus(T a, T b){
    T ret = a + b;
    return ret;
}

//普通函数
int MyPlus(int a,char b){
    int ret = a + b;
    return ret;
}

void test02(){

    int a = 10;
    char b = 'a';

    //调用函数模板，严格匹配类型
    MyPlus(a, a);
    MyPlus(b, b);
    //调用普通函数
    MyPlus(a, b);
    //调用普通函数  普通函数可以隐式类型转换
    MyPlus(b, a);

    //结论：
    //函数模板不允许自动类型转换，必须严格匹配类型
    //普通函数可以进行自动类型转换
}

 

1.4 函数模板和普通函数在一起调用规则

l c++编译器优先考虑普通函数

l 可以通过空模板实参列表的语法限定编译器只能通过模板匹配

l 函数模板可以像普通函数那样可以被重载

l 如果函数模板可以产生一个更好的匹配，那么选择模板

//函数模板
template<class T>
T MyPlus(T a, T b){
    T ret = a + b;
    return ret;
}

//普通函数
int MyPlus(int a, int b){
    int ret = a + b;
    return ret;
}

void test03(){
    int a = 10;
    int b = 20;
    char c = 'a';
    char d = 'b';
    //如果函数模板和普通函数都能匹配，c++编译器优先考虑普通函数
    cout << MyPlus(a, b) << endl;
    //如果我必须要调用函数模板,那么怎么办?
    cout << MyPlus<>(a, b) << endl;
    //此时普通函数也可以匹配，因为普通函数可以自动类型转换
    //但是此时函数模板能够有更好的匹配
    //如果函数模板可以产生一个更好的匹配，那么选择模板
    cout << MyPlus(c,d);
}

//函数模板重载
template<class T>
T MyPlus(T a, T b, T c){
    T ret = a + b + c;
    return ret;
}

void test04(){

    int a = 10;
    int b = 20;
    int c = 30;
    cout << MyPlus(a, b, c) << endl;
    //如果函数模板和普通函数都能匹配，c++编译器优先考虑普通函数
}

 

1.5 模板机制剖析

思考:为什么函数模板可以和普通函数放在一起?c++编译器是如何实现函数模板机制的？

1.5.1编译过程

hello.cpp程序是高级c语言程序，这种程序易于被人读懂。为了在系统上运行hello.c程序，每一条c语句都必须转化为低级的机器指令。然后将这些机器指令打包成可执行目标文件格式，并以二进制形式存储于磁盘中。

预处理(Pre-processing) -> 编译(Compiling) ->汇编(Assembling) -> 链接(Linking)

 

1.5.2 模板实现机制

函数模板机制结论：

l 编译器并不是把函数模板处理成能够处理任何类型的函数

l 函数模板通过具体类型产生不同的函数

l 编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。

1.6模板的局限性

假设有如下模板函数：

template<class T>

void f(T a, T b)

{ … }

如果代码实现时定义了赋值操作 a = b，但是T为数组，这种假设就不成立了

同样，如果里面的语句为判断语句 if(a>b),但T如果是结构体，该假设也不成立，另外如果是传入的数组，数组名为地址，因此它比较的是地址，而这也不是我们所希望的操作。

总之，编写的模板函数很可能无法处理某些类型，另一方面，有时候通用化是有意义的，但C++语法不允许这样做。为了解决这种问题，可以提供模板的重载，为这些特定的类型提供具体化的模板。

 

 

class Person
{
public:
    Person(string name, int age)
    {
        this->mName = name;
        this->mAge = age;
    }
    string mName;
    int mAge;
};

//普通交换函数
template <class T>
void mySwap(T &a,T &b)
{
    T temp = a;
    a = b; 
    b = temp;
}
//第三代具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体化优先于常规模板
template<>void  mySwap<Person>(Person &p1, Person &p2)
{
    string nameTemp;
    int ageTemp;

    nameTemp = p1.mName;
    p1.mName = p2.mName;
    p2.mName = nameTemp;

    ageTemp = p1.mAge;
    p1.mAge = p2.mAge;
    p2.mAge = ageTemp;

}

void test()
{
    Person P1("Tom", 10);
    Person P2("Jerry", 20);

    cout << "P1 Name = " << P1.mName << " P1 Age = " << P1.mAge << endl;
    cout << "P2 Name = " << P2.mName << " P2 Age = " << P2.mAge << endl;
    mySwap(P1, P2);
    cout << "P1 Name = " << P1.mName << " P1 Age = " << P1.mAge << endl;
    cout << "P2 Name = " << P2.mName << " P2 Age = " << P2.mAge << endl;
}