模板专业化违反ODR

Question

We have a header file which contains some residuals for various floating point precisions:

template <typename T>
struct rsdTarget {
  static const double value;
};

template <>
const double rsdTarget<half>::value = (double)(1.0e-3);

template <>
const double rsdTarget<float>::value = (double)(1.0e-7);

template <>
const double rsdTarget<double>::value = (double)(1.0e-12);

This has worked because this header had only been included in a single compilation unit. Now I try to use this header in multiple compilation units and I get linker errors stemming from the ODR:

CMakeFiles/tests_g.dir/random_gauge.cc.o:(.rodata+0x108): multiple definition of `rsdTarget<double>::value'
CMakeFiles/tests_g.dir/clover_product.cc.o:(.rodata+0x548): first defined here

The initialization probably needs to go into a source file and be taken out of the header file. However it seems to be prohibited to but an extern in front of the const double .

What would I have to do such that this works with multiple compilation units?

Update

I thought that solving this for double would fix it fully. However, there is a second non-literal type which I also have to carry through:

template <typename T>
struct tolerance {
  static const QDP::Double small; // Always fail
};

template <>
const QDP::Double tolerance<half>::small = QDP::Double(5.0e-3);

template <>
const QDP::Double tolerance<float>::small = QDP::Double(1.0e-6);

template <>
const QDP::Double tolerance<double>::small = QDP::Double(1.0e-7);

I cannot seem to use that with constexpr because that type does not support it ( constexpr ctor needed, right?). Which of the solutions works with this as well?

Answer 1

You can allow all these definitions reside in the header file without causing linker errors when it is used in multiple translation units, you just need to turn them into templates as well:

template<typename T, typename TDummy = void>
struct rsdTarget;

template<typename TDummy>
struct rsdTarget<half, TDummy>
{
    static const double value;
};

template<typename TDummy>
const double rsdTarget<half, TDummy>::value = (double)(1.0e-3);

template<typename TDummy>
struct rsdTarget<float, TDummy>
{
    static const double value;
};

template<typename TDummy>
const double rsdTarget<float, TDummy>::value = (double)(1.0e-7);

template<typename TDummy>
struct rsdTarget<double, TDummy>
{
    static const double value;
};

template<typename TDummy>
const double rsdTarget<double, TDummy>::value = (double)(1.0e-12);

Answer 2

Prior C++1z

template<typename>
struct rsdTarget;

template<>
struct rsdTarget<half>
{
    static constexpr double value = 1e-3;
};

// and so on...

This has a restriction that value cannot be odr-used, but in most cases, this is not a problem for constants.

Post C++1z, you could just use inline variables and avoid the whole odr fiasco.