C++ 函数模板和类模板

1.函数模板

#include <iostream>
using namespace std;


//int类型的数据交换
void testInt(int& a,int& b)
{
    int tem = a;
    a = b;
    b = tem;
}
//double类型的数据交换
void testDouble(double& a, double& b)
{
    double tem = a;
    a = b;
    b = tem;

}



//模板技术   类型参数化  编写代码可以忽略类型
//模板函数的写法：
template<typename T>//这里可以有T1,T2...
void testTemplate(T& a, T& b)
{
    T temp = a;
    a = b;
    b = temp;

}



int main()
{  
    //有两种写法
    // 
    // 
    //1.自动类型推导
    int a = 10, b = 20;
    cout << "a = " << a << "b= " << b << endl;
    testTemplate(a,b);
    //2.显示的指定类型
    testTemplate<int>(a,b);
    cout << "a = " << a << "b= " << b << endl;


    
    return 0;
}

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

1.函数模板不允许自动类型转换

2.普通函数能够进行类型转换

1.2函数模板和普通函数一起调用的规则

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

2.C++优先考虑普通函数

int MyAdd(int a,int b){return a +b}

template<typename T>
int MyAdd(T a,T b){return a +b}

优先调用普通函数 

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

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

MyAdd<int>(a,b);

1.3 C++编译器模板机制

1.编译器(编译原理)工作流程

2.函数模板实现原理

函数模板通过具体的使用情况生成模板函数，编译器在编译的时候会自动帮我们生成模板函数

 编译器或有两次编译，函数模板声明的时候编译一次，程序中函数调用此情况会再次编译一次

2.类模板

1.实例

#include <iostream>
using namespace std;

template<class T>
class Person {

public:
    Person(T id, T age) {
        this->mage = age;
        this->mid = id;
    };
    void Show() {

        cout << "ID " << mid << "Age" << mage <<endl;
    }
public:
        T mid;
        T mage;
};

void test() {

    Person<int>p(10, 20);
    p.Show();
}




int main()
{  
    test(); 
    return 0;
}

2.模板类的案例:对char类型和int类型数组进行排序

#include <iostream>
using namespace std;

//打印函数
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 = i + 1; j < len; j++) {
            //从大到小
            if (arr[i] < arr[j])
            {
                T temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
        
}
void test(int* arr,int len) {
    mySort(arr, len);
}


int main()
{  
    //定义一个数组
    int arr[] = { 2,6,1,8,9,2 };
    //数组长度
    int length = sizeof(arr) / sizeof(int);
    printArray(arr, length);
    //进行排序
    mySort(arr,length);
    printArray(arr, length);

    char arrChar[] = { 'a','b','e','c','d'};
    //数组长度
    int len = sizeof(arrChar) / sizeof(char);
    printArray(arrChar,len);
    //进行排序
    mySort(arrChar, len);
    printArray(arrChar, len);

    return 0;
}

3.类模板派生普通类

#include <iostream>
using namespace std;

template<class T>
class Person {

public:
    Person(T id, T age) {
        this->mage = age;
        this->mid = id;
    };
    void Show() {

        cout << "ID " << mid << "Age" << mage <<endl;
    }
public:
        T mid;
        T mage;
};

//要指定分配空间

class sonPerson : public Person<int>{
}

//这种写法直接加T就可以
template<class T>
class sonPerson : public Person<T>{
}

类模板在类内实现，声明和实现放在一起

类模板在类外实现，实现放在外面

#include <iostream>
using namespace std;

template<class T>
class Person {

public:
    //重载左移操作符
    template<class T>
    friend ostream& operator<<(ostream& os,Person<T>& p)
    Person(T id, T age);

    void Show() ;

public:
        T mid;
        T mage;
};

template<class T>
Person<T>::Perdon(T age,T id){
    this->mid = id;
    this->mage = age;
}

template<class T>
void Person<T>::Show(){

}


//重载左移运算操作符
 template<class T>
 ostream& operator<<(ostream& os,Person<T>& p){

 os<<"Age"<<p,mage<<"ID"<<p.mid<<endl;
}
}