因此，可以将类定义为“不可复制的”;如果它没有operator=()方法，但仍然可以合法地，根据c++标准和c++提供的机制，安全且没有未定义的行为，使用它的复制构造函数和放置new语法，如下所示。

提醒:下面的所有代码行都可以工作。 您可以在这里运行大部分代码，包括下面的许多代码块，尽管它可能需要一些注释/取消注释代码块，因为它没有被清晰地设置为单独的示例。

1. 不可复制对象是什么?

不可复制的对象不能用=操作符(operator=()函数)复制。就是这样!然而，它仍然可以被合法复制。请看上面真正重要的注释。

不可复制类例1:

在这里，复制构造是可以的，但是禁止复制，因为我们已经显式删除了赋值操作符。尝试执行nc2 = nc1;会导致以下编译时错误:

error: use of deleted function ‘NonCopyable1& NonCopyable1::operator=(const NonCopyable1&)’

下面是完整的例子:

#include <stdio.h>


class NonCopyable1
{
public:
int i = 5;


// Delete the assignment operator to make this class non-copyable
NonCopyable1& operator=(const NonCopyable1& other) = delete;
};


int main()
{
printf("Hello World\n");
    

NonCopyable1 nc1;
NonCopyable1 nc2;
nc2 = nc1;   // copy assignment; compile-time error!
NonCopyable1 nc3 = nc1; // copy constructor; works fine!


return 0;
}

不可复制类例2:

在这里，复制构造是可以的，但禁止复制，因为类包含const成员，不能写入(假设，因为显然有变通方法)。尝试执行nc2 = nc1;会导致以下编译时错误:

error: use of deleted function ‘NonCopyable1& NonCopyable1::operator=(const NonCopyable1&)’
note: ‘NonCopyable1& NonCopyable1::operator=(const NonCopyable1&)’ is implicitly deleted because the default definition would be ill-formed:
error: non-static const member ‘const int NonCopyable1::i’, can’t use default assignment operator

完整的例子:

#include <stdio.h>


class NonCopyable1
{
public:
const int i = 5; // classes with `const` members are non-copyable by default
};


int main()
{
printf("Hello World\n");
    

NonCopyable1 nc1;
NonCopyable1 nc2;
nc2 = nc1;   // copy assignment; compile-time error!
NonCopyable1 nc3 = nc1; // copy constructor; works fine!


return 0;
}

outputData = data;将导致编译失败，并出现上面最后一个例子中所示的错误消息!

#include <functional>


#include <stdio.h>


class NonCopyable1
{
public:
const int i; // classes with `const` members are non-copyable by default


// Constructor to custom-initialize `i`
NonCopyable1(int val = 5) : i(val)
{
// nothing else to do
}
};


// Some class which (perhaps asynchronously) processes data. You attach a
// callback, which gets called later.
// - Also, this may be a shared library over which you have no or little
// control, so you cannot easily change the prototype of the callable/callback
// function.
class ProcessData
{
public:
void attachCallback(std::function<void(void)> callable)
{
callback_ = callable;
}
    

void callCallback()
{
callback_();
}


private:
std::function<void(void)> callback_;
};


int main()
{
printf("Hello World\n");
    

NonCopyable1 outputData; // we need to receive back data through this object
printf("outputData.i (before) = %i\n", outputData.i); // is 5
    

ProcessData processData;
// Attach a lambda function as a callback, capturing `outputData` by
// reference so we can receive back the data from inside the callback via
// this object even though the callable prototype returns `void` (is a
// `void(void)` callable/function).
processData.attachCallback([&outputData]()
{
int someRandomData = 999;
NonCopyable1 data(someRandomData);
// NOT ALLOWED SINCE COPY OPERATOR (Assignment operator) WAS
// AUTO-DELETED since the class has a `const` data member!
outputData = data;
});
processData.callCallback();
// verify we get 999 here, NOT 5!
printf("outputData.i (after) = %i\n", outputData.i);


return 0;
}

一个解决方案:memcpy数据到outputData。这在C中是完全可以接受的，但在c++中并不总是可以。

Cppreference.com状态(强调添加):

如果对象可能重叠或不是TriviallyCopyable,，则未指定memcpy的行为，并且可能没有定义。 . 0

和:

< p > 笔记
普通可复制类型的对象是唯一可以使用std::memcpy安全复制或使用std::ofstream::write()/std::ifstream::read()序列化到二进制文件或从二进制文件序列化的c++对象，这些对象不是潜在重叠的子对象

(https://en.cppreference.com/w/cpp/string/byte/memcpy)

因此，为了安全起见，在使用memcpy()复制对象之前，先确保对象为是否可以简单地复制。替换上面的部分:

    processData.attachCallback([&outputData]()
{
int someRandomData = 999;
NonCopyable1 data(someRandomData);
// NOT ALLOWED SINCE COPY OPERATOR (Assignment operator) WAS
// AUTO-DELETED since the class has a `const` data member!
outputData = data;
});

用这个。注意，这次使用memcpy()来复制数据，而使用std::is_trivially_copyable来确保在编译时，使用memcpy()来复制这种类型确实是安全的!：

    // (added to top)
#include <cstring>  // for `memcpy()`
#include <type_traits> // for `std::is_trivially_copyable<>()`


// Attach a lambda function as a callback, capturing `outputData` by
// reference so we can receive back the data from inside the callback via
// this object even though the callable prototype returns `void` (is a
// `void(void)` callable/function).
processData.attachCallback([&outputData]()
{
int someRandomData = 999;
NonCopyable1 data(someRandomData);
static_assert(std::is_trivially_copyable<NonCopyable1>::value, "NonCopyable1 must "
"be a trivially-copyable type in order to guarantee that `memcpy()` is safe "
"to use on it.");
memcpy(&outputData, &data, sizeof(data));
});

示例程序输出，现在它可以编译&运行。它的工作原理!

Hello World
outputData.i (before) = 5
outputData.i (after) = 999

然而，为了更加安全，你应该在覆盖对象之前手动调用它的析构函数，如下所示:

最佳memcpy()解决方案:

    processData.attachCallback([&outputData]()
{
int someRandomData = 999;
NonCopyable1 data(someRandomData);
static_assert(std::is_trivially_copyable<NonCopyable1>::value, "NonCopyable1 must "
"be a trivially-copyable type in order to guarantee that `memcpy()` is safe "
"to use on it.");
outputData.~NonCopyable1(); // manually call destructor before overwriting this object
memcpy(&outputData, &data, sizeof(data));
});

然而，如果上面的static_assert()失败了，那么你就不应该使用memcpy()。因此，一个始终安全并且更好的c++替代方法是使用&;placement new"。

这里，我们简单地复制构造data到outputData占用的内存区域。这就是这次“定位”的新之处。语法帮了我们大忙!它不像new操作符那样动态分配内存。通常，new运营商 第一个在堆上动态分配内存，而outputData0通过调用对象的构造函数在该内存中构造一个对象。然而，放置新的不做分配部分。相反，它简单地跳过这一部分，并将一个对象构造到内存outputData1中，你必须是预先静态或动态分配该内存的人，并且你必须确保该对象的内存正确对齐(参见outputData2和outputData3以及这里的outputData4示例)(在这种情况下，因为我们显式地将outputData对象创建为对象，使用NonCopyable1 outputData;调用它的构造函数)，你必须确保内存缓冲区/池足够大，以容纳你将要构建的数据。

泛型放置的新语法是这样的

// Call`T`'s specified constructor below, constructing it as an object right into
// the memory location pointed to by `ptr_to_buffer`. No dynamic memory allocation
// whatsoever happens at this time. The object `T` is simply constructed into this
// address in memory.
T* ptr_to_T = new(ptr_to_buffer) T(optional_input_args_to_T's_constructor);

在我们的例子中，它看起来像这样，调用NonCopyable1类的拷贝构造函数，我们已经在上面反复证明了即使删除赋值/复制操作符也有效:

// copy-construct `data` right into the address at `&outputData`, using placement new syntax
new(&outputData) NonCopyable1(data);

我们最终的attachCallback lambda现在看起来像这样，在memcpy()的位置放置了新语法。注意，确保对象可普通复制的检查不再需要。

= = =比;最好的c++解决方案全方位-避免MEMCPY复制构造直接到目标内存位置使用放置新:<====使用这个!= = = =

    processData.attachCallback([&outputData]()
{
int someRandomData = 999;
NonCopyable1 data(someRandomData);
outputData.~NonCopyable1(); // manually call destructor before overwriting this object
// copy-construct `data` right into the address at `&outputData`, using placement new syntax
new(&outputData) NonCopyable1(data);


// Assume that `data` will be further manipulated and used below now, but we needed
// its state at this moment in time.


// Note also that under the most trivial of cases, we could have also just called
// out custom constructor right here too, like this. You can call whatever
// constructor you want!
// new(&outputData) NonCopyable1(999);


// ...
});

2. non-trivially-copyable对象是什么?

不可平凡复制的对象可能包含虚方法和东西，因为这可能导致类必须跟踪“vee指针”。(vptr)和"vee表"(vtbls)，指向内存中正确的虚拟实现。在这里阅读更多信息:多布博士的《多态对象的存储布局》。然而，即使在这种情况下，只要你从同一个进程memcpy()ing到同一个进程(即:在同一个虚拟内存空间),而不是在过程,而不是从磁盘反序列化到RAM中,在我看来,memcpy()将技术工作好和生产没有缺陷(我对自己在少数的例子已经证明了这一点),但是它的技术似乎是行为而不是c++标准定义的,因此它是未定义行为,因此不能从编译器来编译器依靠100%,从c++的一个版本,所以…这是未定义的行为，在这种情况下你不应该memcpy()。

换句话说，如果上面的static_assert(std::is_trivially_copyable<NonCopyable1>::value);检查失败，就不要使用memcpy()。你必须使用"定位"相反!

让静态断言失败的一种方法是简单地在NonCopyable1类的类定义中声明或定义一个自定义的复制/赋值操作符，如下所示:

// Custom copy/assignment operator declaration:
NonCopyable1& operator=(const NonCopyable1& other);


// OR:


// Custom copy/assignment operator definition:
NonCopyable1& operator=(const NonCopyable1& other)
{
// Check for, **and don't allow**, self assignment!
// ie: only copy the contents from the other object
// to this object if it is not the same object (ie: if it is not
// self-assignment)!
if(this != &other)
{
// copy all non-const members manually here, if the class had any; ex:
// j = other.j;
// k = other.k;
// etc.
// Do deep copy of data via any member **pointers**, if such members exist
}


// the assignment function (`operator=()`) expects you to return the
// contents of your own object (the left side), passed by reference, so
// that constructs such as `test1 = test2 = test3;` are valid!
// See this reference, from Stanford, p11, here!:
// http://web.stanford.edu/class/archive/cs/cs106b/cs106b.1084/cs106l/handouts/170_Copy_Constructor_Assignment_Operator.pdf
//      MyClass one, two, three;
//      three = two = one;
return *this;
}

(有关自定义复制构造函数、赋值操作符等的更多示例，以及“三规则”;和“五的规则”，见这里是我的hello world存储库和示例。)

所以，现在我们有了一个自定义赋值操作符，类不再是普通的可复制的，下面的代码:

    processData.attachCallback([&outputData]()
{
int someRandomData = 999;
NonCopyable1 data(someRandomData);
static_assert(std::is_trivially_copyable<NonCopyable1>::value, "NonCopyable1 must "
"be a trivially-copyable type in order to guarantee that `memcpy()` is safe "
"to use on it.");
outputData.~NonCopyable1(); // manually call destructor before overwriting this object
memcpy(&outputData, &data, sizeof(data));
});

将产生以下错误:

main.cpp: In lambda function:
main.cpp:151:13: error: static assertion failed: NonCopyable1 must be a trivially-copyable type in order to guarantee that `memcpy()` is safe to use on it.
static_assert(std::is_trivially_copyable<NonCopyable1>::value, "NonCopyable1 must "
^~~~~~~~~~~~~

所以，你必须/(真的应该)使用"定位"相反，就像上面所描述的那样:

    processData.attachCallback([&outputData]()
{
int someRandomData = 999;
NonCopyable1 data(someRandomData);
outputData.~NonCopyable1(); // manually call destructor before overwriting this object
// copy-construct `data` right into the address at `&outputData`, using placement new syntax
new(&outputData) NonCopyable1(data);
});

更多关于预先分配缓冲区/内存池的信息

如果你真的只是想使用placement new直接复制-construct到内存池/共享内存/预分配的对象空间中，那么就没有必要使用NonCopyable1 outputData;将一个无用的实例构造到那个稍后必须销毁的内存中。相反，您可以只使用字节的内存池。格式如下:

(来自:"Placement new"section: https://en.cppreference.com/w/cpp/language/new)

// within any scope...
{
char buf[sizeof(T)];  // Statically allocate memory large enough for any object of
// type `T`; it may be misaligned!
// OR, to force proper alignment of your memory buffer for your object of type `T`,
// you may specify memory alignment with `alignas()` like this instead:
alignas(alignof(T)) char buf[sizeof(T)];
T* tptr = new(buf) T; // Construct a `T` object, placing it directly into your
// pre-allocated storage at memory address `buf`.
tptr->~T();           // You must **manually** call the object's destructor.
}                         // Leaving scope here auto-deallocates your statically-allocated
// memory `buf`.

所以，在上面的例子中，这个静态分配的输出缓冲区:

// This constructs an actual object here, calling the `NonCopyable1` class's
// default constructor.
NonCopyable1 outputData;

会变成这样:

// This is just a statically-allocated memory pool. No constructor is called.
// Statically allocate an output buffer properly aligned, and large enough,
// to store 1 single `NonCopyable1` object.
alignas(alignof(NonCopyable1)) uint8_t outputData[sizeof(NonCopyable1)];
NonCopyable1* outputDataPtr = (NonCopyable1*)(&outputData[0]);

然后通过outputDataPtr指针读取outputData对象的内容。

前方法(NonCopyable1 outputData;)是最好的如果存在一个这个类的构造函数不需要输入参数时你没有访问这个缓冲区的创建,而且如果你只打算将这一数据类型存储到缓冲区,而后者uint8_t缓冲区方法是最好的如果你)没有访问的所有输入参数甚至构造对象所需的位置需要创建这个缓冲区,或者B)如果你计划在这个内存池中存储多种数据类型，可能是为了在线程、模块、进程等之间以一种联合的方式进行通信。

更多关于c++的内容，以及为什么它让我们在这种情况下跳过这些圈

所以，这整个“安置新”;c++中的东西，以及对它的需求，花了我大量的学习和很长时间来理解它。经过思考，我想到C语言范式(我来自哪里)是手动分配一些内存，然后将一些东西插入其中。在处理静态和动态内存分配时，这些都是单独的操作(记住:你甚至不能为structs设置默认值!)。没有构造函数或析构函数的概念，即使是获得一个基于作用域的析构函数的__attribute__((__cleanup__(my_variable)))0(当变量退出给定作用域时自动调用)也是一件令人头疼的事情，需要一些奇特的gcc扩展__attribute__((__cleanup__(my_variable))) magic __attribute__((__cleanup__(my_variable)))1。然而，从一个对象任意复制到另一个对象是__attribute__((__cleanup__(my_variable)))2，只是复制周围的对象!这与__attribute__((__cleanup__(my_variable)))3形成对比，后者是__attribute__((__cleanup__(my_variable)))4。这个范例集中于准备使用__attribute__((__cleanup__(my_variable)))5的对象。为了实现这一点，它们依赖__attribute__((__cleanup__(my_variable)))6和__attribute__((__cleanup__(my_variable)))7。这意味着像这样创建一个对象:NonCopyable1 data(someRandomData);，不仅为该对象__attribute__((__cleanup__(my_variable)))8，而且还__attribute__((__cleanup__(my_variable)))9，并将该对象构造(放置)到该内存中。它试图在一件事上做多件事。因此，在c++中，memcpy()和赋值操作符(=;operator=()函数)明显受到c++性质的限制。这就是为什么我们必须通过这个奇怪的“复制构造我的对象到一个给定的内存位置通过放置新”的圆环。进程，而不是仅仅创建一个变量，然后稍后将内容复制到它中，或者如果它包含const成员，则稍后将内容memcpy()ing到它中，就像我们在C中所做的那样，c++确实试图强制RAII，这是他们实现它的部分方式。

你可以使用std::optional<>::emplace()代替

从c++ 17开始，你也可以使用std::optional<>作为包装器。各种容器和包装器的现代c++ emplace()函数做的是我们上面手动做的“placement new”;(另见我的答案是和关于std::vector<T,Allocator>::emplace_back "通常使用placement-new构造元素in-place"的引用)。

std::optional静态分配一个足够大的缓冲区给你想要放入其中的对象。然后，它要么存储该对象，要么存储std::nullopt(与{}相同)，这意味着它不存储该对象。要用另一个对象替换其中的一个对象，只需调用std::optional对象上的emplace()方法。它的作用如下:

就地构造包含的值。如果*this在调用之前已经包含一个值，则通过调用其析构函数来销毁所包含的值。

因此，它首先手动调用已在其内部的现有对象的析构函数，如果已有对象已在其内部，则它执行与“放置new"复制构造一个新对象(您提供的对象)到该内存空间。

那么，这个输出缓冲区:

NonCopyable1 outputData;


// OR


alignas(alignof(NonCopyable1)) uint8_t outputData[sizeof(NonCopyable1)];
NonCopyable1* outputDataPtr = (NonCopyable1*)(&outputData[0]);

现在变成这样:

# include <optional>


std::optional<NonCopyable1> outputData = std::nullopt;

而这个“安置新”;复制构造到输出缓冲区:

processData.attachCallback([&outputData]()
{
int someRandomData = 999;
NonCopyable1 data(someRandomData);
outputData.~NonCopyable1(); // manually call destructor before overwriting this object
// copy-construct `data` right into the address at `&outputData`, using placement new syntax
new(&outputData) NonCopyable1(data);
});

现在变成这个emplace()ment，将新数据放入缓冲区。注意，对析构函数的手动调用是不再需要，因为对我们来说是std::optional<>::emplace() 已经处理对任何已经存在的对象调用析构函数 !：

processData.attachCallback([&outputData]()
{
int someRandomData = 999;
NonCopyable1 data(someRandomData);
// emplace `data` right into the `outputData` object
outputData.emplace(data);
});

现在，要从outputData中获取数据，只需使用*对其进行解引用，或对其调用.value()。例:

// verify we get 999 here!
if (outputData.has_value())
{
printf("(*outputData).i (after) = %i\n", (*outputData).i);
// OR
printf("outputData.value().i (after) = %i\n", outputData.value().i);
}
else
{
printf("outputData.has_value() is false!");
}

样例输出:

Hello World
(*outputData).i (after) = 999
outputData.value().i (after) = 999

在这里运行完整的示例代码。

引用,另外，优秀的阅读:

1. *****+[一些最有用和最简单的"安置新"我从未见过这样的例子!] https://www.geeksforgeeks.org/placement-new-operator-cpp/
2. https://en.cppreference.com/w/cpp/language/new—>参见&;位置new&;部分和示例在这里!(我帮助编写了示例)。
3. 我如何使这个c++对象不可复制?< / >
4. [真正重要的一点是，调用放置新行在构造对象时调用对象的构造函数!]第3行(Fred* f = new(place) Fred();)本质上只是调用构造函数Fred::Fred()。这意味着Fred构造函数中的this指针将等于__abc4。http://www.cs.technion.ac.il/users/yechiel/c++-faq/placement-new.html
   1. http://www.cs.technion.ac.il/users/yechiel/c++-faq/memory-pools.html
5. 博士。多布的“多态对象的存储布局”
6. [好的pre- c++ 11 c++“三的规则”介绍]http://web.stanford.edu/class/archive/cs/cs106b/cs106b.1084/cs106l/handouts/170_Copy_Constructor_Assignment_Operator.pdf
7. 我的“hello world”;示例和存储库，演示自定义复制构造函数，赋值操作符等，与c++“三规则”相关;/“五法则”;/“零原则”;/“0/3/5规则”:https://github.com/ElectricRCAircraftGuy/eRCaGuy_hello_world/blob/master/cpp/copy_constructor_and_assignment_operator/copy_constructor_and_assignment_operator.cpp
8. [微软关于c++ 17的std::optional<>类型使用的优秀的编写
9. [相关的，since "placement new"这显然也解决了这个问题，因为这个问题是我的大多数解决方案和示例背后的关键和驱动力!] Const成员和赋值操作符。如何避免未定义的行为?