boost::noncopyable 的优点是什么

Question

为了防止复制类，您可以非常轻松地声明私有复制构造函数/赋值运算符。但您也可以继承boost::noncopyable。

在这种情况下使用 boost 有哪些优点/缺点？

Answer 1

我没有看到任何文档优势：

#include <boost/noncopyable.hpp>

struct A
    : private boost::noncopyable
{
};

vs：

struct A
{
     A(const A&) = delete;
     A& operator=(const A&) = delete;
};

当您添加仅移动类型时，我什至认为文档具有误导性。下面的两个例子是不可复制的，尽管它们是可移动的：

#include <boost/noncopyable.hpp>

struct A
    : private boost::noncopyable
{
    A(A&&) = default;
    A& operator=(A&&) = default;
};

vs:

struct A
{
    A(A&&) = default;
    A& operator=(A&&) = default;
};

在多重继承下，甚至可能会有空间损失：

#include <boost/noncopyable.hpp>

struct A
    : private boost::noncopyable
{
};

struct B
    : public A
{
    B();
    B(const B&);
    B& operator=(const B&);
};

struct C
    : public A
{
};

struct D
    : public B,
      public C,
      private boost::noncopyable
{
};

#include <iostream>

int main()
{
    std::cout << sizeof(D) << '\n';
}

对我来说，这会打印出来：

3

但是，我相信它有更好的文档：

struct A
{
    A(const A&) = delete;
    A& operator=(const A&) = delete;
};

struct B
    : public A
{
    B();
    B(const B&);
    B& operator=(const B&);
};

struct C
    : public A
{
    C(const C&) = delete;
    C& operator=(const C&) = delete;
};

struct D
    : public B,
      public C
{
    D(const D&) = delete;
    D& operator=(const D&) = delete;
};

#include <iostream>

int main()
{
    std::cout << sizeof(D) << '\n';
}

输出：

2

我发现它很多声明我的复制操作比推理我是否多次从 boost::non_copyable 派生以及这是否会让我付出代价更容易。特别是如果我不是完整继承层次结构的作者。

Answer 2

总结一下其他人所说的：

boost::noncopyable相对于私有复制方法的优点：

1. 它的意图更加明确和描述性。使用私有复制函数是一种比 noncopyable 更难发现的习惯用法。
2. 它是更少的代码/更少的打字/更少的混乱/更少的错误空间（最简单的是意外地提供一个实现）。
3. 它将含义直接嵌入到类型的元数据中，类似于 C# 属性。您现在可以编写一个仅接受不可复制对象的函数。
4. 它有可能在构建过程的早期捕获错误。如果类本身或类的朋友进行了错误的复制，则错误将在编译时而不是链接时出现。
5. （几乎与 #4 相同）防止类本身或类的朋友调用私有复制方法。

私有复制方法相对于 boost::noncopyable 的优点：

1. 无 boost 依赖

Answer 3

它使意图明确且清晰，否则就必须查看类的定义，并搜索与复制语义相关的声明，然后查找其所在的访问说明符< em>声明，以确定该类是否不可复制。通过编写需要启用复制语义的代码并查看编译错误来发现它的其他方法。

Answer 4

1. boost::noncopyable 的意图更加清晰。
2. Boost::noncopyable 可防止类方法意外使用私有复制构造函数。
3. 使用 boost::noncopyable 减少代码。

Answer 5

我不明白为什么其他人似乎没有提到它，但是：

使用 noncopyable 你只需写一次类的名称。

如果没有，五重重复：
一个 A 代表“A 类”，两个用于禁用赋值，两个用于禁用复制构造函数。

Answer 6

引用文档：

“处理这些问题的传统方法是声明一个私有复制构造函数和复制赋值，然后记录为什么这样做。但是从 noncopyable 派生更简单、更清晰，并且不需要额外的文档."

http://www.boost.org/libs/utility/utility.htm#Class_noncopyable

Answer 7

一个具体的优点（除了更清楚地表达您的意图之外）是，如果成员或友元函数尝试复制对象，则在编译阶段而不是链接阶段会更快地捕获错误。基类构造函数/赋值在任何地方都不可访问，从而产生编译错误。

它还可以防止您意外定义函数（即输入 {} 而不是 ;），这是一个很可能被忽视的小错误，但可以让成员和朋友制作对象的无效副本。

Answer 8

一个小缺点（特定于GCC）是，如果您使用g++ -Weffc++编译程序并且您有包含指针的类，例如

class C : boost::noncopyable
{
public:
  C() : p(nullptr) {}

private:
  int *p;
};

GCC无法理解发生了什么：

警告：“C 类”具有指针数据成员 [-Weffc++]
警告：但不会覆盖“C(const S&)”[-Weffc++]
警告：或“operator=(const C&)”[-Weffc++]

虽然它不会抱怨：

#define DISALLOW_COPY_AND_ASSIGN(Class) \
  Class(const Class &) = delete;     \
  Class &operator=(const Class &) = delete

class C
{
public:
  C() : p(nullptr) {}
  DISALLOW_COPY_AND_ASSIGN(C);

private:
  int *p;
};

PS 我知道 GCC 的 -Weffc++ 有几个问题。无论如何，检查“问题”的代码非常简单......有时它会有所帮助。

Answer 9

优点是您不必自己编写私有复制构造函数和私有复制运算符，并且它可以清楚地表达您的意图，而无需编写额外的文档。

Answer 10

我宁愿使用 boost::noncopyable 而不是手动删除或私有化复制构造函数和赋值运算符。

然而，我几乎从不使用任何一种方法，因为：

如果我正在创建一个不可复制的对象，那么它是不可复制的就必须有一个原因。这个原因，99%的情况，是因为我有无法有意义复制的成员。有可能，此类成员也更适合作为私有实施细节。所以我制作大多数这样的类：

struct Whatever {
  Whatever();
  ~Whatever();
  private:
  struct Detail;
  std::unique_ptr<Detail> detail;
};

现在，我有一个私有实现结构，并且由于我使用了 std::unique_ptr，所以我的顶级类是不可免费复制的。由此产生的链接错误是可以理解的，因为它们讨论了如何无法复制 std::unique_ptr。对我来说，这就是 boost::noncopyable 和私有实现的所有好处。

这种模式的好处是稍后，如果我决定确实想让此类的对象可复制，我可以添加并实现复制构造函数和/或赋值运算符，而无需更改类层次结构。

Answer 11

缺点，根据斯科特·迈耶斯的说法，如果你确实需要找到它的缺点的话，这个名字是“非自然的”。