是否在C ++中的不同编译单元中多次编译模板类？

Question

Let's say I have the following code:

// templateClass.h
#ifndef TEMPLATE_CLASS_H
#define TEMPLATE_CLASS_H

template <typename T>
class tClass
{
public:
  tClass();
};

#endif

// templateClassDef.inl
#ifndef TEMPLATE_CLASS_DEF_INL
#define TEMPLATE_CLASS_DEF_INL

template <typename T>
tClass<T>::tClass()
{
}

#endif

// normalClass.h
#include "templateClass.h"

class normal
{
public:
  normal();
};

// normalClass.cpp
#include "normalClass.h"
#include "templateClassDef.inl"

normal::normal()
{
  tClass<int> a;
}

// main.cpp
#include "templateClass.h"
#include "templateClassDef.inl"

#include "normalClass.h"

int main()
{
  tClass<int> a;
  normal b;

  return 0;
}

Note that the inl file is NOT being included in the header as it normally is, but is instead included in the source files (I am aware that is not the standard way... this is just an example). Notice that normalcClass.cpp is instantiating tClass<int> and so is main.cpp .

I am curious as to whether the compiler has to construct the instantiation from the template class every time it encounters an explicit instantiation, considering it is the same type (ie tClass<int> ) even though both instantiations occur in separate translation units ( normalClass.cpp and main.cpp )? Also, will this increase in compile time (If the answer to the previous question is yes it will instantiate it again then this should also be yes )?

Answer 1

Basically, templates are instantiated per compile unit, which increases compile time. There are some extensions and features in the new C++ standard to handle this issue, like explicit instantiation and externalization. See this doc for some explanations and optimization techniques:

http://gcc.gnu.org/onlinedocs/gcc/Template-Instantiation.html

Answer 2

通常，是的，模板类通常在每次编译器遇到时编译。

Answer 3

How the compiler implements the template instantiation mechanism is up to the compiler. Practically, the needed and visible function template definitions are created when it is used in a translation unit. This can create quite a bit of unnecessary work. For example, every time you use IOstreams in a translation unit all the correspondung functions from the stream and locale classes are instantiated. ... always with the same two types!

Depending on what the template is for it may be viable to put the implementation into a source file rather than into a header and explicitly instantiate the template in the source. When there are lots of different instantiations being used this isn't viable. In this case it may be reasonable to to predefine commonly use instantiations. For this you can declare instantiations to be extern in C++2011. Of course, you then need to explicitly instantiate the corresponding functions or classes somewhere.

Answer 4

Yes, compilation units are compiled independently from each other.

However, many toolchains support pre-compiled headers which circumvent this, and allow the compiler to reuse already processed code in another compilation unit.