为什么 C++ 链接器对 ODR 违规保持沉默?

Why C++ linker is silent about ODR violation?

让我们考虑一些综合但富有表现力的例子。假设我们有 Header.h:

Header1.h

#include <iostream>

// Define generic version
template<typename T>
inline void Foo()
{
    std::cout << "Generic\n";
}

Header2.h

void Function1();

Header3.h

void Function2();

Source1.cpp

#include "Header1.h"
#include "Header3.h"

// Define specialization 1
template<>
inline void Foo<int>()
{
    std::cout << "Specialization 1\n";
}

void Function1()
{
    Foo<int>();
}

稍后我或其他人在另一个源文件中定义了类似的转换。 Source2.cpp

#include "Header1.h"

// Define specialization 2
template<>
inline void Foo<int>()
{
    std::cout << "Specialization 2\n";
}

void Function2()
{
    Foo<int>();
}

main.cpp

#include "Header2.h"
#include "Header3.h"

int main()
{
    Function1();
    Function2();
}

问题是什么将打印 Function1() 和 Function2()?答案是未定义的行为。

我希望在输出中看到: 专业化1 专精 2

但我看到: 专精2 专精 2

为什么 C++ 编译器对 ODR 违规保持沉默?在这种情况下,我希望编译失败。

我只找到一种解决方法:在未命名的命名空间中定义模板函数。

编译器是静默的,因为它不需要通过[basic.def.odr/4]发出任何东西:

Every program shall contain exactly one definition of every non-inline function or variable that is odr-used in that program outside of a discarded statement; no diagnostic required. The definition can appear explicitly in the program, it can be found in the standard or a user-defined library, or (when appropriate) it is implicitly defined (see [class.ctor], [class.dtor] and [class.copy]). An inline function or variable shall be defined in every translation unit in which it is odr-used outside of a discarded statement.

在极少数情况下,违反 ODR 可能很有用。

例如,您可以使用 std::aligned_storage<MyPimplType_sizeof, MyPimplType_alignof> 代替 std::unique_ptr<MyPimplType> 并在 MyPimplType class 的 constructor/destructor 中测试真实的 sizeof 和对齐方式。这叫做 aligned storage pimpl 或类似的东西。当您想用 impl-by-value(对齐存储而不是 impl)替换 impl-by-pointer(通过指向 impl 的智能指针)时很有用。

接下来,您可以创建新类型的对齐存储,它可以在它的 constructor/destructor:

中自动测试 sizeof 和对齐

private/my_aligned_storage_by_decl.hpppublic/my_aligned_storage_by_decl.hpp

template <typename incomplete_type_to_align, size_t sizeof_, size_t alignof_>
class my_aligned_storage_by { ... };

private/my_aligned_storage_by_impl.hpp

// incomplete_type_to_align must be already complete here!
template <typename incomplete_type_to_align, size_t sizeof_, size_t alignof_>
my_aligned_storage_by<...>::my_aligned_storage_by(...) {
    static_assert(sizeof_ == sizeof(incomplete_type_to_align), ...);
    static_assert(alignof_ == std::alignment_of<incomplete_type_to_align>::value, ...);
}

这可以达到只能通过违反 ODR 并且如果 public 和私有 header 不能合并为一个 header,其中 public 和私有 header 具有相同 my_aligned_storage_by class.

2 个不同定义

实现: https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/include/tacklelib/tackle/aligned_storage/
https://github.com/andry81/tacklelib/tree/trunk/include/tacklelib/tackle/aligned_storage/

用法示例:

include/myheader.hpp

#include <tacklelib/tackle/aligned_storage/public/aligned_storage_by_decl.hpp>

#define MYCLASS_SIZEOF  ...
#define MYCLASS_ALIGNOF ...

class MyClass
{
  // public methods...
  MyClass(...);

  // replacement as impl-by-value:
  struct This;
  tackle::aligned_storage_by<This,
    MYCLASS_SIZEOF,
    MYCLASS_ALIGNOF,
    tackle::tag_pttn_control_lifetime> m_this;
};

void myfoo(const MyClass & myboo);

src/_impl/myheader_this.hpp

#include <myheader.hpp>

struct MyClass::This
{
  // data members and private function of class MyClass is placed here...
};

src/MyClass.cpp

#include <tacklelib/tackle/aligned_storage/private/aligned_storage_by_decl.hpp>

#include <src/_impl/MyClass_this.hpp>

#include <tacklelib/tackle/aligned_storage/private/aligned_storage_by_impl.hpp>

// public methods implementation...

MyClass::MyClass()
{
  m_this.construct_default();
}

MyClass::MyClass(...)
{
  m_this.construct(This{...});
}

void myfoo(const MyClass & myboo)
{
  auto & realboo = *myboo.m_this.this_();
  // deal with realboo...
}

以下是这种方法的一些主要缺点:

  1. 您必须将包含 class 且 my_aligned_storage 作为成员的 header 拆分为 public/private header 并离开public headers 用于 SDK,但将私有的一个包含到 cpp 文件中而不是 public。 (*)

  2. 您已明确控制此类 header 的包含顺序,因为可以静默包含私有 header 而不是 public(但不是副反之亦然)。

  3. 只有当类型变得完全完整时,您才必须包含 sizeof/alignment 测试断言的实现,这有时并不总是可能的。

  4. 你明确指定了sizeof和alignment,在不同的上下文中可以不同,例如debug/release、windows/linux、msvc/gcc等。

(*) 如果 public 和 my_aligned_storage 的私有 header 无法合并为单个 public 声明 header.

在对齐用户 class 确实不大且经常 constructed/assigned/copied 的情况下,这些缺点可以避免或忽略,例如内置类型。