不可调整大小的向量/不可重新分配但可变成员的数组？

Question

有没有办法制作不可重新分配但可变成员的不可调整大小的向量/数组？我能想象到的最接近的事情是使用 vectorconst 副本是从临时构造的，但由于我在初始化时知道​​有多少个以及到底想要什么，所以我宁愿拥有一个对象块而不是指针。是否可以使用 std::vector 或一些更晦涩的 boost 等模板来实现如下所示的内容？

// Struct making vec<A> that cannot be resized or have contents reassigned.
struct B {
  vector<A> va_; // <-- unknown modifiers or different template needed here
  vector<A> va2_;

  // All vector contents initialized on construction.
  Foo(size_t n_foo) : va_(n_foo), va2_(5) { }

  // Things I'd like allowed: altering contents, const_iterator and read access.
  good_actions(size_t idx, int val) {
    va_[idx].set(val);

    cout << "vector<A> info - " <<  " size: " << va_.size() << ", max: "
      << va_.max_size() << ", capacity: " << va_.capacity() << ", empty?: "
      << va_.empty() << endl;

    if (!va_.empty()) {
      cout << "First (old): " << va_[0].get() << ", resetting ..." << endl;
      va_[0].set(0);
    }

    int max = 0;
    for (vector<A>::const_iterator i = va_.begin(); i != va_.end(); ++i) {
      int n = i->get();
      if (n > max) { max = n; }
      if (n < 0)   { i->set(0); }
    }
    cout << "Max : " << max << "." << endl;
  }

  // Everything here should fail at compile.
  bad_actions(size_t idx, int val) {
    va_[0]    = va2_[0];
    va_.at(1) = va2_.at(3);

    va_.swap(va2_);
    va_.erase(va_.begin());
    va_.insert(va_.end(), va2_[0]);

    va_.resize(1);
    va_.clear();
    // also: assign, reserve, push, pop, .. 
  }
};

Answer 1

你的要求有问题。但首先让我们解决固定大小问题，它被称为 std::tr1::array （如果您在编译时知道大小）。

如果您在编译时不知道，您仍然可以在向量上使用一些代理类。

template <class T>
class MyVector
{
public:
  explicit MyVector(size_t const n, T const& t = T()): mVector(n,t) {}

  // Declare the methods you want here
  // and just forward to mVector most of the time ;)

private:
  std::vector<T> mVector;
};

然而，如果你是可变的，那么不可分配有什么意义呢？没有什么可以阻止用户做繁重的工作：

class Type
{
public:
  int a() const { return a; }
  void a(int i) { a = i; }

  int b() const { return b; }
  void b(int i) { b = i; }
private:
  Type& operator=(Type const&);

  int a, b;
};

没有什么可以阻止我做：

void assign(Type& lhs, Type const& rhs)
{
  lhs.a(rhs.a());
  lhs.b(rhs.b());
}

我只是想打你的头，让我的生活变得复杂......

也许你能更准确地描述你想做的事情吗？限制类上可能操作的子集（某些变量不应该修改，但其他变量可以）？

在这种情况下，您可以再次使用 Proxy 类。

class Proxy
{
public:
  // WARN: syntax is screwed, but `vector` requires a model
  // of the Assignable concept so this operation NEED be defined...
  Proxy& operator=(Proxy const& rhs)
  {
    mType.a = rhs.mType.a;
    // mType.b is unchanged
    return *this;
  }

  int a() const { return mType.a(); }
  void a(int i) { mType.a(i); }      

  int b() const { return mType.b(); }

private:
  Type mType;
};

使用合适的代理没有什么不能做的。这也许是我见过的最有用的模式。

Answer 2

你所问的实际上是不可能的。

防止分配某些内容的唯一方法是将该类型的operator = 定义为private。 （作为其扩展，由于 const operator = 方法没有多大意义（因此不常见），您可以通过仅允许从容器访问 const 引用来接近这一点。但是用户仍然可以定义一个 const operator =，并且无论如何你都需要可变对象。）

如果你考虑一下，std::vector::operator [] 返回一个引用它所包含的价值。使用赋值运算符将调用 operator = 来获取值。 std::vector 在这里被完全绕过（除了用于首先获取引用的 operator[] 调用），因此不可能（>std::vector) 以任何方式覆盖对 operator = 函数的调用。

您为直接访问容器中对象的成员所做的任何操作都必须返回对该对象的引用，然后可以使用该引用来调用该对象的operator =。因此，容器无法阻止其内部的对象被分配，除非容器为其包含的对象实现一个代理，该代理具有一个私有赋值运算符，该运算符不执行任何操作并将其他调用转发到“真实”对象，但不允许直接访问真实对象（尽管如果这样做有意义，您可以返回真实对象的副本）。

Answer 3

您能否创建一个包含对对象的引用的类，但其构造函数只能由其 std::vector 的朋友访问？

例如：

template<typename T>
class MyRef {
   firend class std::vector< MyRef<T> >
public:
   T& operator->();
[...etc...]

Answer 4

您可以通过创建 std::vector const 和向量的 struct 或 class 数据来实现您想要的目的可变。您的 set 方法必须是 const。下面是一个在 g++ 中按预期工作的示例：

#include <vector>

class foo
{ 
public:
  foo () : n_ () {}
  void set(int n) const { n_ = n; }

private:

  mutable int n_;
};

int main()
{
  std::vector<foo> const a(3);  // Notice the "const".
  std::vector<foo> b(1);

  // Executes!
  a[0].set(1);

  // Failes to compile!
  a.swap(b);
}

这样您就不能以任何方式更改 vector，但您可以修改由向量持有的对象的 mutable 数据成员向量。下面是这个例子的编译方式：

g++ foo.cpp 
foo.cpp: In function 'int main()':
foo.cpp:24: error: passing 'const std::vector<foo, std::allocator<foo> >' as 'this' argument of 'void std::vector<_Tp, _Alloc>::swap(std::vector<_Tp, _Alloc>&) [with _Tp = foo, _Alloc = std::allocator<foo>]' discards qualifiers

我能想到的一个缺点是你必须更加了解 const-正确性 代码，但这也不一定是缺点。

哈！

编辑/澄清：这种方法的目标不是完全击败const。相反，目标是演示使用标准 C++ 和 STL 实现 OP 问题中提出的要求的方法。它不是理想的解决方案，因为它公开了一个 const 方法，允许更改用户可见的内部状态。当然，这是这种方法的问题。