class template instantiation

问题:

I just read the wiki article about CRTP, and I'm a little confused about template instantiation.

According to the wiki,

member function bodies (definitions) are not instantiated until long after their declarations.

I don't quite understand what it means.

Suppose I got a class template:

template <typename T>
class A
{
    public:
        void foo(T t)
        {
            //...
        };
};

When I instantiate the class template A, does it instantiate the member function foo()?

For example:

//in .cpp file
int main()
{
    A<int> a; //question 1
              //class template is instantiated here, isn't it? 
              //What about foo(), is it instantiated too?

    a.foo(10); //question 2
               //according to the quotation, foo() will not be instantiated until it is used.
               //if so, foo() is instantiated right here, not in question 1, right?
}

回答1:

You seem to be confusing one thing:

Instantiation happens during compilation, not during runtime. Hence you can't say "on which line" a class template or a function template was instantiated.

That said, you're right about the fact that member function templates aren't instantiated together with class templates.

You could observe it in such a case: You have the following files

• template.h (defines class A and function A::foo)
• a.cpp (uses A)
• b.cpp (uses A and A::foo)

Then during compilation of a.cpp, only A would be instantiated. However, during compilation of b.cpp, both would be instantiated.

Because of this, in case A::foo contained some semantically invalid code for a given set of template parameters, you would get compile errors in b.cpp, but not a.cpp.

I hope that clears things up!

回答2:

With class templates, the rule of thumb is that only those members are instantiated which are actually used.

If you want complete instantiation, C++ offers explicit instantiation (however, usually you don't; the fact that not every bit is fully instantiated means that your template class is even more generic as it lowers the requirements on T, note that syntax checking and lookup of non-dependent types (stuff that is not dependent on T) still happens).

You will find a more complete answer here: Template instantiation details of GCC and MS compilers