C ++：为什么编译器在不使用模板时将其实例化

Question

Let's consider this code:

template <bool c>
class A {
public:
    A() = default;
    // I want to enable f(int) only if c == true
    template<typename Temp = typename enable_if<c>::type>
    void f(int val) {
        cout << val << endl;
    };
};

int main() {
    A<false> a;
    A<true> b;
    b.f(543);
}

When I try to compile this I get the following error:

error: no type named 'type' in 'struct std::enable_if<false, void>'

But I don't use the template method f(int) when the argument <bool c> is false then it shouldn't exist.

Answer 1

The compiler does not "instantiate" your template, as you seem to incorrectly believe. The compiler is simply trying to parse and analyze your template declaration, which is a part of your class definition. If the class is instantiated, then all member declarations have to be valid. Your member template declaration is not valid. Hence the error.

If some template is "not used", it means that it does not get specialized and instantiated. But the declaration of that template still has to be valid. And the validity of those parts of that declaration that do not depend on template parameters is checked immediately. In other words, what you wrote in your code is no different from

template <typename T = jksgdcaufgdug> void foo() {}

int main() {}

or, closer to your situation

template <typename T = std::enable_if<false>::type> void foo() {}

int main() {}

Even though these programs do not "use" (do not instantiate) function template foo , it still does not mean that the declaration of foo can contain random garbage like jksgdcaufgdug or explicitly refer to non-existent entities like std::enable_if<false>::type . The above examples will not compile for that reason.

You can use "random garbage" in dependent contexts, like

template <typename T> void foo(typename T::kjhdfjskhf x) 
{ 
  typename T::jksgdcaufgdug i; 
}

and you can use std::enable_if in dependent contexts like

template <typename T, 
          typename U = typename enable_if<is_void<T>::value>::type>
void bar()
{ 
}

and it will not produce "early" errors, but in your case enable_if<c> does not depend on Temp , so it is not in dependent context. Which means that the correctness of typename enable_if<c>::type is checked immediately when you instantiate A<false> .