没有运算符 =、复制构造函数或默认构造函数和运行时参数的对象的数组初始化

Question

免责声明

我正在尝试分配一个对象数组，这些对象既不能复制构造，也不能赋值，也没有默认构造函数。对象具有在运行时确定的参数。我知道您可以通过使用指针数组或巧妙地使用placement new 来解决这个问题，但我更感兴趣的是这是否可以用C++11 (1y) 魔术干净地完成。 所以，这纯粹是理论上的兴趣，所以请避免尝试通过提供解决方法来解决“我的问题”。

代码...

...所以问题是：有没有办法在 C++11 或 C++14 中进行以下工作：

class X{
public:
  explicit X(int a){...}
  X(const X&) = delete;
  void operator = (const X&) = delete;
private:
  ...
};

class Y{
public:
  Y(const std::vector<int>& args) {
    x = new X[]{args};
  }
  ~Y(){
    delete [] x;
  }
private:
  X* x;
};

标准

具体来说，我正在寻找满足以下条件的解决方案/构造：

• X 不可复制。
• X 不可分配。
• X 没有默认的无参数构造函数（构造具有预期的副作用）。
• X 的构造函数的参数直到运行时才知道。
• X 的所有实例必须在内存中连续布局。
• 当数组从它的基指针中删除时（或者如果使用中间类，当中间对象被破坏时），X 必须被正确地破坏。这排除了指针数组和对放置 new 的天真使用。

编辑/附录

我忘了提到移动构造函数不可用。在手头的实际情况下，X 产生一个工作线程并在初始构造对象的this 上下文中执行，任何使用移动构造函数的尝试都会破坏执行线程的状态。

Answer 1

如果您使X 至少可移动，则可以使用std::vector 及其emplace_back 函数。

class X{
public:
  explicit X(int){}
  X(X&&) = default;
  X(const X&) = delete;
  void operator = (const X&) = delete;
};

int main() {
    std::vector<X> xs;
    xs.emplace_back(0);
    xs.emplace_back(1);
    xs.emplace_back(2);
    xs.emplace_back(3);
}

（如果你声明了一个拷贝构造函数，即使那个声明删除了它，编译器也不会自动生成任何特殊的移动成员，所以你需要显式地请求它们）

这基本上归结为“新放置的数组”策略，但都抽象为高级概念。

如果您不能使用可移动类型，则必须实现一个类似矢量的类，该类预先分配存储并且从不重新分配。标准库中没有类似的东西。

Answer 2

既不能复制也不能移动，也没有默认构造函数的类，不能保存在标准容器（不满足要求）或可变大小的数组分配（只允许指定固定数字的参数元素）。

这意味着您需要改为分配原始内存并使用placement new 来构造对象。您可以将其包装在一个固定空间矢量类中。

template <typename T>
class fixed_capacity_vector {
public:
  using size_type = std::size_t;

  fixed_capacity_vector(size_type capacity)
    : data_(::operator new(capacity * sizeof(T)), size_(), capacity_(capacity)
  {}

  fixed_capacity_vector(const fixed_capacity_vector&) = delete;
  fixed_capacity_vector(fixed_capacity_vector&&) = delete;
  fixed_capacity_vector& operator =(const fixed_capacity_vector&) = delete;
  fixed_capacity_vector& operator =(fixed_capacity_vector&&) = delete;

  ~fixed_capacity_vector() {
    for (size_type i = 0; i < size_; ++i) data_[i].~T();
    ::operator delete(data_);
  }

  template <typename... Args>
  T& emplace_back(Args&&... args) {
    if (size_ == capacity_) throw out_of_range();
    new (data_ + size_) T(std::forward<Args>(args)...);
    ++size_;
    return data_[size_-1];
  }

private:
  T* data_;
  size_type size_;
  size_type capacity_;
};

Answer 3

您将不得不手动跟踪构造的元素，但您可以使用allocator 来帮助：

class Y{
public:
  Y(const std::vector<int>& args):
    alloc{},
    n{args.size()},
    x{alloc.allocate(n)}
  {
    auto end = x;
    try {
      for (auto arg: args)
        alloc.construct(end++, arg);
    } catch (...) {
      while (end != x)
        alloc.destroy(--end);
      alloc.deallocate(x, n);
      throw;
    }
  }
  ~Y() {
    for (auto end = std::next(x, n); end != x; --end)
      alloc.destroy(end);
    alloc.deallocate(x, n);
  }
private:
  std::allocator<X> alloc;
  const std::size_t n;
  const X *x;
};