Append quint16/unsigned short to QByteArray quickly

In my project I'm working with QByteArrays appending data to them as the program goes. Most of the time, a simple quint8 gets appended just fine using QByteArray::append(). But when a quint16 gets appended, only 1 byte gets appended instead of 2.

QByteArray ba = QByteArray::fromHex("010203");
quint number(300);//300 in hex is 012c

ba.append(number);//What should be appended instead of just number?

//the current incorrect result is
ba.toHex() == "0102032c"

//the desired result is
ba.toHex() == "010203012c"

I've already tried this, but it just inserts the value as a string (4 bytes):

ba.append(QByteArray::number(number, 16));

What should I append to the QByteArray so both bytes of "number" get appended instead of just one byte? Also, the fastest method possible is preferred since this program needs to have great performance times. So absolutely no converting to QStrings.

Thanks for your time.

Solution

On its own, QByteArray only supports appending bytes; to append a big-endian representation of fixed-size integer types you can build your own operator<< (or what you prefer) overloads using the appropriate bit shifts:

QByteArray &operator<<(QByteArray &l, quint8 r)
{
    l.append(r);
    return l;
}

QByteArray &operator<<(QByteArray &l, quint16 r)
{
    return l<<quint8(r>>8)<<quint8(r);
}

QByteArray &operator<<(QByteArray &l, quint32 r)
{
    return l<<quint16(r>>16)<<quint16(r);
}

This allows you to write code like:

QByteArray b;
b<<quint16(300);     // appends 0x01 0x2c
b<<quint8(4);        // appends 0x04
b<<quint16(4);       // appends 0x00 0x04
b<<quint32(123456);  // appends 0x00 0x01 0xe2 0x40
b<<quint8(1)<<quin16(2)<<quint32(3); // appends 0x01 0x00 0x02 0x00 0x00 0x00 0x03

You should probably avoid writing

QByteArray b;
b<<1;

because in theory the output depends on the size of the current platform integer (although AFAIK on all platforms supported by Qt int is 32 bit).