为什么将原始指针转换为unique_ptr不会删除原始指针？

Question

I am trying to understand unique_ptr, but they have me a bit stumped. Consider the following code:

PartClass * part= new PartClass;

//The OwnerClass is a composite that excpects a unique_ptr
OwnerClass * owner = new OwnerClass( unique_ptr<PartClass>( part );

After the second line of code I would expect the original pointer - part - to have been deleted. After all, as soon as you have a unique_ptr it creates a lot of fuss, needing to be moved, etc. So why does the compiler allow a raw pointer to still access the part-object? Doesn't it violate the whole concept of unique_ptr?

Answer 1

It works for the same reason that you can explicitly give out the pointer. For example:

std::unique_ptr<int> value = std::make_unique<int>(1);
int* pValue = value.get();

While pValue can access the memory it does not own it and should not delete the memory. In your example the ownership has been transferred while there happens to be a raw pointer that still points the the resource, which is fine.

Answer 2

A unique_ptr is just another class from the compiler standpoint. As it stands, one of its ctors accepts a raw pointer. It's dtor will release the memory via passed in raw pointer (typically free ).

The fact your variable part points to the same memory location does not change any of the unique_ptr behaviour. In this context that is just another local object.

The fact you do hold a raw pointer to the same memory managed via unique_ptr (order does not matter) may potentially lead to a double free, and undefined behaviour (hopefully a crash). I'd recommend passing new PartClass directly to unique_ptr initialization.

Answer 3

By passing part to the unique_ptr you passed across ownership of the pointer to unique_ptr .

Yes, you've still got a raw pointer, but as you've given ownership to the smart pointer you should consider it off limits. You certainly don't want to be deleting it.

Answer 4

The PartClass object still exists, and that's what was intended, so it absolutely should not be deleted. The question is really why isn't part set to a null pointer, and that's because it's up to you to manage such things. The pointer is valid, and you can use it if you want to. If you don't want to use it, don't keep it around.