在 C++ 中插入容器时如何处理不可复制的对象

Question

我正在寻找处理不可复制对象的最佳实践。

我有一个互斥类，显然它不应该是可复制的。 我添加了一个私有复制构造函数来强制执行此操作。

这破坏了代码 - 有些地方只需要修复，但我有一个普遍的问题 其中使用互斥锁作为数据成员或通过继承的类被插入到容器中。

这通常发生在容器初始化期间，因此互斥体尚未初始化，因此是可以的，但如果没有复制构造函数，它就无法工作。更改容器以包含指针是不可接受的。

有什么建议吗？

Answer 1

std::vector 不能存储不可复制的对象（由于调整大小），因此不能存储 Foo 类型的对象：

struct Foo {
   std::mutex mutex;
   ...
};

一种方法解决这个问题的方法是使用 std::unique_ptr：

struct Foo {
   std::unique_ptr<std::mutex> pmutex;
   Foo() : pmutex{std::make_unique<std::mutex>()} {}
   ...
};

另一种选择是使用 std::deque ，它可以保存不可复制的对象（例如上面 Foo 的第一个版本的实例通常使用 emplace_back 方法“就地”构造对象来添加元素 - 例如，
这里 Foo 类型的对象不需要需要可复制：

struct FooPool {
    std::deque<Foo> objects;
    ObjectPool(std::initializer_list<T> argList) {
        for (auto&& arg : argList)
             objects.emplace_back(arg);
    ...
};
  

Answer 2

在类中使用互斥体并不一定意味着该类必须是不可复制的。您（几乎）总是可以像这样实现它：

C::C (C const & c)
// No ctor-initializer here.
{
  MutexLock guard (c.mutex);

  // Do the copy-construction here.
  x = c.x;
}

虽然这使得使用互斥体复制类在某种程度上成为可能，但您可能不应该这样做。如果没有每个实例的互斥锁，您的设计可能会更好。

Answer 3

在 Ubuntu 14.04（包括 emplace_back）上使用 c++11，我已经让它工作了。

我发现 emplace_back 工作正常，但是 erase （可能还有 insert）不起作用，因为当向量将元素打乱到填补空白，它使用：

 *previous = *current;

我发现技巧是允许在我的资源类中进行移动分配：

  Watch& operator=(Watch &&other);

这是我的 inotify_watch 类，它可以存在于 std::vector 中：

class Watch {
private:
  int inotify_handle = 0;
  int handle = -1;
  // Erases all knowledge of our resources
  void erase() {
    inotify_handle = 0;
    handle = -1;
  }
public:
  Watch(int inotify_handle, const char *path, uint32_t mask)
      : inotify_handle(inotify_handle),
        handle(inotify_add_watch(inotify_handle, path, mask)) {
    if (handle == -1)
      throw std::system_error(errno, std::system_category());
  }
  Watch(const Watch& other) = delete; // Can't copy it, it's a real resource
  // Move is fine
  Watch(Watch &&other)
      : inotify_handle(other.inotify_handle), handle(other.handle) {
    other.erase(); // Make the other one forget about our resources, so that
                   // when the destructor is called, it won't try to free them,
                   // as we own them now
  } 
  // Move assignment is fine
  Watch &operator=(Watch &&other) {
    inotify_handle = other.inotify_handle;
    handle = other.handle;
    other.erase(); // Make the other one forget about our resources, so that
                   // when the destructor is called, it won't try to free them,
                   // as we own them now
    return *this;
  }
  bool operator ==(const Watch& other) {
    return (inotify_handle == other.inotify_handle) && (handle == other.handle);
  }
  ~Watch() {
    if (handle != -1) {
      int result = inotify_rm_watch(inotify_handle, handle);
      if (result == -1)
        throw std::system_error(errno, std::system_category());
    }
  }
};

Answer 4

这里提供三种解决方案：

1。使用指针 - 快速解决方法是使其成为指针容器 - 例如 shared_ptr。

如果您的对象确实不可复制，并且不可能使用其他容器，那么这将是“好的”解决方案。

2.其他容器 - 或者，您可以使用非复制容器（使用就地构造），但它们并不常见，并且在很大程度上与 STL 不兼容。 （我已经尝试了一段时间，但根本没有好处）

如果您的对象确实是不可复制的，并且不可能使用指针，那么这将是“上帝”解决方案。

[编辑] 在 C++13 中，std::vector 允许就地构造 (emplace_back)，并且可用于实现移动语义的不可复制对象。
[/编辑]

3.修复你的可复制性 - 如果你的类本身是可复制的，而互斥体不是，那么你“简单”需要修复复制构造函数和赋值运算符。

编写它们是一件痛苦的事情，因为您通常必须复制并复制它们。分配除互斥体之外的所有成员，但这通常可以通过以下方式简化：

template <typename TNonCopyable>
struct NeverCopy : public T 
{
    NeverCopy() {}
    NeverCopy(T const & rhs) {}

    NeverCopy<T> & operator=(T const & rhs) { return *this; }
}

将互斥体成员更改为

NeverCopy<Mutex> m_mutex;

不幸的是，使用该模板您会丢失互斥体的特殊构造函数。

[编辑]警告：“修复”复制CTor/赋值通常需要您锁定复制构造的右侧，并锁定赋值的两侧。不幸的是，没有办法覆盖复制构造函数/赋值并调用默认实现，因此如果没有外部锁定，NeverCopy 技巧可能对您不起作用。 （还有一些其他解决方法也有其自身的局限性。）

Answer 5

如果它们是不可复制的，则容器必须存储指向这些对象的（智能）指针或引用包装器等，尽管使用 C++0x，不可复制的对象仍然可以移动（如 boost 线程），以便它们可以按原样存储在容器中。

举个例子：引用包装器（又名 boost::ref，底层的指针）

#include <vector>
#include <tr1/functional>
struct Noncopy {
private:
        Noncopy(const Noncopy&) {}
public:
        Noncopy() {}
};
int main()
{
        std::vector<std::tr1::reference_wrapper<Noncopy> > v;
        Noncopy m;
        v.push_back(std::tr1::reference_wrapper<Noncopy>(m));
}

C++0x，用 gcc 测试：

#include <vector>
struct Movable {
private:
        Movable(const Movable&) = delete;
public:
        Movable() {}
        Movable(Movable&&) {}
};
int main()
{
        std::vector<Movable> v;
        Movable m;
        v.emplace_back(std::move(m));
}

编辑：没关系，C++0x FCD 说，在 30.4.1/3 下，

互斥体类型不可复制或移动。

所以你最好使用指向它们的指针。根据需要进行智能或其他包装。

Answer 6

如果一个对象是不可复制的，那么通常有一个很好的理由。如果有充分的理由，那么您不应该通过将其放入尝试复制它的容器来破坏它。

Answer 7

鉴于您如何提出这个问题，没有真正的答案。没有办法做你想做的事。实际的答案是容器包含指针，并且您已经说过由于某些未指定的原因这是不行的。

有些人谈论了可移动的事物以及使用 C++0x，其中容器通常要求其元素可移动，但不要求它们可复制。我认为这也是一个糟糕的解决方案，因为我怀疑互斥体在持有时不应该被移动，这使得实际上不可能移动它们。

因此，唯一真正剩下的答案是指向互斥体。使用 ::std::tr1::shared_ptr （在 #include 中）或 ::boost::shared_ptr 来指向互斥体。这需要更改内部具有互斥体的类的定义，但听起来您无论如何都在这样做。

Answer 8

STL 容器严重依赖于其内容的可复制性，因此要么使它们可复制，要么不将它们放入容器中。

Answer 9

最好的选择是使用指针或某种类型的在底层使用指针的包装类。这将允许它们被合理地复制，并且实际上执行副本预期执行的操作（共享互斥锁）。

但是，既然你说没有指针，那么还有另一种选择。听起来互斥体“有时是可复制的”，也许您应该编写一个复制构造函数和一个赋值运算符，并在初始化后复制互斥体时让它们抛出异常。缺点是直到运行时才知道你做错了。

Answer 10

使用智能指针，如 boost::shared_ptr 或使用其他容器，如 boost::intrusive。两者都需要修改您的代码。