Question

是否有一个固定长度序列的标准容器，其长度在运行时确定。我想将参数传递给每个sequence元素的构造函数，并使用该参数初始化const成员（或引用）。我还想在O（1）中的给定索引处获得序列元素。在我看来，我的所有要求都无法同时满足。

我知道std::array有固定长度，但必须在编译时知道该长度。
std::vector具有动态大小，并允许使用emplace传递构造函数参数。虽然您可以reserve内存以避免实际的重新分配，但理论上类型仍然必须movable才允许这样的重新分配，例如阻止const成员。
然后有std::list和std::forwad_list，它们不需要可移动类型，但仍可调整大小，并且在随机访问模式下执行效果相当差。我还认为这些列表可能会产生相当大的开销，因为每个列表节点可能会单独分配。
奇怪的是，到目前为止std::valarray是我最好的选择，因为它有一个固定的长度，不会自动调整大小。虽然有resize方法，但除非您实际调用该方法，否则您的类型不必移动。这里的主要缺点是缺少自定义构造函数参数，因此使用此方法无法初始化const成员。

我错过了一些替代方案吗？有没有办法以满足我所有要求的方式调整其中一个标准容器？

编辑：为了让您更准确地了解我要做的事情，请参阅此示例：

class A {
  void foo(unsigned n);
};

class B {
private:
  A* const a;
  const unsigned i;
public:
  B(A* aa) : a(aa), i(0) { }
  B(A* aa, unsigned ii) : a(aa), i(ii) { }
  B(const std::pair<A*, unsigned>& args) : B(args.first, args.second) { }
  B(const B&) = delete;
  B(B&&) = delete;
  B& operator=(const B&) = delete;
  B& operator=(B&&) = delete;
};

void A::foo(unsigned n) {
  // Solution using forward_list should be guaranteed to work
  std::forward_list<B> bs_list;
  for (unsigned i = n; i != 0; --i)
    bs_list.emplace_front(std::make_pair(this, i - 1));

  // Solution by Arne Mertz with single ctor argumen
  const std::vector<A*> ctor_args1(n, this);
  const std::vector<B> bs_vector(ctor_args1.begin(), ctor_args1.end());

  // Solution by Arne Mertz using intermediate creator objects
  std::vector<std::pair<A*, unsigned>> ctor_args2;
  ctor_args2.reserve(n);
  for (unsigned i = 0; i != n; ++i)
    ctor_args2.push_back(std::make_pair(this, i));
  const std::vector<B> bs_vector2(ctor_args2.begin(), ctor_args2.end());
}

Answer 1

理论上vector具有您需要的属性。如您所述，如果元素是不可复制的和/或不可分配的，则不支持可能对所包含类型进行分配的操作，尤其包括任何序列修改（empace_back，push_back，insert等）。因此，要创建不可复制元素的向量，您必须在向量构造期间构造每个元素。

正如Steve Jessop在他的回答中指出的那样，如果你首先定义向量const，你甚至无法调用这样的修改动作 - 当然元素也保持不变。

如果我理解正确，你只有一系列构造函数参数，而不是真正的对象序列。如果它只是一个参数并且包含的类型具有相应的构造函数，那么事情应该很容易：

struct C
{
  const int i_;  
  C(int i) : i_(i) {}
};

int main()
{
  const std::vector<C> theVector { 1, 2, 3, 42 };
}

如果构造函数是显式的，则必须先创建一个列表，或者在initializer-list中显式构造对象：

int main()
{
  auto list = { 1, 2, 3, 4 };
  const std::vector<C> theVector (std::begin(list), std::end(list));
  const std::vector<C> anotherVector { C(1), C(44) };
}

如果每个构造对象只有一个参数，请考虑一个中间创建者对象：

struct C
{
  const int i_;  
  C(int i, int y) : i_(i+y) {}
};

struct CCreator
{ 
  int i; int y; 
  explicit operator C() { return C(i,y); }
};

int main()
{
  const std::vector<CCreator> ctorArgs = { {1,2}, {3,42} };
  const std::vector<C> theVector { begin(ctorArgs), end(ctorArgs) };
}

Answer 2

我认为const std::vector<T>具有您要求的属性。它的元素实际上并没有用const 定义，但它提供了它们的const视图。你无法改变大小。你不能调用任何需要T的成员函数来移动，所以对于正常使用它们不会被实例化（如果你做了extern类声明，那么你可以不这样做。

如果我错了，并且由于T无法移动而确实遇到问题，请尝试使用const std::deque<T>。

困难在于构建更加光明 - 在C ++ 11中，您可以使用初始化列表执行此操作，或者在C ++ 03中，您可以从非const向量或其他任何内容构造const vector你可以得到迭代器。这并不一定意味着T需要是可复制的，但确实需要一种可以构造它的类型（可能是你为此目的而发明的一种）。

Answer 3

使用std::shared_ptr添加间接级别。可以像往常一样复制和分配共享指针，但不需要修改指向的对象。这样您就不会有任何问题，如下例所示：

class a
{
public:
    a(int b) : b(b) { }

    // delete assignment operator
     a& operator=(a const&) = delete;

private:
    // const member
    const int b;
};

// main
std::vector<std::shared_ptr<a>> container;

container.reserve(10);
container.push_back(std::make_shared<a>(0));
container.push_back(std::make_shared<a>(1));
container.push_back(std::make_shared<a>(2));
container.push_back(std::make_shared<a>(3));

另一个优点是函数std::make_shared，它允许您使用任意数量的参数创建对象。

修改

正如MvG所说，人们也可以使用std::unique_ptr。使用boost::indirect_iterator可以通过将元素复制到新的向量中来删除间接：

void A::foo(unsigned n) { std::vector<std::unique_ptr<B>> bs_vector; bs_vector.reserve(n); for (unsigned i = 0; i != n; ++i) { bs_vector.push_back(std::unique_ptr<B>(new B(this, i))); } typedef boost::indirect_iterator<std::vector<std::unique_ptr<B>>::iterator> it; // needs copy ctor for B const std::vector<B> bs_vector2(it(bs_vector.begin()), it(bs_vector.end())); // work with bs_vector2 }

Answer 4

我也遇到过这个问题，我代码中的用例是提供一个线程安全的vector，元素数是固定的，是原子数。我在这里阅读了所有很棒的答案。我想我们也可以考虑我的解决方案：

刚刚继承了std::vector，隐藏了push_back、emplace_back、erase等修饰符，那么我们就得到了一个固定大小的向量。我们只能使用 operator [] 访问和修改元素。

template <typename T>
class FixedVector : protected std::vector<T> {
 public:
  using BaseType = std::vector<T>;
  FixedVector(size_t n) : BaseType(n) {}
  FixedVector(const T &val, size_t n) : BaseType(val, n) {}
  typename BaseType::reference operator[](size_t n) {
    return BaseType::operator[](n);
  }
};

容器固定动态尺寸

4 个答案: