    Template explicit specializations can be declared in the usual way. I.e.,
by replacing its body with a semicolon.

    When em(declaring) a template explicit specialization the pair of
 i(angle brackets) following the tt(template) keyword are essential. If
omitted, we would have constructed a
        i(template instantiation declaration).
    The compiler would silently process it, at the expense of a somewhat
longer compilation time.

    When declaring a template explicit specialization (or when using an
instantiation declaration) the
        hi(template explicit type specification: omitting)
    explicit specification of the template type parameters can be omitted if
the compiler is able to deduce these types from the function's arguments.  As
this is the case with the tt(char (const) *) specializations, they could also
be declared as follows:
        verb(
    template <> char *add(char *const &p1, char *const &p2)
    template <> char const *add(char const *const &p1,
                                char const *const &p2);
        )
    If in addition tt(template <>) could be omitted the template character
would be removed from the declaration. The resulting declaration is now a mere
function declaration. This is not an error: function templates and ordinary
(non-template) functions may mutually overload each other. Ordinary functions
are not as restrictive as function templates with respect to allowed type
conversions. This could be a reason to overload a template with an ordinary
function every once in a while.

    A function template explicit specialization is not just another overloaded
        hi(function template: specialization vs. overloading) version of
the function template. Whereas an overloaded version may define a completely
different set of template parameters, a specialization must use the same set
of template parameters as its non-specialized variant. The compiler uses the
specialization in situations where the actual template arguments match the
types defined by the specialization (following the rule that the most
specialized set of parameters matching a set of arguments will be
used). For different sets of parameters  overloaded versions of functions (or
function templates) must be used.
