【发布时间】：2023-04-05 19:26:01
【问题描述】：
通过以下代码示例，我们在 GCC 中看到了一些奇怪的行为。奇怪的行为是 GCC 6.3.0 中的 ODR 违规，其类型在两个单独的翻译单元中定义。它可能与递归类型定义或不完整类型有关。
我们不确定我们的代码是否有效，或者我们是否依赖于递归定义类型的方式中的未定义行为。请查看如何在两个单独的 cpp 文件中定义和实例化类似变体的动态类模板。
dynamic_test.h：
#pragma once
#include <algorithm>
#include <type_traits>
namespace dynamic
{
template <class T>
void erasure_destroy( const void *p )
{
reinterpret_cast<const T*>( p )->~T();
}
template <class T>
void erasure_copy( void *pDest, const void *pSrc )
{
::new( pDest ) T( *reinterpret_cast<const T*>( pSrc ) );
}
template <class T>
struct TypeArg {};
struct ErasureFuncs
{
template <class T = ErasureFuncs>
ErasureFuncs( TypeArg<T> t = TypeArg<T>() ) :
pDestroy( &erasure_destroy<T> ),
pCopy( &erasure_copy<T> )
{
(void)t;
}
std::add_pointer_t<void( const void* )> pDestroy;
std::add_pointer_t<void( void*, const void* )> pCopy;
};
enum class TypeValue
{
Null,
Number,
Vector
};
template <typename T>
using unqual = std::remove_cv_t<std::remove_reference_t<T>>;
template <class Base, class Derived>
using disable_if_same_or_derived = std::enable_if_t<!std::is_base_of<Base, unqual<Derived>>::value>;
template <template <class> class TypesT>
struct Dynamic
{
using Types = TypesT<Dynamic>;
using Null = typename Types::Null;
using Number = typename Types::Number;
using Vector = typename Types::Vector;
Dynamic()
{
construct<Null>( nullptr );
}
~Dynamic()
{
m_erasureFuncs.pDestroy( &m_data );
}
Dynamic( const Dynamic &d ) :
m_typeValue( d.m_typeValue ),
m_erasureFuncs( d.m_erasureFuncs )
{
m_erasureFuncs.pCopy( &m_data, &d.m_data );
}
Dynamic( Dynamic &&d ) = delete;
template <class T, class = disable_if_same_or_derived<Dynamic, T>>
Dynamic( T &&value )
{
construct<unqual<T>>( std::forward<T>( value ) );
}
Dynamic &operator=( const Dynamic &d ) = delete;
Dynamic &operator=( Dynamic &&d ) = delete;
private:
static TypeValue to_type_value( TypeArg<Null> )
{
return TypeValue::Null;
}
static TypeValue to_type_value( TypeArg<Number> )
{
return TypeValue::Number;
}
static TypeValue to_type_value( TypeArg<Vector> )
{
return TypeValue::Vector;
}
template <class T, class...Args>
void construct( Args&&...args )
{
m_typeValue = to_type_value( TypeArg<T>() );
m_erasureFuncs = TypeArg<T>();
new ( &m_data ) T( std::forward<Args>( args )... );
}
private:
TypeValue m_typeValue;
ErasureFuncs m_erasureFuncs;
std::aligned_union_t<0, Null, Number, Vector> m_data;
};
}
void test1();
void test2();
dynamic_test_1.cpp：
#include "dynamic_test.h"
#include <vector>
namespace
{
template <class DynamicType>
struct Types
{
using Null = std::nullptr_t;
using Number = long double;
using Vector = std::vector<DynamicType>;
};
using D = dynamic::Dynamic<Types>;
}
void test1()
{
D::Vector v1;
v1.emplace_back( D::Number( 0 ) );
}
dynamic_test_2.cpp：
#include "dynamic_test.h"
#include <vector>
namespace
{
template <class DynamicType>
struct Types
{
using Null = std::nullptr_t;
using Number = double;
using Vector = std::vector<DynamicType>;
};
using D = dynamic::Dynamic<Types>;
}
void test2()
{
D::Vector v1;
v1.emplace_back( D::Number( 0 ) );
}
main.cpp:
#include "dynamic_test.h"
int main( int, char* const [] )
{
test1();
test2();
return 0;
}
运行此代码会导致 SIGSEGV 带有以下堆栈跟踪：
1 ?? 0x1fa51
2 dynamic::Dynamic<(anonymous namespace)::Types>::~Dynamic dynamic_test.h 66 0x40152b
3 std::_Destroy<dynamic::Dynamic<(anonymous namespace)::Types>> stl_construct.h 93 0x4013c1
4 std::_Destroy_aux<false>::__destroy<dynamic::Dynamic<(anonymous namespace)::Types> *> stl_construct.h 103 0x40126b
5 std::_Destroy<dynamic::Dynamic<(anonymous namespace)::Types> *> stl_construct.h 126 0x400fa8
6 std::_Destroy<dynamic::Dynamic<(anonymous namespace)::Types> *, dynamic::Dynamic<(anonymous namespace)::Types>> stl_construct.h 151 0x400cd1
7 std::vector<dynamic::Dynamic<(anonymous namespace)::Types>>::~vector stl_vector.h 426 0x400b75
8 test2 dynamic_test_2.cpp 20 0x401796
9 main main.cpp 6 0x400a9f
奇怪的是，构造 Vector 会直接将我们带到析构函数。
非常奇怪的是，当我们执行以下操作时，这些错误就会消失：
- 在其中一个 cpp 文件中重命名“类型”，这样它们就不会使用 类模板的名称相同。
- 在每个 cpp 文件中使“类型”的实现相同（更改 每个文件中要加倍的数字）。
- 不要将数字推送到向量。
- 将 Dynamic 的实现更改为不使用此递归类型 定义风格。
这是一个有效的实现的精简示例：
template <class Types>
struct Dynamic
{
using Null = typename Types::Null;
using Number = typename Types::Number;
using Vector = typename Types::template Vector<Dynamic>;
...
struct Types
{
using Null = std::nullptr_t;
using Number = long double;
template <class DynamicType>
using Vector = std::vector<DynamicType>;
};
当我们使用链接时间优化 (LTO) 进行编译时，我们还会看到一些与 ODR 违规相关的警告：
dynamic_test.h:51: warning: type ‘struct Dynamic’ violates the C++ One Definition Rule [-Wodr]
struct Dynamic
^
是否有人对可能导致此问题的原因有所了解？
【问题讨论】：
-
看起来它可能在内部将它们视为同一类型；如果是这样，它可能是编译器错误，但我不能 100% 确定标准对此有何规定。不过，只是猜测，我没有安装 GCC，而且我所知道的唯一允许多个文件的在线 GCC 环境已经过时。
-
源文件中的两个不同命名的命名空间（而不是匿名命名空间）是否也能解决问题？
-
如果在命令行中改变dynamic_test.cpp文件的顺序，是否会改变segfault来自哪个测试？
-
您还应该提供您在此处使用的编译和链接命令，以使您的复制案例完整。还要尝试将链接和编译分离为单独的步骤。编译 .o 文件后，您应该在它们上运行
nm。nm应显示符号Types和小写字母 t。 -
@ethortsen 如果更改排序更改哪个测试导致段错误，第二个链接的测试是段错误，最有可能发生的是第一个链接的
Types的定义是在第二个链接中使用。我不希望这种情况发生在具有内部联系的事情上，这就是我询问 nm 的原因。我试图在本地进行复制，但失败了（不同的操作系统，不同的 gcc，谁知道）。您可以尝试为每个Types不同地定义一个静态字符串，并将其打印为测试的一部分以尝试证明它。
标签： c++ gcc g++ one-definition-rule