为什么显式模板实例化不起作用

Question

Could you please explain, why the explicit template instantiation doesn't work here?

template <typename T>
bool IsEqual(T v1, T v2) {
    return v1 == v2;
}

template bool IsEqual<double>(double a, double b);

int main() {  
    int c = 4;
    double d = 4.0;
    IsEqual(c,d)
    return 0;
}

The error the code produces is:

note:   template argument deduction/substitution failed:
note:   deduced conflicting types for parameter 'T' ('int' and 'double')

If the function isn't a template function then everything works well. So I expect an explicit instantiation to create the same function.

bool IsEqualT (double a, double b) {
    return a == b;
}

Answer 1

Template parameter deduction doesnt take care about explicit instantiation or overload resolution.

You have to pass arguments of same type if you want to call IsEqual or change its declaration to

template <typename T, typename S>
bool IsEqual(T v1, S v2) {
    return v1 == v2;
}

// ... main

int c = 4;
double d = 4.0;
printf("%s", IsEqual(c,d) == true ? "True" : "False"); // Prints true

or help compiler choose right overload by specifing T as double .

IsEqual<double>(c,d);

Answer 2

Manually stamping out

template bool IsEqual<double>(double a, double b)

Doesn't stop the compiler from doing template argument deduction in

IsEqual(c,d)

It just tells the compiler regardless of what other functions it might stamp out, you want it to stamp out that function for double s.

So, since you still go through template argument deduction, and int is not the same as double you get the compiler error. You will either have to cast c to a double or rewrite the function to have 2 template parameters so it can take two different types.

Answer 3

An explicit template instantiation guarantees that the compiler produces code for a particular set of template parameters, which means it will be found if the linker needs it.

It doesn't hide other combinations of template parameters, or prevent them from being instantiated (implicitly or otherwise).

As such, explicit instantiation has no effect on template parameter deduction, and no effect on overload resolution. The whole family of possible instantiation are still candidates.