STL 函数模板

函数模板并非真正的函数

1. 函数模板的定义

• <> 表示类型参数表, 里面是类型形参
• () 表示调用形参表，里面是调用形参
• class 也可以换成 typename， 不过基本不用

2. 函数模板的使用

3. 函数模板的分析

#include <iostream>
using namespace std;

// 函数模板
template <class T> T Max(T x, T y){
    return x > y ? x : y;
}

// 编译器会根据 Max<int> 中的int（类型实参）从函数模板中产生一个真正的函数实体， 这个过程叫实例化
// int Max(int x, int y) { return x > y ? x : y}
// 同理 Max<double>、Max<string>
// double Max(double x, double y) { return x > y ? x : y}
// string Max(string x, string y) { return x > y ? x : y}
// 相同函数名， 相同作用域， 不同类型实参， 构成函数重载

int main(){
    int nx = 10, ny = 20;
    cout << Max<int>(nx, ny) << endl; // 除了生成函数，还会把调用的地方改成：Max(nx, ny)
    double dx = 1.1, dy = 2.2;
    cout << Max<double>(dx, dy) << endl;  // Max(dx, dy)

    return 0;
}

4. 实例化函数模板的条件

5. 函数模板扩展

5.1 两次编译

• 第二次编译时，所有的未知类型都变为已知类型，会去检查这些一直类型的调用是否合理有效。

#include <iostream>
using namespace std;

class A{
public:
    void func() {
        return ;
    }
};

template <class T>void foo(){
    // 第一次编译检查：
    // xxx; 编译报错， 因为会检查函数模板内部出现的所有标识符是否有声明；
    A a;
    // 对于已知类型的调用要查看调用是否有效，比如func在A中有没有定义
    a.func();  // 已知类型调用
    // 对于未知类型都认为合理, 不管T类型中有没有定义xxxx函数
    T t;
    t.xxxx(); // 未知类型调用
    // 但是如果xxxx中有< or >, 那么就会编译报错，比如 t.x<x
}

int main(){
    // 第二次编译检查：
    // 编译报错，因为A类中没有xxxx这个成员函数
    foo<A>(); 
    return 0;
}

5.2 隐式推断类型实参

一般不认为去指定，让编译器自己干的事情，都会称为隐式。
相关可以理解为一样, 那么就可以通过x， y的类型退出T的类型。

#include <iostream>
using namespace std;

// 函数模板
template <class T> T Max(T x, T y){
    return x > y ? x : y;
}

int main(){
    int nx = 10, ny = 20;
    cout << Max(nx, ny) << endl; 
    // Max(nx, ny) => Max<>(nx, ny) => Max<int>(nx, ny)
    // 获得和调普通函数一致的语法表现形式
    double dx = 1.1, dy = 2.2;
    cout << Max(dx, dy) << endl; 
    return 0;
}

5.3.1 三种情况不能做隐式推断

• 1中，无法根据调用形参x或y的类型推断出类型形参D的类型
• 2中，123是int， 45.6是double，那编译器就无法推断出类型形参T的类型，因为不支持隐式的将double转为int
• 3 看下面代码示例

#include <iostream>
using namespace std;

template <class R, class T>R Hum(T t){
    R r;
    return r;
}

int main(){
    //Hum(1); // 编译报错，返回值的类型R无法隐式推断
    Hum<double>(1); // 需要显示的指明
    return 0;
}

5.3 函数模板的重载

#include <iostream>
using namespace std;

template <class T> void Max(T x, T y){
    cout << "1: Max(T, T)" << endl;
}

void Max(int x, int y) {
    cout << "2: Max(int, int)" << endl;
}


int main(){
    int nx = 1, ny = 2;
    Max(nx, ny);    // 2: Max(int, int)
    double dx = 1.1, dy = 2.2; 
    Max(dx, dy);    // 1: Max(T, T)
    Max(nx, dy);    // 2: Max(int, int)
    Max<>(nx, ny);  // 1: Max(T, T)
    return 0;
}