使用调试断言时避免 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;
    }
};