Is this a correct usage of extern template in C++11? (Can it be that the extern template class and respective template class is visible in the same translation unit?)
// example.hpp:
#pragma once
template< typename T >
class C {
void f(T);
};
// question is about the next two lines
extern template class C< float >;
extern template class C< double >;
// example_def.hpp:
#include "example.hpp"
template< typename T >
void C< T >::f(T) {
//... smth. practicable
}
// example.cpp:
#include "example_def.hpp"
template class C< float >;
template class C< double >;
// other.hpp:
#pragma once
void g();
// other.cpp:
#include "other.hpp"
#include "example.hpp"
// maybe those two lines should be here instead?
void g() {
C< float >();
C< double >();
}
// main.cpp:
#include "example.hpp"
#include "other.hpp"
// ...and here?
int main() {
C< float >();
C< double >();
g();
return 0;
}
Yes, both an extern template class specification (called explicit instantiation declaration by the Standard) and a template class specification (called explicit instantiation definition by the Standard) can be in the same translation unit, if the definition (without extern) follows the declaration (with extern):
(§14.7.2/11) If an entity is the subject of both an explicit instantiation declaration and an explicit instantiation definition in the same translation unit, the definition shall follow the declaration. An entity that is the subject of an explicit instantiation declaration and that is also used in a way that would otherwise cause an implicit instantiation (14.7.1) in the translation unit shall be the subject of an explicit instantiation definition somewhere in the program; otherwise the program is ill-formed, no diagnostic required. [ Note: This rule does apply to inline functions even though an explicit instantiation declaration of such an entity has no other normative effect. This is needed to ensure that if the address of an inline function is taken in a translation unit in which the implementation chose to suppress the out-of-line body, another translation unit will supply the body. — end note ] An explicit instantiation declaration shall not name a specialization of a template with internal linkage.
(Emphasis mine). The terms explicit instantiation declaration and explicit instantiation definition are defined here:
(§14.7.2/2) The syntax for explicit instantiation is:
explicit-instantiation:
externopt template declaration
There are two forms of explicit instantiation: an explicit instantiation definition and an explicit instantiation declaration. An explicit instantiation declaration begins with the extern keyword.
The effect of these explicit instantiations is as follows:
The explicit instantiation declaration (with extern) prevents all implicit instantiations to take effect (except for inline functions and class template specializations, §14.7.2/10).
The explicit instantiation definition (without extern) causes the instantiation to happen no matter what, i.e. it overrides the explicit instantiation declaration (this also follows from §14.7.2/10).
General comments
The fact that your explicit instantiation declarations are located in the header file that defines the template implies that anyone who includes the header files in order to make use of the template will either have to also add an explicit instantiation definition, or, alternatively, needs to link to the code of another .cpp file that includes such an explicit instantiation definition.
This can be confusing and is probably not a very good idea when you expect many different users to instantiate the template for many different types. But it can be sensible if the number of instantiations for distinct types is small and you can anticipate them all. Of course you must make sure that there is one (or several) .cpp file(s) that include explicit instantiation definitions for all the instantiations required, and that its corresponding object file is linked with the project at build time.
The basic idea of extern templates is to support explicit instantiation of commonly used instantiations while also supporting implicit instantiations for less commonly used parameters. For example, std::basic_string<char> could be explicitly instaniated but std::basic_string<signed char> could be left for implicit instantiation (the actual motivating examples were IOStreams which take substantial time to get instantiated but only two instantiations are actually used).
To allow implicit instantiation the definition of the used templates needs to be visible in each translation unit where the template is used. If the template definition is visible the compiler assumes by default that it needs to provide an instantiation implicitly. Using an extern template declaration tells the compiler that the specific template instantiation will be provided by some translation unit.
Although your case works it isn't even necessary to declare the extern templates: When the compiler uses an instantiation and doesn't find its definition it will assume that the instantiation is found in some translation unit.
Related
This question already has answers here:
Explicit template instantiation - when is it used?
(4 answers)
How template explicit instantiation works and when?
(1 answer)
Closed 9 months ago.
I'm working with a code base that has the following declarations in a.cpp:
template <int num_dim = 2>
int register_parameters();
extern template int register_parameters<2>(); // why is extern required here?
In b.cpp, we define
template <int num_dim = 2> int register_parameters() {
// define stuff
}
template int register_parameters<2>();
When I remove the extern keyword, I get the following error at compile time
error: explicit instantiation of ‘int register_parameters() [with int num_dim = 2]’ but no definition available [-fpermissive]
template int register_parameters<2>();
I am wondering why the extern keyword is required in this case?
These are not specialization declarations. Explicit specialization declarations/definitions use template<> instead of template and extern can't be used on them like this.
extern template int register_parameters<2>();
is an explicit instantiation declaration.
template int register_parameters<2>();
is an explicit instantiation definition.
Normally, when the definition of a template is available, and a template specialization like register_parameters<2> is used in a way that would require a definition of that specialization to exist (e.g. a function call register_parameters<2>()), the compiler would implicitly instantiate the template definition into the definition for the specific specialization (i.e. the actual body of the function that register_parameters<2> refers to with 2 substituted for ndims from the template definition). For it to be able to do that it is usually required that the template is defined in a header file available at the point requiring the implicit instantiation.
The explicit instantiation definition instructs the compiler to explicitly instantiate the template specialization in this translation unit and guarantee that the instantiation is available to other translation units as well (so that these do not actually need an instantiation/definition).
If there is no definition for the template available, then this can of course not work. Hence your error message at the end of the question.
The explicit instantiation declaration instructs the compiler that there is a corresponding definition somewhere (else) in the program and that implicit instantiation of the template specialization should not be done and is not needed in this translation unit. It could not be done in a.cpp anyway though, since it lacks the definition of the template.
So together these two make sure that there will be exactly one single instantiation of the template specialization in the program, coming from translation unit b.cpp with the explicit instantiation definition, instead of the more common approach of having the template be defined in a header and implicitly instantiated in each translation unit.
The following explicit template instantiation results in compiler frontend segfault under LLVM clang++ 11.0 on x86_64-pc-windows-msvc, using the clang-cl interface with -std=c++17, regardless of optimization level.
A.h
template <typename T>
class A
{
public:
T value;
static constexpr auto address = &A<T>::value;
};
extern template class A<float>;
A.cpp
#include "A.h"
template class A<float>;
Note that since C++17 A::address is an inline variable so ODR-using cannot be a problem here.
The compiler behavior is obviously wrong, I already filed a report at the LLVM bug tracker.
Nevertheless, I am still curious about the actual correctness of the code.
Is it an undefined behavior which is handled incorrectly by the compiler, or the code itself is free of any problems and it's only about the compiler. Personally I don't find anything in the standard at the specification of explicit template instantiations which would suggest that the above code is wrong.
I don't think that the above is ill-formed, am I missing something?
Your example class A
// A.h
#pragma once
template <typename T>
class A {
public:
T value;
static constexpr auto address = &A<T>::value;
};
extern template class A<float>;
// A.cpp
#include "A.h"
template class A<float>;
used e.g. as in the following example (full demo here)
#include <iostream>
#include "A.h"
int main() {
A<float> af{42.F}; // uses explicit instantiation: no implicit instantiation occurs.
A<int> ai{43}; // implicit instantiation.
std::cout << af.*A<float>::address // 42
<< "\n" << ai.*A<int>::address; // 43
}
is well-formed, and it is naturally a (ICE; internal compiler error) compiler bug that the compiler crashes. Unless your own program also contains uncarefully placed explicit specializations (see below) or is otherwise very different from the minimal example above, your own program should likewise be well-formed.
Details
[temp.explicit]/14 requires, for an explicit instantiation declaration [emphasis mine]:
If an entity is the subject of both an explicit instantiation
declaration and an explicit instantiation definition in the same
translation unit, the definition shall follow the declaration. An
entity that is the subject of an explicit instantiation declaration
and that is also used in a way that would otherwise cause an
implicit instantiation in the translation unit shall be the subject
of an explicit instantiation definition somewhere in the program;
otherwise the program is ill-formed, no diagnostic required. [...] An
explicit instantiation declaration shall not name a specialization of
a template with internal linkage.
These requirements are all fulfilled the example above, as are the requirements on the definition of A to precede the explicit definition of a specialization of it as per [temp.explicit]/5.
Finally, [temp.spec]/5 contains the additional requirements that [emphasis mine]:
For a given template and a given set of template-arguments,
(5.1) an explicit instantiation definition shall appear at most once in a program,
(5.2) an explicit specialization shall be defined at most once in a program, as specified in [basic.def.odr], and
(5.3) both an explicit instantiation and a declaration of an explicit specialization shall not appear in a program unless the
explicit instantiation follows a declaration of the explicit
specialization. An implementation is not required to diagnose a
violation of this rule.
(5.1) is fulfilled as the explicit instantiation definition of A<float> is located within a single translation unit (a common ill-formed NDR error is to uncarefully place explicit instantiation definitions in headers, where the header is included in more than a single source file). (5.2) does not apply as there is no explicit specialization of A present (for any specialization), and (5.3) subsequently does not apply as there is no explicit specialization of the A<float> specialization that can conflict with the explicit instantiation definition of the latter.
Finally note that, as per [temp.local]/2, you may use the injected-class-name A when initializing the static data member address of the class template A:
template <typename T>
class A {
public:
T value;
static constexpr auto address = &A::value;
};
This question already has answers here:
Should I declare my function template specializations or is defining them enough?
(2 answers)
Is it safe to place definition of specialization of template member function (withOUT default body) in source file?
(3 answers)
Closed 2 years ago.
I'm working on a codebase which uses the following structure:
a.h:
template<int N> void f();
void b();
a.cpp:
#include "a.h"
template<> void f<1>() {}
int main()
{
b();
}
b.cpp:
#include "a.h"
void b()
{
f<1>();
}
The code appears to build and run correctly.
My question is: is this well-formed, or is it some kind of ill-formed NDR that happens to work?
If building with clang -Wundefined-func-template (this was enabled in my IDE's default settings for clang-tidy) then a warning is produced:
b.cpp:5:2: warning: instantiation of function 'f<1>' required here, but no definition is available [-Wundefined-func-template]
f<1>();
^
./a.h:1:22: note: forward declaration of template entity is here
template<int N> void f();
^
b.cpp:5:2: note: add an explicit instantiation declaration to suppress this warning if 'f<1>' is explicitly instantiated in another translation unit
f<1>();
^
But I am not sure whether to just disable the warning, or make some code change (other than moving the explicit specialization definition to the header file, which would not be preferable for this project).
Following the advice in the warning message and adding an explicit instantiation declaration to the header file (i.e. extern template void f<1>();) caused an error message (implicit instantiation of a specialization before explicit instantiation).
However, adding an explicit specialization declaration template<> void f<1>(); to the header file suppresses the warning. But I am not sure if this is (a) necessary, and/or (b) recommended style.
The program violates [temp.expl.spec]/6:
If a template, a member template or a member of a class template is explicitly specialized then that specialization shall be declared before the first use of that specialization that would cause an implicit instantiation to take place, in every translation unit in which such a use occurs; no diagnostic is required.
The function template f is explicitly specialized by template<> void f<1>() {} in b.cpp. But in the translation unit formed from b.cpp and including a.h, the statement f<1>(); would cause an implicit instantiation of the same specialization f<1>, and there is no declaration of the explicit specialization earlier (or anywhere) in the translation unit.
Per the Standard, an explicit specialization is always a distinct thing from an instantiated specialization, since both can never exist for the same primary template and same template arguments. But the program might work anyway because many compilers use the same mangled linker names for template explicit specializations and instantiated specializations.
The clang warning might be because it's legal, though unusual, to implicitly instantiate a function template without a visible definition if the same specialization is explicitly instantiated, not explicitly specialized, elsewhere. So it's suggesting an improvement to make a legal program clearer. I'm not exactly sure if it actually is legal, though. But its suggested explicit instantiation declaration would be a lie, since the specialization is explicitly specialized, not explicitly instantiated.
The program does become valid if you add explicit specialization declarations to the header file for every specialization which will be used.
template<int N> void f();
template<> void f<1>();
There's an example in [temp.over]/5 that matches yours almost exactly, and pronounces it well-formed:
[temp.over]/5 ... [ Example:
template<class T> void f(T); // declaration
void g() {
f("Annemarie"); // call of f<const char*>
}
The call of f is well-formed even if the template f is only declared and not defined at the point of the call. The program will be ill-formed unless a specialization for f<const char*>, either implicitly or explicitly generated, is present in some translation unit. —end example ]
[temp]/7 says:
A function template, member function of a class template, variable template, or static data member of a class template shall be defined in every translation unit in which it is implicitly instantiated unless the corresponding specialization is explicitly instantiated in some translation unit; no diagnostic is required.
The standard requires explicit instantiation, so explicit specialization in a.cpp won't make the program well-formed.
A similar question ([temp]/7 treats function templates and member functions of class templates equally) was asked in CWG2138:
It is not clear whether the following common practice is valid by the current rules:
// foo.h
template<typename T> struct X {
int f(); // never defined
};
// foo.cc
#include "foo.h"
template<> int X<int>::f() { return 123; }
// main.cc
#include "foo.h"
int main() { return X<int>().f(); }
which was closed as NAD with the following rationale:
As stated in the analysis [which referred to [temp]/7, among other things], the intent is for the example to be ill-formed, no diagnostic required.
So, the answer is: the program is ill-formed NDR, and this is intended.
Consider the following code snippet:
template <typename>
struct X { };
extern template struct X<int>;
int main()
{
X<int>{};
}
It compiles and links: live example on godbolt.org. I would expect it not to link due to the extern template declaration.
My understanding is that extern template means: "please don't instantiate this particular template specialization in this TU, it will be provided by some other TU and you can link against it".
The examples/descriptions. I've seen on isocpp and cppreference seem to validate my mental model. E.g.
From https://en.cppreference.com/w/cpp/language/class_template:
An explicit instantiation declaration (an extern template) skips implicit instantiation step: the code that would otherwise cause an implicit instantiation instead uses the explicit instantiation definition provided elsewhere (resulting in link errors if no such instantiation exists). This can be used to reduce compilation times by explicitly declaring a template instantiation in all but one of the source files using it, and explicitly defining it in the remaining file.
Why does my code snippet link? What is actually happening here?
EDIT - found this in the latest Standard draft:
[temp.explicit]
If an entity is the subject of both an explicit instantiation declaration and an explicit instantiation definition in the same translation unit, the definition shall follow the declaration. An entity that is the subject of an explicit instantiation declaration and that is also used in a way that would otherwise cause an implicit instantiation in the translation unit shall be the subject of an explicit instantiation definition somewhere in the program; otherwise the program is ill-formed, no diagnostic required.
Does this mean that the code snippet I posted is ill-formed, NDR?
Why does my code snippet link? What is actually happening here?
Well, there's nothing to link. For one has to consider the effects of the explicit instantiation. From n3337:
[temp.explicit] (emphasis mine)
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. [ Note: The intent is that an inline function that is the
subject of an explicit instantiation declaration will still be
implicitly instantiated when odr-used ([basic.def.odr]) so that the
body can be considered for inlining, but that no out-of-line copy of
the inline function would be generated in the translation unit. — end
note ]
So the implicit instantiation of the class template specialization X<int>, is not suppressed. It's also an aggregate, so its initialization occurs inline, and we get nothing to link against. However, if it had any members, those would be suppressed under paragraph 8:
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.
So if you had instead of an aggregate something akin to this:
template <typename>
struct X {
X();
};
template <typename T>
X<T>::X() {}
extern template struct X<int>;
int main()
{
X<int>{};
}
That would fail as you expect, since it ODR uses a constructor whose definition is never instantiated. The declaration is instantiated, because the enclosing specialization is instantiated, as mentioned above. But we never get any definition, under the suppressing effect of the explicit instantiation declaration.
Does this mean that the code snippet I posted is ill-formed, NDR?
Yes, by the exact sentence from [temp.explicit]/13 that you quoted. "An entity" means just that. It does not matter if an explicit instantiation declaration otherwise have no normative effect.
In this question, the accepted answer involves a template function declaration in a header file which has its definition in the source file. To make this template function also usable in other translation units, explicit template instantiations are made in the source file for each "allowed" usage. So far this appears to me as standard practice.
The answer however also recommends placing corresponding explicit template instantiation declarations in the header file. I have not seen this practice before and would like to know if this is required by the standard.
Here is a small example:
A.h
struct A
{
template<class T>
void g(T t);
};
A.cpp
#include "A.h"
template<class T>
void A::g(T t)
{ /* ... */ }
template void A::g(int); // Explicit instantiation of the definition.
main.cpp
#include "A.h"
int main()
{
A a;
a.g(0);
}
The wording in the standard does not make it clear to me whether the explicit instantiation of the declaration is also required. This seems to primarily concern the "the definition is never instantiated explicitly, an implicit instantiation in A.cpp is not guaranteed to be retained" case (not depicted), but I would appreciate clarification.
Are explicit template instantiation declarations required in the header when explicitly instantiating the definitions in the source file?
No. The rule is, from [temp]/10, emphasis mine:
A function template, member function of a class template, variable template, or static data member of a class template shall be defined in every translation unit in which it is implicitly instantiated unless the corresponding specialization is explicitly instantiated in some translation unit; no diagnostic is required.
In your example, A::g<int> is implicitly instantiated in main.cpp but it is explicitly instantiated in "some translation unit" (A.cpp). The program is fine.