Vfrdtyky

I have the following QByteArray:

QByteArray ba;

ba.resize(3);

ba[0]=ba[2]=0x8a;

ba[1]=0x0d;          //so ba=8a0d8a

I want to add a hexadecimal number to the above QByteArray. For eg. on adding 0x01, ba should contain 8a0d8b. Any such operation involving carry should be propagated forward as in a normal hex addition. I have tried using + operator:

ba=ba+1;

but it concatenates (resulting in 8a0d8a01 in the above case) instead of performing actual operation. How can this be done ?

I think this is the easiest solution:

uint32_t num = (b[3] << 24) + (b[2] << 16) + (b[1] << 8) + (b[0]);

num++; // add one

b[0] = num & 0xff;

b[1] = (num >> 8) & 0xff;

b[2] = (num >> 16) & 0xff;

b[3] = (num >> 24) & 0xff;

Basically you convert to an arithmetic integer back and forth. Just make sure you don't overflow. This is a simple example. You can make it a class with a state that returns QByteArray on some method or you can make a function that does this once at a time.

First off: There is no such functionality in QByteArray. There are ways around it however, as long as you know how long the bytearray will be. There is however one tiny thing that makes this extra complicated: Endianess.

The following example assumes all your bytearrays have a maximum length. The function is generic, so you can decide dynamically if required:

template <typename TInt>

void addNumber(QByteArray &data, TInt number) {

    static_assert(std::is_integral<TInt>::value, "TInt must be an integral type");



    constexpr auto maxSize = sizeof(TInt);

    const auto dSize = data.size();



    // make shure no data that is longer then the allowed integer size is passed

    Q_ASSERT_X(dSize <= maxSize, Q_FUNC_INFO, "bytearrays longer than sizeof(TInt) byte are not allowed!");



    // prepend '' bytes to the array to fill it up to an N byte length

    if(dSize < maxSize)

        data = QByteArray{maxSize - dSize, ''} + data;



    // convert to a number, add and convert back

    auto dataNum = qFromBigEndian<TInt>(data.constData());

    dataNum += number;

    qToBigEndian(dataNum, data.data());



    // resize the data back to the original size, dropping the previously prepended bytes

    if(dSize < maxSize)

        data = data.mid(maxSize - dSize);

}

To use the method, simply find out how long your bytearrays can be and then use the method with the according type. For example, if your data is limited to at most 4 bytes (as specified in the commencts), you could use it as:

QByteArray ba = "x8ax0dx8a";

addNumber<quint32>(ba, 1u);

// ba is now "x8ax0dx8b"

Important: Be careful with the template argument. specify it explicitly to ensure you do not accidentially pass a literal of a different type. For example, calling it as simply addNumber(ba, 1) will deduce TInt as int - not an unsinged int.

EDIT:
In case you define your bytearrays endianness to be the same as the current plattform, no such conversion is needed. The code would change to:

// convert to a number, add and convert back

*(reinterpret_cast<TInt*>(data.data())) += number;

It really depends on where this data comes from and how you use it.

Why not use a simple data like

template <typename T> union BData

{

     uint8_t data[sizeof(T)];

     T value;

 }; 

Then you can perform your arithmetic operations and extract bytes from the union. However you should be aware of endiness.