C++ 如何将复制构造函数和赋值运算符添加到此类？

向此类添加副本构造函数时遇到问题：

我需要添加它，以便在stl向量容器中添加并发_队列。 尝试了下面的方法，它几乎可以编译。事实上，如果我从它编译的复制构造函数中删除了_互斥体和_condition_变量。当我把它加回去的时候，它不会。赋值运算符在编译方面似乎没有问题

concurrent_queue(concurrent_queue<Data> const& rhs):
    the_queue(rhs.the_queue),
    the_mutex(rhs.the_mutex),
    the_condition_variable(rhs.the_condition_variable)
{
}

concurrent_queue<Data>& operator = (concurrent_queue<Data> const& rhs)
{
    if (this == &rhs) return *this; // check for self assignment

    the_queue = rhs.the_queue;
    the_mutex(rhs.the_mutex);
    the_condition_variable(rhs.the_condition_variable);
}

concurrent_queue（concurrent_queue const&rhs）：
_队列（右侧为_队列），
_互斥体（rhs.the_互斥体），
_条件_变量（rhs.条件_变量）
{
}
并发队列和运算符=（并发队列常量和rhs）
{
如果（this==&rhs）返回*this；//检查自赋值
_队列=rhs。_队列；
_互斥体（rhs.the_互斥体）；
_条件_变量（rhs.条件_变量）；
}

我得到的错误如下：

concurrentqueue.h: In copy constructor ‘concurrent_queue<Data>::concurrent_queue(const concurrent_queue<Data>&) [with Data = Packet*]’:
/usr/include/c++/4.4/bits/stl_construct.h:74:   instantiated from ‘void std::_Construct(_T1*, const _T2&) [with _T1 = concurrent_queue<Packet*>, _T2 = concurrent_queue<Packet*>]’
/usr/include/c++/4.4/bits/stl_uninitialized.h:187:   instantiated from ‘static void std::__uninitialized_fill_n<<anonymous> >::uninitialized_fill_n(_ForwardIterator, _Size, const _Tp&) [with _ForwardIterator = concurrent_queue<Packet*>*, _Size = long unsigned int, _Tp = concurrent_queue<Packet*>, bool <anonymous> = false]’
/usr/include/c++/4.4/bits/stl_uninitialized.h:223:   instantiated from ‘void std::uninitialized_fill_n(_ForwardIterator, _Size, const _Tp&) [with _ForwardIterator = concurrent_queue<Packet*>*, _Size = long unsigned int, _Tp = concurrent_queue<Packet*>]’
/usr/include/c++/4.4/bits/stl_uninitialized.h:318:   instantiated from ‘void std::__uninitialized_fill_n_a(_ForwardIterator, _Size, const _Tp&, std::allocator<_Tp2>&) [with _ForwardIterator = concurrent_queue<Packet*>*, _Size = long unsigned int, _Tp = concurrent_queue<Packet*>, _Tp2 = concurrent_queue<Packet*>]’
/usr/include/c++/4.4/bits/stl_vector.h:1035:   instantiated from ‘void std::vector<_Tp, _Alloc>::_M_fill_initialize(size_t, const _Tp&) [with _Tp = concurrent_queue<Packet*>, _Alloc = std::allocator<concurrent_queue<Packet*> >]’
/usr/include/c++/4.4/bits/stl_vector.h:230:   instantiated from ‘std::vector<_Tp, _Alloc>::vector(size_t, const _Tp&, const _Alloc&) [with _Tp = concurrent_queue<Packet*>, _Alloc = std::allocator<concurrent_queue<Packet*> >]’
test.cpp:18:   instantiated from here
concurrentqueue.h:24: error: no match for call to ‘(boost::mutex) (boost::mutex&)’

concurrentqueue.h:在复制构造函数“concurrent_queue:：concurrent_queue（const concurrent_queue&）[with Data=Packet*]”中：
/usr/include/c++/4.4/bits/stl_construct.h:74：从“void std:：_construct（_T1*，const_T2&）[带_T1=concurrent_queue，_T2=concurrent_queue]”实例化
/usr/include/c++/4.4/bits/stl_uninitialized.h:187：从“静态void std:：__uninitialized_fill_n:：uninitialized_fill_n”（_ForwardIterator，_Size，const_Tp&）[其中_ForwardIterator=concurrent_queue*，_Size=long unsigned int，_Tp=concurrent_queue，bool=false]）
/usr/include/c++/4.4/bits/stl_uninitialized.h:223:从“void std:：uninitialized_fill_n”（_ForwardIterator，_Size，const _Tp&）实例化[其中_ForwardIterator=concurrent_queue*，_Size=long unsigned int，_Tp=concurrent_queue]'
/usr/include/c++/4.4/bits/stl_uninitialized.h:318：从“void std:：__uninitialized_fill_n_a”（_ForwardIterator，_Size，const_Tp&，std:：allocator&）[带_ForwardIterator=concurrent_queue*，_Size=long unsigned int，_Tp=concurrent__队列，_Tp2=concurrent_队列]实例化
/usr/include/c++/4.4/bits/stl_vector.h:1035:从“void std:：vector:：_M_fill_initialize（size\u t，const\u Tp&）[使用_Tp=concurrent\u queue，_Alloc=std:：allocator]实例化
/usr/include/c++/4.4/bits/stl\u vector.h:230：从“std:：vector:：vector（size\t，const\u Tp&，const\u Alloc&）”实例化[with _Tp=concurrent\u queue，_Alloc=std:：allocator]
test.cpp:18：从此处实例化
concurrentqueue.h:24:错误：对“（boost:：mutex）（boost:：mutex&）”的调用不匹配

编辑： 看起来boost互斥继承了不可复制的，我认为条件变量也是一样的。

---

有趣的是，在作业中我可以复制它。为什么会这样呢？我是否需要担心，在我使用它的情况下，它实际上是不可复制的？

这两个

boost:：mutex

和

boost:：condition\u variable

都只有默认构造函数。除此之外，您不希望复制它们的（潜在锁定的）状态—只需使用默认构造函数即可

---

另外，您不应该直接复制

队列，因为这不是线程安全的。
AFAIK，
boost:：mutex
和
boost:：condition
不可复制（而且复制互斥锁也没有任何意义）。使用副本构造函数中的默认构造函数构造它们，如下所示：

concurrent_queue(concurrent_queue<Data> const& rhs):
    the_queue(rhs.the_queue),
    the_mutex(),
    the_condition_variable()
{
}

concurrent_queue（concurrent_queue const&rhs）：
_队列（右侧为_队列），
_mutex（），
_条件_变量（）
{
}

请注意，要使复制构造函数线程安全，还有很多困难。如果您没有在线程之间复制对象，那么这应该不是问题。按照您的想法，所有的
并发\u队列
对象都是预先分配的，这不应该是一个问题。
不需要编写其中任何一个：如果合法的话，编译器会发出代码来复制成员。您需要做的是编写法律代码，如其他答案所示。