包含自身映射的 C++ 结构

Question

简单的问题：我如何让它工作？

struct A {
    double whatever; 
    std::unordered_map<std::string, A> mapToMoreA; 
}

g++ 错误：std::pair<_t1 _t2>::second 类型不完整

据我了解，在实例化映射时，编译器需要知道 A 的大小，但它不知道这一点，因为映射是在 A 的声明中声明的，所以解决这个问题的唯一方法是使用指向 A 的指针（不想这样做）？

Answer 1

大多数情况下，这将取决于容器实现细节（更准确地说，取决于在容器声明时实例化的内容和不实例化的内容）。显然，std::unordered_map 的实现要求类型是完整的。同时 GCC 的 std::map 实现在不完整类型的情况下编译得非常好。

为了说明这种差异的来源，请考虑以下示例。假设我们决定自己实现类似std::vector 的功能，并将我们的向量类声明如下

template <typename T> class my_vector {
  T *begin;
  T *end;
  ...
};

只要我们的类定义只包含指向T 的指针，类型T 就不需要对类定义本身来说是完整的。我们可以将my_vector 本身实例化为一个不完整的T 而不会出现任何问题

class X;
my_vector<X> v; // OK

当我们开始使用（并因此实例化）my_vector 的各个方法时，稍后将需要类型的“完整性”。

但是，如果出于某种原因我们决定将 T 的直接实例包含到我们的向量类中，事情就会发生变化

template <typename T>
class my_vector {
  T *begin;
  T *end;
  T dummy_element;
  ...
};

现在很早就需要T 的完整性，在my_vector 本身的实例化点

class X;
my_vector<X> v; // ERROR, incomplete type

在你的情况下一定发生了类似的事情。您正在处理的unordered_map 的定义不知何故包含A 的直接实例。这就是无法实例化的原因（显然，在这种情况下，您最终会得到无限递归类型）。

通过实现unordered_map 更好地考虑将确保不将A 作为直接成员包含在自身中。这样的实现不需要A 就可以完成。正如您自己所指出的，Boost 的 unordered_map 实现在这方面设计得更好。

Answer 2

我不知道除了智能指针之外的任何 STL 容器都可以处理不完整的类型。但是，如果您不想使用指针，则可以使用包装器结构：

struct A {
    struct B { double whatever; }; 
    std::unordered_map<std::string, B> mapToB; 
};

编辑：如果以上不满足您的用例，这里是一个指针替代方案。

struct A {
    double whatever;
    std::unordered_map<std::string, std::unique_ptr<A>> mapToMoreA; 
};

您也可以只使用boost::unordered_map，它不仅支持不完整的类型，而且在 Visual Studio 中具有更高的调试性能，因为 Microsoft 的 std::unordered_map 实现由于过多的迭代器调试检查而效率极低。我不知道这两个容器的 gcc 有任何性能问题。

Answer 3

Boost.Variant 有一个专门用于此目的的方便实用程序 - boost::recusive_wrapper<>。以下应该有效：

struct A {
    double whatever; 
    std::unordered_map<std::string, boost::recursive_wrapper<A>> mapToMoreA; 
};

唯一值得注意的缺点是 Boost.Variant 尚未更新以支持 C++11 移动语义。更新：在 Boost 1.56 中添加。

Answer 4

如果让地图保持指针是不可接受的，也许这对你有用：

struct A {
  struct hidden;
  std::unique_ptr<hidden> pimpl;
};

struct A::hidden {
  double whatever;
  std::unordered_map<std::string, A> mapToMoreA;
};

Answer 5

在 C++ 中，对于不完整的类型，通常使用具有预定义常量大小的指针：

这当然会改变您使用地图的方式：您必须取消引用 * 或 -> 运算符才能访问成员，并且必须在某些时候使用 delete 指针。

struct A
{
    double bla;
    std::map<std::string, A*> mapToMoreA;
};

A 的成员函数应该在 struct 块内拆分成一个原型并稍后实现，否则 A 及其成员尚未完全定义：

struct A
{
    double bla;
    std::map<std::string, A*> mapToMoreA;
    void doStuff(const std::string& str);
};

void A::doStuff(const std::string& str)
{
    mapToMoreA[str] = new A();
}

Answer 6

或者使用指向地图的指针。在这种情况下，指针必须是 void* 类型（可以隐藏在一组函数后面）。也许有 std::unordered_map 的替代品可以处理不完整的值类型。

Answer 7

我认为您可以在定义 struct A; 之前转发它，编译器应该很高兴。

编辑：所以在多次被否决后，我写了以下内容来看看我错过了什么：

#include <boost/unordered_map.hpp>                                                                                      
#include <string>
#include <iostream>

struct A;

struct A {
    double whatever;
    boost::unordered_map<std::string, A> mapToMoreA;
};

int main(void)
{
    A b;
    b.whatever = 2.5;
    b.mapToMoreA["abc"] = b;
    std::cerr << b.mapToMoreA["abc"].whatever << std::endl;
    return 0;
}

这在我的 mac 上使用 g++ 4.2.1 可以很好地编译，并在运行时打印出“2.5”（如预期的那样）。

对不起，我没有 unordered_map 没有提升。是这个问题吗？ （即，std::unordered_map 是否以某种方式对编译器施加了比 boost 更多的约束？）否则，我不确定我在这里遗漏了什么。那些对此表示反对的人，请用cmets启发我。谢谢！