Re: extern template useless?
[3rd posting attempt]
Am 09.08.2012 06:25, schrieb Jens Auer:
> Hi,
>
> in our project we see large link times because templates are
> instantiated in a lot of translation units with the same types and
> then removed by the linker which is really slow and performance
> essentially seems to be IO-bound. I thought that the new extern
> template was supposed to solve this problem by suppressing the
> instantiations and providing one explicit instantiation definition
> in a translation unit by hand, so I tried an example:
>
> header.h:
> #include <vector>
>
> extern template class std::vector<int>;
What you are going to do here is undefined behaviour as of
[namespace.std] p2:
"A program may explicitly instantiate a template defined in the
standard library only if the declaration depends on the name of a
user-defined type and the instantiation meets the standard library
requirements for the original template."
The reason for this restriction exists to allow library implementors
to provide such explicit instantiations by themselves.
> template<typename T>
> struct A
> {
> void f(T) {}
> };
>
> extern template struct A<int>;
>
> -----------------------------------------
> source1.cpp
> #include "Header.h"
>
> // provide explicit instantiations
> template class std::vector<int>;
> template struct A<int>;
>
> ------------------------------------------
> source2.cpp
> #include "Header.h"
>
> // use to create implicit instantiations
> void foo()
> {
> std::vector<int> v;
> v.resize(10);
> A<int> a;
> a.f( v[0] );
> }
>
> If I understand correctly, std::vector<int> and A<int> should only
> be instantiated in the object file when compiling source1.cpp, and
> not in the object file from source2.cpp. However, Microsoft Visual
> C++ generates code for std::vector<int> in both object files. This
> seems to be in compliance with the standard at $14.7.2.10: "Except
> for inline functions and class template specializations, explicit
> instantiation declarations have the effect of suppressing the
> implicit instantiation of the entity to which they refer."
I agree.
> This seems to contradict the intend of extern template and given
> the way people write template code make it rather useless, because
> everybody defines the methods inline in the class. Is there a way
> around this without essentially modifying library code?
Library implementations are for good reasons a foreign country with
restrictive import rules, so to say. The explicit instantiation is not
useful to influence library-provided templates (unless at least one
type is a user-provided one) and I think that most of the problems you
describe are simply QoI.
Let me add to that that according to 14.7.2 p8:
"An explicit instantiation that names a class template specialization
is also an explicit instantiation of the same kind (declaration or
definition) of each of its members (not including members inherited
from base classes) that has not been previously explicitly specialized
in the translation unit containing the explicit instantiation, except
as described below."
This means that the explicit instantiation request does not include
members of base classes and library implementations can use as much
internal base classes as they want. This additionally reduces the
usefulness of explicit instantiations of library templates for the
user (not for the implementor) of the library.
I feel uncertain about your more general complains not restricting to
library templates, but as a gut feeling it seems to me that the
current rules seem reasonable given that without any further
directives at the hand the inline specifier is there for some
reasons. It seems that what you are asking for is a further control
directive along the lines of "for implicit instantiations I want
inline instantiations, otherwise not".
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]