Concurrent access to data with QReadWriteLock
Locking
Let's see what these member functions actually do, and what can go wrong:
getData
The lock acquired in getData basically only ensures that nobody is currently modifying data while inside. As soon as the caller gets the returned value, another thread is free to modify it.
To be a bit clearer, this is how RAII breaks down:
QVector&lt;DataType&gt; getData() {
    QReadWriteLocker lock(rwLock);
    QVector&lt;DataType&gt; temp = data;
    lock.~QReadWriteLocker(); // unlock
    return temp;
}

So the lock doesn't actually cover subsequent usage.
beginModifyData/endModifyData
These two member functions expect to be called in tandem. But what happens if the caller to beginModifyData forgets to call endModifyData (e.g. because an exception was thrown)? Obviously, in that case the lock never gets released.
Also, somebody might store the returned pointer, thus having unsynchronized access to the data after the lock got released.
General stuff
Is there any specific reason why rwLock has to be a pointer? It could simply be of type QReadWriteLock instead.
Is there any specific reason why beginModifyData returns a QVector&lt;DataType&gt;* instead of a QVector&lt;DataType&gt;&amp;?
Your question regarding RVO
No, that is not how return value optimization (RVO) works. For a better understanding, if the compiler applies RVO it might conceptually rewrite the code to something similar to this:
void getData(QVector&lt;DataType&gt;* return_value) {
    QReadWriteLocker lock(rwLock);
    // construct a new QVector&lt;DataType&gt; at the given address (to be passed from the callsite)
    new(return_value) QVector&lt;DataType&gt;(data);
}

// the callsite would be rewritten from
QVector&lt;DataType&gt; myData = dataManager-&gt;getData();
// to
QVector&lt;DataType&gt; myData; // uninitialized!
dataManger-&gt;getData(&amp;myData);

So this obviously won't work with a reference.
Without RVO, the reference won't work at all, as the lifetime of the returned object ends at the end of its declaration. However, it will work (at least partially) for a const QVector&lt;DataType&gt;&amp; as lifetimes of temporaries get extended for those (though it will still refer to the copy).