为什么在进行赋值时调用移动构造函数？

Question

I'm trying to make a sample implementation of std::unique_ptr. Here is the code:

include <iostream>

template<typename T>
class UniquePtr
{
public:
  explicit UniquePtr(T * ptr)
    :m_ptr(ptr)
  {};

  UniquePtr(UniquePtr const & other) = delete;
  UniquePtr& operator=(UniquePtr const & other) = delete;

  explicit UniquePtr(UniquePtr && other)
  {
    m_ptr = other.m_ptr;
    other.m_ptr = nullptr;
  }

  UniquePtr & operator=(UniquePtr && other)
  {
    std::cout << "Move assignment called " << std::endl;
    m_ptr = other.m_ptr;
    other.m_ptr = nullptr;
  }

  ~UniquePtr()
  {
    delete m_ptr;
  }

  T& operator*()
  {
    return *m_ptr;
  }

  T& operator->()
  {
    return m_ptr;
  }

private:
  T * m_ptr = nullptr;
};

int main()
{
  UniquePtr<int> t(new int(3));
  t= UniquePtr<int>(new int(4));

  std::cout << *t << std::endl;
}

This code compiles and I'm able to see the value 4 in the output even after deleting the default assignment and copy constructor. What am I doing wrong?

Answer 1

In the assignment, move is called because the UniquePtr<int>(new int(4)) is constructing a temporary object, and in this case the compiler tries to use the move assignment if possible, else it would fall back to the copy assignment, which is deleted.

UniquePtr<int> t(new int(3));
t= UniquePtr<int>(new int(4)); // move assignment because temporary
auto k = t; // copy assignment since t is not temporary and so does not compile.

As commented, the move assignment is not returning *this , you should enable all warnings. Also the last operator-> has a syntax error, it returns a pointer but expects a reference.

Additionally, your code has a major issue, in case of exceptions you could have a memory leak. Suppose you write something like:

class Banana
{ ... }

void eatBanana(UniquePtr<Banana> banana, int amountToEat);
int computeAmount();

eatBanana(UniquePtr<Banana>(new Banana(3)), computeAmount());

If, for any reason, the computeAmount() function throws an exception, then the memory allocated by new could never be released, because computeAmount() could be executed between new and the constructor of the UniquePtr . For this reason, we normally use std::make_unique() .

You should implement your own version of make_unique() and use it, it's trival, see here:https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique

Here more information about the issues and the solution: https://www.oreilly.com/library/view/effective-modern-c/9781491908419/ch04.html