std::move 和 unique_ptr::release 有什么区别？

Question

I am wondering why pstr2 is not null at the 4th line of STDOUT. AFAIK, move and release do not have ownership after a call.

  auto pstr = make_unique<string>(5, '*');
  cout << (pstr ? *pstr : "pstr is empty") << endl;
  auto pstr2(pstr.release());
  cout << (pstr ? *pstr : "pstr is empty") << endl;
  cout << (pstr2 ? *pstr2 : "pstr2 is empty") << endl;
  auto pstr3(move(pstr2));
  cout << (pstr2 ? *pstr2 : "pstr2 is empty") << endl;
  cout << (pstr3 ? *pstr3 : "pstr3 is empty") << endl;

The output is

*****
pstr is empty
*****
***** <-- my curious part.
*****

Answer 1

When you declare a variable as auto for its type, its actual type is deduced from whatever value is assigned to the variable during its initialization.

The type of pstr is deduced as unique_ptr<string> , because that is what make_unique<string>(5, '*') returns.

auto pstr2(pstr.release()); does not do what you think it does. release() does not return a unique_ptr<string> , like you are expecting. It returns the raw string* pointer that was being held by pstr . So, the type of pstr2 is deduced as string* , not as unique_ptr<string> (and since pstr has given up its ownership of its string* pointer, you need to explicitly call delete pstr2; when you are done, or else the string object will be leaked).

Similar with auto pstr3(move(pstr2)); . Since pstr2 is a raw string* , and std::move() is just a copy for a raw pointer, the type of pstr3 is also deduced as string* , not as unique_ptr<string> . pstr2 and pstr3 are pointing at the same string object in memory, which is why neither of them are null, and both output the same data to the console.

If you change the type of pstr2 to replace the auto with unique_ptr<string> explicitly (or decltype(pstr) ), then you will get the behavior you are expecting, eg:

auto pstr = make_unique<string>(5, '*');
cout << (pstr ? *pstr : "pstr is empty") << endl;
unique_ptr<string> pstr2(pstr.release());
// or: decltype(pstr) pstr2(pstr.release());
cout << (pstr ? *pstr : "pstr is empty") << endl;
cout << (pstr2 ? *pstr2 : "pstr2 is empty") << endl;
auto pstr3(move(pstr2));
// or: decltype(pstr2) pstr3(move(pstr2));
cout << (pstr2 ? *pstr2 : "pstr2 is empty") << endl;
cout << (pstr3 ? *pstr3 : "pstr3 is empty") << endl;

Output

*****
pstr is empty
*****
pstr2 is empty
*****

Live Demo

Answer 2

I think you are assuming that pstr.release() returns a std::unique_ptr whereas in the code as written it returns a std::string * . Since this cannot be moved from, this explains the results you get.

If you change:

auto pstr2(pstr.release());

to:

auto pstr2 = unique_ptr<string>(pstr.release());

then you get the results you expect.

Live demo

Answer 3

Because pstr.release() returns a raw pointer, then pstr2 & pstr3 are deducated as raw pointers.

After compiling they are just like

unique_ptr<string> pstr = make_unique<string>(5, '*');
string* pstr2(pstr.release());
string* pstr3(move(pstr2));