-1

我认为最简单的提问方式是举个例子。假设我们有以下类型：

class Node
{
  // make noncopyable
  Node(const Node& ref) = delete;      
  Node& operator=(const Node& ref) = delete;

  // but moveable
  Node(Node&& ref) = default;
  Node& operator=(Node&& ref) = default;

  // we do not have a default construction
  Node() = delete;
  Node(unsigned i): _i(i) {}

  unsigned _i;
};

现在我想将其中一些节点存储在 std::array 中：

template<unsigned count>
class ParentNode
{
  std::array<Node,count> _children;
  ParentNode() 
     // i cannt do this, since i do not know how many nodes i need
     // : _children{{Node(1),Node(2),Node(3)}}  
     : _children()  // how do i do this?
  {}
};

如评论中所述，问题是：我该怎么做？传递给孩子的无符号应该是存储孩子的数组的索引。但也非常感谢更通用的解决方案！

我发现自己的以下解决方案可能会导致更复杂类型的未定义行为。有关正确定义的解决方案，请参阅接受的答案。

template<unsigned count>
class ParentNode
{
public:
   // return by value as this will implicitly invoke the move operator/constructor
   std::array<Node,count> generateChildren(std::array<Node,count>& childs)
   {
      for (unsigned u = 0; u < count; u++)
         childs[u] = Node(u);  // use move semantics, (correct?)

      return std::move(childs); // not needed
      return childs;  // return by value is same as return std::move(childs)
   }

  std::array<Node,count> _children;

  ParentNode() 
     // i cannt do this, since i do not know how many nodes i need
     // : _children{{Node(1),Node(2),Node(3)}}  
     : _children(generateChildren(_children))  // works because of move semantics (?)
  {}
};

ParentNode<5> f;

代码确实编译。但我不确定它是否符合我的预期。也许对移动语义和右值引用有深入了解的人可以添加一些评论:-)

4

2 回答 2

1

您可以使用可变参数生成一个array初始化为索引的任意函数的元素。使用标准机制生成索引序列：

template <int... I> struct indices {};
template <int N, int... I> struct make_indices :
  make_indices<N-1,N-1,I...> {};
template <int... I> struct make_indices<0,I...> : indices<I...> {};

这很简单：

template <typename T, typename F, int... I>
inline std::array<T, sizeof...(I)> array_maker(F&& f, indices<I...>) {
  return std::array<T, sizeof...(I)>{ std::forward<F>(f)(I)... };
}

template <typename T, std::size_t N, typename F>
inline std::array<T, N> array_maker(F&& f) {
  return array_maker<T>(std::forward<F>(f), make_indices<N>());
}

这让我们可以从复制以下效果做任何事情std::iota：

auto a = array_maker<int,10>([](int i){return i;});

以倒序排列前 10 个自然数的平方的数组：

const auto a = array_maker<std::string,10>([](int i){
  return std::to_string((10 - i) * (10 - i));
});

由于您Node是可移动的，因此您可以将ParentNode构造函数定义为：

ParentNode() 
   : _children(array_maker<Node, count>([](unsigned i){return i+1;}))
{}

在 Coliru 现场观看这一切。

于 2013-08-10T15:29:18.920 回答
-1

真的，你无能为力。你想把一个没有默认构造函数的类型放入一个大小由模板参数确定的数组中，然后想用一些任意值初始化元素，你把自己画到了一个角落。

没有任何东西可以从一个函数返回，它可以放入一个花括号初始化列表并用于初始化一个具有多个元素的数组（或任何类型的聚合）。{}不代表“ initializer_list”。它是一个花括号初始化列表，在某些情况下可以成为一个initializer_list，但它也可以成为构造函数调用的参数或在聚合初始化中使用的元素。

您最好的选择实际上是只使用 avector并使用循环手动初始化它。

于 2013-08-10T12:29:33.497 回答