如何将push_back unique_ptr参数推到共享ptrs的向量上

Question

I'm having a tough time pushing back a unique_ptr from my method parameter onto a vector of shared pointers.

IFCCB.h:

private:
vector<shared_ptr<IFC>>  m_shpVectorIFC;
public:
void addElementVectorIFC(unique_ptr<IFC> rupIFC);

IFCCB.cpp:

void IFCCB::addElementVectorIFC(unique_ptr<IFC> rupIFC)
{
    m_shpVectorIFC.push_back(std::unique_ptr<IFC>(new IFContent(rupIFC)));
}

I'm getting the error:

C2664: 'IFC::IFC(const IFC &)' : cannot convert argument 1 from 'std::unique_ptr>' to 'IFO *'

In this case, IFO is the heirarchical parent of IFC. I'm not sure why it's looking at that.

I've looked at vector info and shared_ptr info , as well as using unique_ptr with standard library containers .

Any ideas? I'm not used to working with shared_ptrs and unique_ptrs.

Answer 1

The problem is that push_back takes the container's value_type , which is shared_ptr<IFC> , but you are passing it a unique_ptr<IFC> and the conversion from unique_ptr to shared_ptr uses an explicit constructor and can only be done from a unique_ptr rvalue, so the argument cannot be implicitly converted to shared_ptr .

To make it work you need to use std::move to convert the unique_ptr to an rvalue and then either do the conversion to shared_ptr explicitly:

unique_ptr<IFC> p;
// ...
m_shpVectorIFC.push_back(std::shared_ptr<IFC>(std::move(p)));

Or use emplace_back instead, because that function can use explicit constructors to construct the new container element:

m_shpVectorIFC.emplace_back(std::move(p)));

I'm not convinced your code that creates a new unique_ptr is correct (why can't you just insert rupIFC into the container using either of the solutions shown above?) but if that's really what you want to do, the error you get is because you are trying to pass unique_ptr<IFC> to the IFContent constructor, which takes a IFO* not a unique_ptr<IFC> . To make that compile you need to get the raw pointer out of rupIFC :

std::unique_ptr<IFC>(new IFContent(rupIFC.get()))

However this is probably unsafe, because the pointer you passed to the IFContent constructor will be deleted at the end of the function when rupIFC is destroyed, so maybe you meant to release it:

std::unique_ptr<IFC>(new IFContent(rupIFC.release()))

NB as dlf's answer says, there is no point creating a unique_ptr if you just want to convert it to a shared_ptr immediately, so you could simply do:

m_shpVectorIFC.emplace_back(std::make_shared<IFContent>(rupIFC.release()));

Answer 2

Based on your addendum, you will need to use unique_ptr::get() to provide the IFContent constructor with the raw pointer it wants. Depending on what it does with that pointer, you may actually need to use release instead to prevent double-deletion. Also, no need to create an intermediate unique_ptr when it's just going to be converted right into a shared_ptr anyway:

void IFCCB::addElementVectorIFC(unique_ptr<IFC> rupIFC)
{
    m_shpVectorIFC.push_back(std::shared_ptr<IFC>(new IFContent(rupIFC.get())));
}