使用调试断言时避免 ODR 违规

Question

我有一个仅头文件的库，它在调试模式下编译时启用了一些额外的快速失败运行时断言。标头的简化版本如下所示：

#include <exception>

#ifdef MYDEBUG
#   define MYASSERT(condition) do{ if (!(condition)) std::terminate(); } while(0)
#else
#   define MYASSERT(condition)
#endif

template<typename T>
class Checker
{
public:

    T operator()(T value)
    {
        MYASSERT(value);
        return value;
    }
};

如果一个翻译单元在没有首先定义MYDEBUG 的情况下包含标头，而另一个在定义MYDEBUG 后包含标头，并且我将生成的目标文件链接在一起，这是否构成ODR 违规？

如何避免这种情况，但仍允许每个 TU 在包含标头时独立指定其所需的断言设置？

Answer 1

如果一个翻译单元在没有首先定义MYDEBUG 的情况下包含标头，而另一个在定义MYDEBUG 后包含标头，并且我将生成的目标文件链接在一起，这是否构成ODR 违规？

是的，这违反了单一定义规则。这违反了内联函数的规则，即内联函数定义必须在所有翻译单元中具有准确的标记。

如何避免这种情况，但仍允许每个 TU 在包含标头时独立指定其所需的断言设置？

一种处理方法是将MYASSERT 定义为文件范围的static 函数。

#ifdef MYDEBUG
static void MYASSERT(bool condition)
{
   if (!(condition))
   {
      std::terminate();
   }
}
#else
static void MYASSERT(bool condition)
{
   // Noop
}
#endif

看来你不能。谢谢，@RustyX。

Answer 2

解决方案 1： 使用范围：

#ifdef MYDEBUG
#   define MYASSERT(condition) do{ if (!(condition)) std::terminate(); } while(0)
#else
#   define MYASSERT(condition)
#endif

namespace {
  template<typename T>
  class Checker
  {
  public:
      T operator()(T value)
      {
          MYASSERT(value);
          return value;
      }
  };
}

这实质上将Checker 更改为内部链接，并且可能会带来额外的成本，即它可能会多次出现在最终的可执行文件中。但是，在这种特殊情况下，没有额外的成本，因为它可能无论如何都会被内联。

解决方案2：在调试模式下参数化模板：

（更新 3：感谢@Jarod42 的建议，使用模板特化）

#ifdef MYDEBUG
#   define MYASSERT(condition) do{ if (!(condition)) std::terminate(); } while(0)
#   define MYDEBUG_FLAG true
#else
#   define MYASSERT(condition)
#   define MYDEBUG_FLAG false
#endif

template<typename T, bool = MYDEBUG_FLAG> class Checker;

template<typename T>
class Checker<T, MYDEBUG_FLAG>
{
public:
    T operator()(T value)
    {
        MYASSERT(value);
        return value;
    }
};

那么调试和非调试实例将相互独立。

这样做的好处是，即使不小心实例化了Checker<T, !MYDEBUG_FLAG>，它也不会编译，因此不会违反 ODR（前提是每个 TU 中只定义了一个版本，无论是调试还是非调试） )。

Answer 3

第一个 RustyX 答案的变体，但我认为已修复：

#ifdef MYDEBUG
#   define MYDEBUG_FLAG true
#else
#   define MYDEBUG_FLAG false
#endif

#define MYASSERT(condition) do{ if (!(condition)) std::terminate(); } while(0)

// Following declaration differs, but doesn't break ODR.
template<typename T, bool = MYDEBUG_FLAG> class Checker;

// And both definitions of specialization.
template <typename T>
class Checker<T, true>
{
public:

    T operator()(T value)
    {
        MYASSERT(value);
        return value;
    }
};

template <typename T>
class Checker<T, false>
{
public:

    T operator()(T value)
    {
        return value;
    }
};