函数模板实践

做了4个试验，test5没做，但是给了结论。

直接贴实践过的代码

#include <iostream>
#include <string>


template<typename T>
void swapval(T& val1, T& val2){
    T vector = val1;
    val1 = val2;
    val2 = vector;
}

/*****普通函数******/
std::string sort(std::string array[], int len){
    std::cout << "我是普通函数sort" << std::endl;

    for(int i=0; i< len; i++){
             for(int j=i+1; j<len; j++){
                 if(array[i] > array[j]){
            swapval(array[i], array[j]);
                 }
              }
        }
       return  array[0];
}

/*****函数模板******/
template<typename T>
T sort(T array[], int len){
    std::cout << "我是函数模板sort" << std::endl;

    for(int i=0; i< len; i++){
             for(int j=i+1; j<len; j++){
                 if(array[i] > array[j]){
            swapval(array[i], array[j]);
                 }
              }
        }
       return  array[0];
}

template<typename T>
T print(T array[], int len){
    for(int i=0; i< len; i++){
           std::cout << array[i] << "  ";
        }
    std::cout << std::endl;
       return  array[0];
}

typedef std::string (t_func_str)(std::string array[], int len);

int main(int argc, char* argv[]){
     
     /*********
    test1: 函数基本测试之int 
     *******/
     int array1[8] = {8, 7, 9, 4, 3, 6, 8, 1};
     sort<int>(array1, sizeof(array1)/sizeof(int));
     print<int>(array1, sizeof(array1)/sizeof(int));

     std::cout << "test1 over " << std::endl;
     /*********
    test2: 函数基本测试之float 
     *******/
     float array2[8] = {8.31, 7, 9.52, 4, 3, 6, 8.0, 1.2345};
     sort(array2, sizeof(array2)/sizeof(float));      /****类型自动推导****/
     print<float>(array2, sizeof(array2)/sizeof(float)); /****显式指定类型****/

     std::cout << "test2 over " << std::endl;
     /*********
    test3: 函数基本测试之string 
     *******/
     std::string array3[5] = {"aa", "bb", "ccc", "ab", "ba"};
     std::string min_3 = sort(array3, 5);
     std::cout << "min :" << min_3 << std::endl;
     print<std::string>(array3, 5);

     std::cout << "test3 over " << std::endl;
     /*********
    test4: 当函数模板 遇上函数重载，调用谁？ (这里存在普通函数sort 和 函数模板sort) 
     *******/
     std::string array4[5] = {"aac", "bbd", "c", "abb", "ba"};
     #if 1
     t_func_str * pfunc_str = sort<>; /*** 如果使能这句代码，将使用函数模板sort
                                     且编译器自动推导泛型T 为std::string .******/
     #else
     t_func_str * pfunc_str = sort  /*** 如果使能这句代码，将使用普通函数sort .******/
     #endif

     std::string min_4 = pfunc_str(array4, 5);
     std::cout << "min :" << min_4 << std::endl;
     print<std::string>(array4, 5);

     std::cout << "test4 over " << std::endl;

     /*********
    test5: 当函数模板 遇上隐式类型转换，不记录实验过程，只贴结论：
     *******/

     return 0;
}

test1 、test2 小结：
因为不存在参数类型为int 和float的普通函数sort，所以这两个例子内只能匹配到函数模板sort。

test3 、test4 小结：
当函数模板 遇上函数重载，编译器将面临多个选择。
此时编译器将优先选择使用普通函数的重载版本。
若函数名后使用<>指定使用函数模板，则会使用函数模板。

test5结论：
函数模板本身不支持隐式类型转换，
自动推导类型时，必须严格匹配。
显示类型指定时，能够进行隐式类型转换。

.