Why isn't move operator just destructor + move constructor

Question

Considering the following snippet :

class Foo
{
public:
    /* ... */
    Foo(Foo &&other);
    ~Foo();

    Foo &operator=(Foo &&rhs);

private:
    int *data;
};

Foo::Foo(Foo &&other)
{
    data = other.data;
    other.data = nullptr;
}

Foo::~Foo()
{
    delete data;
}

Foo &Foo::operator=(Foo &&other)
{
    if (this == &other) return *this;

    delete data;            /* SAME AS DESTRUCTOR */

    data = other.data;      /* SAME AS MOVE CONSTRUCTOR */
    other.data = nullptr;
    return *this;
}

This snippet is pretty much what I always end up having.

Why do we need a move operator if its behavior can be deduced ?
If this statement isn't true, in which case the move operator behave differently than just destructor + move constructor ?

It can be written like `::std::swap(this->data, other.data)` for example — user7860670, Jan 15 '19 at 09:27
Even though it's only an example, you should use the initialisation list with the constructor and your assignment function isn't returning a result in all cases. Doing `this != &other` is preferable to the logic you have and then always returning *this. — Nick, Jan 15 '19 at 09:27
This answer of Howard Hinnant gives a relevant discussion about why there is likely no _single best version_ of move assignment operator: https://stackoverflow.com/a/9322542/580083. Another one: https://stackoverflow.com/a/39864881/580083. — Daniel Langr, Jan 15 '19 at 09:32

score 2 · Answer 1 · answered Jan 15 '19 at 10:09

2

With a small change to your class, it can.

class Foo
{
public:
    /* ... */
    // deleted copy constructor and copy assignment
    // generated destructor, move constructor and move assignment

private:
    std::unique_ptr<int> data;
};

answered Jan 15 '19 at 10:09

Caleth

52,200
2
44
75

Lightness Races in Orbit · Accepted Answer · 2019-01-15T10:55:57.253

Because it can't be deduced. The language doesn't know what is involved in tearing down your int*. Maybe you have other housekeeping to perform.

In fact, if you're writing a move constructor, you'll usually have other housekeeping to perform, because if all you are doing is deleteing dynamic memory, you should have been using a smart pointer and wouldn't need to write your own move constructor at all.

Furthermore, you're repeating logic in your code. You can "re-use the destructor" by avoiding these antics in your move constructor & assigner, simply swapping pointers instead, and let the moved-from object's destructor do what it usually does when the time comes:

Foo::Foo(Foo&& other)
   : data(nullptr)
{
    *this = std::move(other);
}

Foo& Foo::operator=(Foo&& other)
{
    std::swap(this->data, other.data);
    return *this;
};

(Disclaimer: there's probably a more idiomatic way to do this that I can't remember, but you get the point.)

Now there's much less boilerplate. So you can see that, even if the language deduced move constructors for you, it wouldn't involve a destructor at all.

Why isn't move operator just destructor + move constructor

2 Answers2