#include <vector>
#include <cstdint>
#include <cstring>

class MyClass
{
private:
    std::vector<uint8_t> data;

public:
    MyClass() : data(100) {}

    void setHeader(uint32_t value)
    {
        std::memcpy(data.data(), &value, sizeof(value));
    }

    // ... еще устанавливаем разные части бинарного пакета

    const std::vector<uint8_t>& getData() const
    {
        return data;
    }
};

std::vector<uint8_t> t = obj.getData();

std::vector<uint8_t>& t = obj.getData();

std::vector<uint8_t> takeData()
{
    return std::move(data);
}

Здесь вызов std::move следует убрать. Несмотря на то, что в коде пытаются "подсказать" компилятору, что возвращаемый объект следует перемещать, а не копировать, используя функцию std::move, компилятор будет обязан сгенерировать более медленный ассемблерный код.

Дело в том, что возвращаемый объект – это результат вызова std::move, его тип будет Res &&. Тип фактически возвращаемого объекта и тип возвращаемого объекта по сигнатуре функции различны. Следовательно, компилятор не сможет применить для функции foo NRVO, и мы имеем дело не с оптимизацией, а с пессимизацией.

Более того, согласно стандарту C++11, если компилятор не сможет применить необязательную оптимизацию, то он должен сначала применить конструктор перемещения и лишь затем конструктор копирования для локальных переменных или формальных параметров функции.

QVector<int> vector1 = {1, 2, 3};
QVector<int> vector2 = vector1;

qDebug() << (vector1.data() == vector2.data());  // true, данные общие

std::vector<uint8_t>&& takeData()
{
    std::vector<uint8_t>&& temp = std::move(data); // temp - rvalue-ссылка на data
    return temp;
}

S>std::vector<uint8_t>&& takeData()
S>{
S>    std::vector<uint8_t>&& temp = std::move(data); // temp - rvalue-ссылка на data
S>    return temp;
S>}
S>

return std::move(data)

vector get() { return std::move(memberVector);}

S>std::vector<uint8_t> t = obj.getData();
S>

S>std::vector<uint8_t>& t = obj.getData();
S>

MyClass(const MyClass&) = delete;
MyClass& operator=(const MyClass&) = delete;

#include <vector>
#include <cstdint>
#include <cstring>
#include <cstdio>

struct T {
    int value{};

    explicit T(int value) : value(value) { printf("T(%d)\n", value);}
    ~T() { printf("~T(%d)\n", value);}

    T(const T&) = delete;
    T(T&&) = delete;
    T& operator=(const T&) = delete;
    T& operator=(T&&) = delete;
};

T takeData(int value)
{
    return T(value);
}

int main() {
    auto t = takeData(42);
}