Move semantics with LValue reference

Question

So Move semantics is great, giving us higher performence.

I read this was a completly new feature and without C++11 it is 'impossible' to do this.

But could we do this before C++11? Like something that goes like the below.

class AAA
{
private:
    int* m_data;
public:
    AAA(int _data) : m_data(new int(_data)) { }
    AAA(AAA& _other) // Not using RValue reference.
    {
        m_data = _other.m_data;
        _other.m_data = nullptr;
    }

    ~AAA() { delete m_data; }
};

int main()
{
    AAA sth1(100);
    AAA sth2(sth1)
    return 0;
}

I thought that what the existence of RValue reference is for is not to make the same functions whose argument is just slighty different(like Const and Non-Const).

Simply, with RValue reference which is just another 'type', we can do both Copy constructor and Move constructor at the same time. And that's it.

Wondering if I am correct or am missing something huge.

Thanks in advance.

Answer 1

std::auto_ptr did exactly what you suggest. The problem was that it made behavior confusing and copying impossible. Rvalue references allow one to make classes that can be both moved and copied.

rvalue references allow automatic moving/copying based upon context (for example the moving of a temporary) trying to simulate this with an lvalue style copy constructor (which actually performed a move) would likely be disastrous.

Answer 2

My understanding is that move semantic is not only possible but also available as library ( Boost.Move ) for C++03 compilers (maybe with some restrictions). However, the language implementation might have been necessary both to allow free optimization without touching anycode and to simplify it's use as much as possible.

Answer 3

Yes, there is something missing, which you do not get with lvalues, even if they are non const. Non const lvalues cannot be produced from temporaries, so your attempt does not work in that case.

Answer 4

What if you want to pass an rvalue to your constructor? Your ctor will fail because it's non-const. With rvalue references, you can pass an rvalue to the ctor, and move from it, as rvalues are always temporaries.