// N4606 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4606.pdf
#define msg "(198)14.7.2 Explicit instantiation [temp.explicit]p397.cpp"
// Edited by Dr. Ogawa Kiyoshi. Compile procedure and results record.

#include <iostream>

Example:
template<class T> class Array { void mf(); };
template class Array<char>;
template void Array<int>::mf();
template<class T> void sort(Array<T>& v) { /* ... */ }
template void sort(Array<char>&); // argument is deduced here
namespace N {
template<class T> void f(T&) { }
}
template void N::f<int>(int&);
—end example ]
4 A declaration of a function template, a variable template, a member function or static data member of a class
template, or a member function template of a class or class template shall precede an explicit instantiation of
that entity. A definition of a class template, a member class of a class template, or a member class template of
a class or class template shall precede an explicit instantiation of that entity unless the explicit instantiation
is preceded by an explicit specialization of the entity with the same template arguments. If the declaration of
the explicit instantiation names an implicitly-declared special member function (Clause 12), the program is
ill-formed.
5 For a given set of template arguments, if an explicit instantiation of a template appears after a declaration of
an explicit specialization for that template, the explicit instantiation has no effect. Otherwise, for an explicit
instantiation definition the definition of a function template, a variable template, a member function template,
or a member function or static data member of a class template shall be present in every translation unit in
which it is explicitly instantiated.
§ 14.7.2 397
©ISO/IEC N4606
6 An explicit instantiation of a class, function template, or variable template specialization is placed in the
namespace in which the template is defined. An explicit instantiation for a member of a class template is
placed in the namespace where the enclosing class template is defined. An explicit instantiation for a member
template is placed in the namespace where the enclosing class or class template is defined. [ Example:
namespace N {
template<class T> class Y { void mf() { } };
}
template class Y<int>; // error: class template Y not visible
// in the global namespace
using N::Y;
template class Y<int>; // error: explicit instantiation outside of the
// namespace of the template
template class N::Y<char*>; // OK: explicit instantiation in namespace N
template void N::Y<double>::mf(); // OK: explicit instantiation
// in namespace N
—end example ]
7 A trailing template-argument can be left unspecified in an explicit instantiation of a function template
specialization or of a member function template specialization provided it can be deduced from the type of a
function parameter (14.8.2). [ Example:
template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v) { /* ... */ }
// instantiate sort(Array<int>&) - template-argument deduced
template void sort<>(Array<int>&);
—end example ]
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 and members that are templates) that has not been previously explicitly specialized in the translation
unit containing the explicit instantiation, except as described below. [ Note: In addition, it will typically be
an explicit instantiation of certain implementation-dependent data about the class. —end note ]
9 An explicit instantiation definition that names a class template specialization explicitly instantiates the class
template specialization and is an explicit instantiation definition of only those members that have been
defined at the point of instantiation.
10 Except for inline functions and variables, declarations with types deduced from their initializer or return
value (7.1.7.4), const variables of literal types, variables of reference types, 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 (3.2) 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 ]
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
§ 14.7.2 398
©ISO/IEC N4606
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.
12 The usual access checking rules do not apply to names used to specify explicit instantiations. [ Note: In
particular, the template arguments and names used in the function declarator (including parameter types,
return types and exception specifications) may be private types or objects which would normally not be
accessible and the template may be a member template or member function which would not normally be
accessible. —end note ]
13 An explicit instantiation does not constitute a use of a default argument, so default argument instantiation is
not done. [ Example:
char* p = 0;
template<class T> T g(T x = &p) { return x; }
template int g<int>(int); // OK even though &p isn’t an int.
—end examp
int main() {
  std::cout<< msg << std::endl;
  return EXIT_SUCCESS;
}

$ ./cppgl17.sh p360
$ clang++ p360.cpp
(176)14.5.1.2 Member classes of class templates [temp.mem.class]p360.cpp

$ g++-7 p360.cpp
(176)14.5.1.2 Member classes of class templates [temp.mem.class]p360.cpp

#!/bin/bash
astyle -s2 -c < $1.cpp > $1s2.cpp
cat $1s2.cpp