57 C++ - 函数模板

//交换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;
}

//模板打印函数
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);
}

//函数模板
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);
  //结论：
  //函数模板不允许自动类型转换，必须严格匹配类型
  //普通函数可以进行自动类型转换
}

//函数模板
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++编译器优先考虑普通函数
}