AutosarC++18_03-A14.7.2

Template specialization shall be declared in the same file (1) as the primary template (2) as a user-defined type, for which the specialization is declared

Required inputs: IR

Rationale

It is undefined behavior, when a compiler sees the (partial or explicit) template specialization after it already has instantiated the primary or less specialized template.

Moreover, the case (2) allows compile-time interfaces to be extensible, as developers can safely provide custom specializations e.g. for traits classes or std::hash.

Example
// $Id: A14-7-2.cpp 312645 2018-03-21 11:44:35Z michal.szczepankiewicz $
#include <cstdint>

// in A.hpp

#include <functional>

struct A {
  std::uint8_t x;
};

namespace std {

// compliant, case (2)
// template specialization for the user-defined type
// in the same file as the type declaration
template <> struct hash<A> {
  size_t operator()(const A &a) const noexcept {
    return std::hash<decltype(a.x)>()(a.x);
  }
};

} // namespace std

// traits.hpp

#include <cstdint>
#include <type_traits>

template <typename T> struct is_serializable : std::false_type {};

// compliant, case (1)
template <> struct is_serializable<std::uint8_t> : std::true_type {};

// func.cpp

#include <vector>

// non-compliant, not declared
// in the same file as
// is_serializable class
template <> struct is_serializable<std::uint16_t> : std::true_type {};

template <typename T, typename = std::enable_if<is_serializable<T>::value>>
std::vector<std::uint8_t> serialize(const T &t) {
  // only a basic stub
  return std::vector<std::uint8_t>{t};
}

#include <string>
int main() { serialize(std::uint8_t{3}); }
See Also
  • MISRA C++ 2008 [6]: Rule 14-7-2 (Required) For any given template specialization, an explicit instantiation of the template with the template arguments used in the specialization shall not render the program ill-formed.

Possible Messages

Key

Text

Severity

Disabled

template_specialization_in_different_file

Specialization not declared in same file as primary template

None

False

Options

allow_in_directly_included_files

allow_in_directly_included_files : bool = False

This option allows to relax the expected file to be any file that is directly included from the primary file or a type declaration file if applicable via the option allow_in_type_declaration_file and its modification only_fully_specialized_with_class.
 

allow_in_type_declaration_file

allow_in_type_declaration_file : bool = True

Also allow specialications in the same file of a user-defined type for which the specialization is declared.
 

only_fully_specialized_with_class

only_fully_specialized_with_class : bool = False

If this option is set to true, only full specialications with a class name within the same file of the class are allowed. This option modifies the option allow_in_type_declaration_file and has no effect if allow_in_type_declaration_file is false.
 

relax_if_template_only_declared

relax_if_template_only_declared : bool = False

Allow specializations that are not declared in the header file if the template itself is only declared but not defined in the header.