假设所有 T 的 sizeof(std::unordered_map<std::string, T>) 都相同实际上是安全的吗？

Question

我处于这样一种情况，我在两个类的定义之间有一个循环依赖循环，其中（据我所知）两个类都需要另一个类型一个完整的类型，以便正确定义它们。

简而言之，我需要的是正在发生的事情的简化版本：

struct Map;

struct Node {
    // some interface...
private:
    // this cannot be done because Map is an incomplete type
    char buffer[sizeof(Map)];
    // plus other stuff...
    void* dummy;
};

struct Map {
    // some interface...
private:
    // this is Map's only member
    std::unordered_map<std::string, Node> map_;
};

情况其实比上面的更复杂，因为Node实际上是一个变体类型（类似于boost::variant），它使用placement new来显式构造多种类型之一预分配（并具有适当的对齐方式，我在此简化中忽略了这一点）缓冲区中的对象：因此缓冲区不完全是 sizeof(Map) 而是一些计算常量，它依赖于 sizeof(Map).

问题很明显，当 Map 仅向前声明时，sizeof(Map) 不可用。此外，如果我将声明的顺序更改为先转发声明 Node，则 Map 的编译将失败，因为当 Node 是不完整类型时无法实例化 std::unordered_map<std::string, Node>，至少我的 GCC 4.8.2 在 Ubuntu 上。（我知道它更依赖于 libstdc++ 版本而不是 GCC 版本，但我不知道如何找到它...）

作为替代方案，我正在考虑以下解决方法：

struct Node {
    // some interface...
private:
    // doing this instead of depending on sizeof(Map)
    char buffer[sizeof(std::unordered_map<std::string, void*>)];
    // other stuff...
    void* dummy;
};

struct Map {
    // some interface...
private:
    // this is Map's only member
    std::unordered_map<std::string, Node> map_;
};

// and asserting this after the fact to make sure buffer is large enough
static_assert (sizeof(Map) <= sizeof(std::unordered_map<std::string, void*>),
    "Map is unexpectedly too large");

这基本上依赖于 std::unordered_map<std::string, T> 对所有 T 大小相同的假设，这在我使用 GCC 的测试中似乎成立。

因此我的问题有三个方面：

C++ 标准中是否有任何内容要求此假设成立？（我假设没有，但如果有我会惊喜...）
如果不是，实际上是否可以安全地假设它对所有合理的实现都适用，并且我修订版本中的静态断言永远不会触发?
最后，有没有我没有想到的更好的解决这个问题的方法？我敢肯定，有可能我可以做一些我没有想到的明显的事情，但不幸的是我想不出任何东西...

Answer 1

1) 否

2) 我不确定

3) 你也可以使用设计模式工厂方法。您的工厂将 return 基于 Map 变体的对象（编辑：我的意思是您将使用 Map 变体实例作为参数，工厂方法实现将使用该信息相应地创建 return 对象）并且它可以预分配缓冲区到正确的大小。

Answer 2

1) 否

2) STL 容器不能用不完整的类型实例化。但是，显然某些编译器确实允许这样做。不允许这不是一个微不足道的决定，在许多情况下，您的假设确实成立。 This 文章可能会让您感兴趣。鉴于根据标准，如果不添加间接层就无法解决此问题，而您不想这样做。只能提个醒，你确实不按标准做事

话虽如此，我认为您的解决方案是使用 stl 容器的最佳解决方案。当大小确实超过预期大小时，静态断言确实会发出警告。

3) 是的，通过添加另一层间接寻址，我的解决方案如下：

您遇到的问题是对象的大小取决于其数组的大小。假设您有一个对象 A 和一个对象 B：

struct A
{
   char sizeof[B]
}

struct B
{
    char sizeof[A]
}

对象 A 会增长，以便容纳 B 大小的字符。但是反过来对象 B 也必须增长。我想你可以看到这是怎么回事。我知道这正是您的问题，但我认为基本原理非常相似。

在这种特殊情况下，我会通过更改

来解决它

char buffer[sizeof(Map)];

线只是一个指针：

char* buffer

并在初始化后动态分配内存。 Sow 你的 cpp 文件看起来像这样：

//node.cpp
//untested code
node::node()
{
    buffer = malloc(sizeof(map));
}

node::~node()
{
    free buffer;
}

Answer 3

1) 可能不会

2) 因为它看起来完全依赖于实现，所以这是一个很大的风险，因为这可能会在任何编译器更新时崩溃。

3) 您可以使用 boost::unordered_map 接受不完整的类型，从而解决您的问题。

Answer 4

继续假设吧。那么static_assert在构造你是对的。

还有更高级的解决方案，例如弄清楚 boost 递归数据结构的工作原理并在此处应用该技术（这可能需要编写您自己的映射），或者仅使用支持不完整数据结构的 boost:: 容器。

假设所有 T 的 sizeof(std::unordered_map<std::string, T>) 都相同实际上是安全的吗？

Practically safe to assume sizeof(std::unordered_map<std::string, T>) is the same for all T?

c++

stl

language-lawyer

c++11