运行时的函数模板类型推导

Question

I am trying to understand why the following compiles/runs despite the template type being resolved at run time. Is it because the if/else calls to f alone are enough to tell the compiler to create void f<double>(double) and void f<std::string>(std::string) ?

test.hpp

#include <type_traits>
#include <string>
#include <iostream>

template <typename T>
void f(T x) {
    if(std::is_same<T, std::string>::value)
        std::cout << "String: " << x;
}

test.cpp

#include <iostream>
#include "test.hpp"

int main(int, char** argv) {
    double x(std::stod(argv[1]));

    if(x < 42) f(x);
    else f(std::to_string(x));

    return 0;
}

---

$ (clan)g++ -std=c++14 test.cpp
$ ./a.exe 41

$ ./a.exe 43
String: 43.000000

Answer 1

There is no run time template deduction going on here. When you have

if(x < 42) f(x);

The compiler knows, at compile time, that x is a double so it stamps out

void f<double>(double)

Then in

else f(std::to_string(x));

The compiler knows the return type of std::to_string is a std::string so it stamps out a

void f<std::string>(std::string)

To use. Both functions exist at the same time and only one gets called at run time depending on what input you give the program.

Lets look at this example code provided by chris in his comment . Using

#include <type_traits>

template <typename T>
__attribute__((used)) int f(T x) {
    if(std::is_same<T, int>::value)
        return 1;
    else
        return 2;
}

int main(int argc, char** argv) {
    if(argc > 1) return f(1);
    else return f(1.0);
}

Compiling with -O3 -std=c++1z -Wall -Wextra -pedantic generates the assembly

main:                                   # @main
        xor     eax, eax
        cmp     edi, 2
        setl    al
        inc     eax
        ret

int f<int>(int):                        # @int f<int>(int)
        mov     eax, 1
        ret

int f<double>(double):                  # @int f<double>(double)
        mov     eax, 2
        ret

As you can see both template functions exist in the assembly and it is just the if in main that decides which one to call at run time.

Answer 2

1. Compiler reads main , sees two calls to f , once with a string argument and once with an int

2. Generates two f s. Calls to both functions are embedded in main.

3. Your if statement causes one or another call. So there is no template resolution in runtime. Such thing does not exist.