boost ::不可复制的优点是什么

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

在这种情况下使用升压有什么优点/缺点？

我看不出任何文档方面的好处：

#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多次衍生以及是否要花我多得多。特别是如果我不是完整继承层次结构的作者。

它使意图明确和清晰的，否则，人们必须看到类的定义，并搜索相关的拷贝语义的声明，然后寻找其被访问说明符声明，以确定是否该类是否不可复制。通过编写要求启用了复制语义的代码来发现它的其他方法，并查看编译错误。

总结别人说的话：

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

1. 它在意图上更明确和更具描述性。使用私人复制功能是一个习惯，比发现需要更长的时间noncopyable。
2. 更少的代码/更少的键入/更少的混乱/更少的错误空间（最容易的是偶然地提供了实现）。
3. 它将含义直接嵌入类型的元数据中，类似于C＃属性。现在，您可以编写一个仅接受不可复制对象的函数。
4. 它可能会在构建过程的早期发现错误。如果类本身或类的朋友正在执行错误的复制，则错误将在编译时而不是链接时显示。
5. （与＃4几乎相同）防止类本身或类的朋友调用私有复制方法。

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

1. 没有助推依赖

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

我不明白为什么没人能提到它，但是：

与noncopyable您一起写下您的班级名称一次。

没有，则进行五重复制：一个用于“类A”的A，两个用于禁用分配的属性，以及两个用于禁用复制构造函数的属性。

引用文档：

“处理这些问题的传统方法是声明一个私有副本构造函数和副本赋值，然后记录为什么这样做。但是，从不可复制派生的过程更加简单明了，并且不需要其他文档。”

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

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

它还可以防止您意外地定义函数（即，键入{}而不是;），这是一个很小的错误，很可能不会引起注意，但是会允许成员和朋友创建该对象的无效副本。

好处是您不必自己编写私有副本构造函数和私有副本运算符，并且无需编写其他文档即可清楚地表达您的意图。

一个小缺点（特定于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 ++有几个问题。无论如何，检查“问题”的代码非常简单……有时会有所帮助。

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

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

如果我要制作不可复制的对象，则必须有一个不可复制的原因。99％的原因是因为我的成员无法被有意义地复制。这样的成员很可能也更适合作为私有实施细节。因此，我制作了大多数这样的类：

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

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

这种模式的好处是以后，如果我确定确实要使该类的对象可复制，则可以在不更改类层次结构的情况下添加并实现一个复制构造函数和/或赋值运算符。

根据斯科特·迈耶斯（Scott Meyers）的说法，如果您确实需要找到它，则名称为“非自然”。