#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);
}

template <typename T>
class greedy_vector : public std::vector<T> {
public:
    using std::vector<T>::vector;

    greedy_vector explicit_copy() const {
        return *this;
    }

private:
    greedy_vector(const greedy_vector& other): std::vector<T>(other) {}
};

greedy_vector<int> data{100};
const auto copy = data; // ошибка

SP>template <typename T>
SP>class greedy_vector : public std::vector<T> {
SP>public:
SP>    using std::vector<T>::vector;

SP>    greedy_vector explicit_copy() const {
SP>        return *this;
SP>    }

SP>private:
SP>    greedy_vector(const greedy_vector& other): std::vector<T>(other) {}
SP>};
SP>

SP>greedy_vector<int> data{100};
SP>const auto copy = data; // ошибка
SP>

#include <vector>

template <typename T>
class greedy_vector : public std::vector<T> {
public:
    using std::vector<T>::vector;

    friend greedy_vector explicit_copy(const greedy_vector& orig) {
        return greedy_vector(orig); // guaranteed RVO
    }

private:
    greedy_vector(const greedy_vector&) = default;
};

int main()
{
    greedy_vector<int> data{100};
    const auto copy = explicit_copy(data);
}

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

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

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

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

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

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

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

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

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

for(uint8_t n : obj.takeData())
  std::cout << ' ' << n;
std::cout << '\n';

// ой, obj пустой :(