编译时生成应在构造函数中创建的非constexpr对象的数组

Question

您已经做了一个结构示例，看起来像这样：

#include <array>
enum class ItemType
{
  Tree,
  Bush,
  Flower,
  Grass,
  Mushroom,
  CountOfTypes
};

class Items;

class Item
{
public:
  Item(Items* parentContainer, ItemType type) : parentContainer(parentContainer), type(type) { DoSomething(); }
  ItemType type;
  // Parent container needs to be acessed occasionally
  Items* parentContainer;
  // This cannot be constexpr
  void DoSomething();
};

class Items
{
public:
  using ItemArray = std::array<Item, ItemType::CountOfTypes>;
  // Should contain one item per type, at index equal to that type
  ItemArray items;
};

请注意对数组内容的要求，对于items数组，必须始终为true：

ItemType someType = ... any of item type enum except of CountOfTypes ...;
/// must be true
items[(size_t)someType].type == someType;

此代码将无法编译，因为Item没有默认构造函数，但我们尝试在Items::Items中进行分配。即使可以编译，这些值也不会被初始化，我们不希望这样。

解决该问题的一种方法是按正确的顺序手动枚举类型：

class Items
{
public:
  Item items[(size_t)ItemType::CountOfTypes] = { {this, ItemType::Tree}, {this, ItemType::Bush}, {this, ItemType::Grass}, {this, ItemType::Mushroom} };
};

另一个选择是添加默认的构造函数，然后调用一些初始化函数。我也不喜欢。

但是我过去已经使用过std::make_integer_sequence了，我会尝试再做一次。如果上面的代码有效，则应按一定顺序生成它。因此，我尝试了这个：

class Items
{
public:
  using ItemArray = std::array<Item, (size_t)ItemType::CountOfTypes>;
  template <int... Indices>
  static ItemArray GenerateItems(std::integer_sequence<int, Indices...>, Items* parent) { return { ({parent, Indices})... }; }

  ItemArray items = GenerateItems(std::make_integer_sequence<int, static_cast<int>(ItemType::CountOfTypes)>{}, this);
};

这是基于我以前使用此功能的情况。我不确定这是否是正确的方法。

我在Visual Studio中遇到的错误是：

1>o:\projects\cpptest\cpptest\cpptest\arraywiththis.cpp(30): error C2760: syntax error: unexpected token '{', expected 'expression'
1>o:\projects\cpptest\cpptest\cpptest\arraywiththis.cpp(30): note: This diagnostic occurred in the compiler generated function 'Items::ItemArray Items::GenerateItems(std::integer_sequence<int,Indices...>,Items *)'

海湾合作委员会更加直言不讳（他们的错误信息在过去6年中得到了不可思议的改善：]

PS O:\projects\cpptest\CPPTest\CPPTest> g++ .\ArrayWithThis.cpp
.\ArrayWithThis.cpp: In static member function 'static Items::ItemArray Items::GenerateItems(std::integer_sequence<int, Indices ...>, Items*)':
.\ArrayWithThis.cpp:30:117: error: expected ';' before '}' token
   static ItemArray GenerateItems(std::integer_sequence<int, Indices...>, Items* parent) { return { ({parent, Indices})... }; }
                                                                                                                     ^
                                                                                                                     ;
.\ArrayWithThis.cpp: In instantiation of 'static Items::ItemArray Items::GenerateItems(std::integer_sequence<int, Indices ...>, Items*) [with int ...Indices = {0, 1, 2, 3}; Items::ItemArray = std::array<Item, 4>]':
.\ArrayWithThis.cpp:32:116:   required from here
.\ArrayWithThis.cpp:30:123: error: could not convert '{((void)0, 0), ((void)0, 1), ((void)0, 2), ((void)0, 3)}' from '<brace-enclosed initializer list>' to 'Items::ItemArray' {aka 'std::array<Item, 4>'}
   static ItemArray GenerateItems(std::integer_sequence<int, Indices...>, Items* parent) { return { ({parent, Indices})... }; }

尤其是在困扰我：((void)0, 0)为什么无效？

我正在尝试做的可能吗？如果是，该如何解决我的代码？

Answer 1

您有多余的括号；可能是：

class Items
{
public:
  static constexpr std::size_t ItemCount = static_cast<std::size_t>(ItemType::CountOfTypes);
  using ItemArray = std::array<Item, ItemCount>;

  template <std::size_t ... Is>
  static ItemArray GenerateItems(std::index_sequence<Is...>, Items* parent)
  { return {{ Item{parent, Indices}... }}; }

  ItemArray items = GenerateItems(std::make_index_sequence<ItemCount>{}, this);
};