Implementing a move constructor(rvalue reference) for an array class

Question

I have an array class I grabbed off of a website that gives an example of a move constructor. How would one implement this move constructor in an example program however? I feel like I understand the function definition, but I have no idea how one would make use of this in a program.

class ArrayWrapper
{
public:
    // default constructor produces a moderately sized array
    ArrayWrapper ()
        : _p_vals( new int[ 64 ] )
        , _size( 64 )
    {}

    ArrayWrapper (int n)
        : _p_vals( new int[ n ] )
        , _size( n )
    {}

    // move constructor, how does this come in handy?
    ArrayWrapper (ArrayWrapper&& other)
        : _p_vals( other._p_vals  )
        , _size( other._size )
    {
        other._p_vals = NULL;
    }

    // copy constructor
    ArrayWrapper (const ArrayWrapper& other)
        : _p_vals( new int[ other._size  ] )
        , _size( other._size )
    {
        for ( int i = 0; i < _size; ++i )
        {
            _p_vals[ i ] = other._p_vals[ i ];
        }
    }
    ~ArrayWrapper ()
    {
        delete [] _p_vals;
    }

private:
    int *_p_vals;
    int _size;
};

[What are move semantics](http://stackoverflow.com/questions/3106110/what-are-move-semantics) — David G, May 13 '13 at 23:48

score 2 · Accepted Answer · answered May 13 '13 at 23:48

2

How would one implement this move constructor in an example program however?

I think the code you have shows that already.

I feel like I understand the function definition, but I have no idea how one would make use of this in a program.

Just use one of the several ways to trigger a move. For instance:

ArrayWrapper aw;
ArrayWrapper aw2 = std::move(aw);

Or even:

ArrayWrapper foo()
{
    ArrayWrapper aw;
    //...
    return aw;
}

// ...

ArrayWrapper aw2 = foo();

Notice, that in this last case the compiler is likely to elide the call to the move constructor anyway.

answered May 13 '13 at 23:48

Andy Prowl

124,023
23
387
451

So does this make aw2 a deep copy of aw? by use of the move constructor? – Syntactic Fructose May 13 '13 at 23:49
@Need4Sleep: No, the move constructor is meant to *move* the content of the moved-from object into the object being constructed. That is the opposite of deep-copying – Andy Prowl May 13 '13 at 23:50
@Need4Sleep, It's a shallow copy. You can't use `aw` after this. It's good for temporaries that are about to be destroyed. It only copies a pointer, not the whole array. – chris May 13 '13 at 23:50
ok, so this literally MOVES the contents of aw into aw2? Meaning aw is ready to be destructed/reassigned after the aw2 call? – Syntactic Fructose May 13 '13 at 23:52
@Need4Sleep: Redefined is not the right word, reassigned perhaps. But I feel like you got it – Andy Prowl May 13 '13 at 23:54
@Andy Prowl, yes yes, i'll edit to change my comment. Thanks for the explanation everyone. – Syntactic Fructose May 13 '13 at 23:55

score 1 · Answer 2 · answered May 13 '13 at 23:49

It is used in the same situations that the copy constructor would be but only if the expression being copied from is an rvalue. An rvalue typically refers to a temporary object. So, for example, if you have a function foo that returns an ArrayWrapper by value, the expression that calls that function would be an rvalue.

ArrayWrapper aw = foo();

Here, the ArrayWrapper object will be constructed from the temporary object returned by foo. The move constructor overload is chosen because the rvalue reference argument binds to the rvalue expression.

A move constructor typically leaves the object it is moving from in an valid but indeterminate state.

Implementing a move constructor(rvalue reference) for an array class

2 Answers2