函数模板

//  函数模板

template<typename T>
const T& min(const T& a, const T& b)
{
    return (a<b)? a:b;
}

template<typename T>
T FromString(const std::string& str)
{
    std::istringstream is(str);
    T t;
    is>>t;
    return t;
}

template<typename T>
std::string toStr(const T& t)
{
    std::ostringstream s;
    s<<t;
    return s.c_str();
}


// 一定要先声明函数的反悔类型参数 此时<int> 中的数据类型就是 返回类型

template<typename R, typename P>
R implicit_cast(const P& p)
{
    return p;
}

int main()
{
    int i = 1;
    float x = implicit_cast<float>(i);
    int   j = implicit_cast<int>(x);
    // !!! char* p =implict_cast<char*>(i);
    // 不存在这种隐转换
}

// 函数模板重载
template<typename T>
const T& min(const T& a, const T& b)
{
    return (a<b)? a:b;
}


const char* min(const char* a, const char* b)
{
    return (strcmp(a,b)<0)?a:b;
}


double min(double x, double y)
{
    return (x<y)?x:y;
}


// 以函数模板地址作为参数
template<typename T>
void f(T*) {}

void h(void (*pf)(int*)) {}

template<typename T>
void g(void (*pf)(T*)) {}

int main()
{
    h(&f<int>);
    h(&f);

    g<int>(&f<int>);
    g(&f<int>);
    g<int>(&f);
}