为了防止复制一个类，你可以很容易地声明一个私有的复制构造函数/赋值操作符。但是你也可以继承boost::noncopyable。
在这种情况下使用 boost 有什么优点/缺点？
【问题讨论】：
struct Foo{Foo(const Foo&)=delete;};
Foo & operator=(const Foo &) = delete;?
标签： c++ boost noncopyable
我没有看到任何文档优势：
#include <boost/noncopyable.hpp>
struct A
: private boost::noncopyable
{
};
对比：
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;
};
对比：
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 早在 C++11 之前就已经可用，并且编译支持 = delete。我同意你的观点，对于 C++11 近乎兼容的编译器，它现在已经过时了。
noncopyable 设为CRTP 基类，这样层次结构中的所有基类都是唯一的。
private: __copy_constructor__; 是完全可移植的，您不需要 ~40 MB 的 Boost 依赖项。
boost::ptr_vector<animal>（boost.org/doc/libs/1_54_0/libs/ptr_container/doc/tutorial.html）之前使用std::vector<std::unique_ptr<animal>>。基本原理：如果我知道vector，并且我知道unique_ptr，那么我就知道unique_ptr 向量的语义。而且我知道 std::algorithms （例如排序）如何与之交互。我不必完全了解新容器及其成员算法（例如成员排序）。
总结别人说的话：
boost::noncopyable 相对于私有复制方法的优势：
noncopyable 需要更长的时间来发现的习惯用法。私有复制方法相对于boost::noncopyable的优势：
【讨论】：
它使意图明确和明确，否则必须查看类的定义，并搜索与复制语义相关的声明，然后查找其中的访问说明符已声明，以确定该类是否不可复制。通过编写需要启用复制语义的代码并查看编译错误来发现它的其他方法。
【讨论】：
noncopyable。所以这是一个有争议的问题。
【讨论】：
我不明白为什么似乎没有其他人提到它，但是：
使用noncopyable，您只需写一次班级名称。
没有，五重复制： 一个 A 用于“class A”，两个用于禁用赋值，两个用于禁用复制构造函数。
【讨论】：
引用文档：
“处理这些的传统方法是声明一个私有的复制构造函数和复制赋值，然后记录为什么这样做。但是从 noncopyable 派生更简单、更清晰，并且不需要额外的文档。 "
http://www.boost.org/libs/utility/utility.htm#Class_noncopyable
【讨论】：
一个具体的优势（除了更清楚地表达您的意图之外）是，如果成员或友元函数试图复制对象，则在编译阶段而不是链接阶段会更快地发现错误。基类构造函数/赋值在任何地方都无法访问，导致编译错误。
它还可以防止您意外定义函数（即键入{} 而不是;），这是一个很可能被忽视的小错误，但随后会允许成员和朋友制作对象的无效副本。
【讨论】：
...is that the error will be caught sooner, at the compile stage not the link stage。具体如何？即使boost::noncopyable 会做同样的事情，如果你不使用它。
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 而不是手动删除或私有化复制构造函数和赋值运算符。
但是，我几乎从不使用 either 方法，因为：
如果我正在制作一个不可复制的对象，那么它是不可复制的肯定是有原因的。这个原因，99% 的时间，是因为我的成员无法有意义地复制。很有可能，这些成员也更适合作为私有实现细节。所以我制作了大多数这样的类：
struct Whatever {
Whatever();
~Whatever();
private:
struct Detail;
std::unique_ptr<Detail> detail;
};
所以现在，我有一个私有实现结构，并且由于我使用了 std::unique_ptr，我的顶级类是不可免费复制的。来自此的链接错误是可以理解的，因为它们谈论您如何无法复制 std::unique_ptr。对我来说，这就是 boost::noncopyable 和私有实现合二为一的所有好处。
这种模式的好处是以后，如果我确定我确实想让我的这个类的对象可复制，我可以添加和实现一个复制构造函数和/或赋值运算符而不改变类层次结构。
【讨论】：
根据 Scott Meyers 的说法，缺点是“非自然”，如果您确实需要找到它的缺点。
【讨论】：