33

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

  • 我知道std::array有固定的长度，但这个长度必须在编译时知道。
  • std::vector具有动态大小，并允许使用emplace. 尽管您可以reserve记忆以避免实际的重新分配，但该类型仍然必须是可移动的以理论上允许此类重新分配，例如防止 const 成员。
  • 然后是std::listand std::forward_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());
}
4

4 回答 4

10

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

正如史蒂夫杰索普在他的回答中指出的那样，如果您首先定义向量 const，您甚至无法调用此类修改操作 - 当然元素也保持不变。

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

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

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

如果构造函数是显式的，则必须先创建一个列表或显式构造初始化器列表中的对象：

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) };
}
于 2013-02-15T13:15:19.410 回答
6

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

如果我错了，并且您确实因为T不可移动而遇到麻烦，请尝试使用 aconst std::deque<T>代替。

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

于 2013-02-15T13:38:55.430 回答
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
}
于 2013-02-15T13:28:39.213 回答
-1

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

只需继承并隐藏, ,std::vector等修饰符，即可得到一个固定大小的向量。我们只能使用 访问和修改元素。push_backemplace_backeraseoperator []

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);
  }
};
于 2021-04-06T02:49:37.003 回答