[ SOLVED (kinda) ]copy structure to QByteArray

[faldzip]

QDataStream is a class for serializing objects. But it can append its own info about serializing object. So don't expect it would be byte to byte what you want. It is made in such way that when you write something to QDataStream (with operator <<) and then you can read it from it on the other end (with operator >>) then you get the same. But who cares what is in the middle :] A little example : let's say you have a QString str("Hello"); then you write it to QDataStream object. In this stream the QDataStream can do whateveer it wants it can even append " World!" to your string :] but when you read string fron QDataStream it returns what you wrote: QString("Hello"). So if you want to have a QByteArray containing only your own data then put every byte of your data separately. For example, if you have an 32-bit integer you can do:

int num = 158;
QByteArray ba;
for (int i = 0; i < 4; ++i) {
    ba += quint8((num >> i*8) & 0x000000ff);
}

int num = 158;
QByteArray ba;
for (int i = 0; i < 4; ++i) {
    ba += quint8((num >> i*8) & 0x000000ff);
}

To copy to clipboard, switch view to plain text mode 

and now you have every byte of your int written to byte array. Then you have to construct one int from 4 bytes from byte array on the other side.

[pdoria]

Regarding the last post...
(involving qdatastream << qbytearray )

From Qt Assistant, "Format of the QDataStream Operators"

QByteArray
If the byte array is null: 0xFFFFFFFF (quint32)
Otherwise: the array size (quint32) followed by the array bytes, i.e. size bytes

So, from what I see, QDataStream doesn't do whatever "comes to its mind".
It's simply doing what it's told...

What I need to do is simply eliminate the use of QByteArray from the structure or find a fast, elegant, way to chop those array size bytes ...

BR,
Pedro Doria Meunier

[jord]

Ok. By the looks of things you're sending this data to hardware for processing. I didn't realise that.

In this case you could use a struct as you were planning to. It's quite common practice. You will probably have to tell the compiler not to pad out the struct, but I see in another thread you are already aware of that. If you are only targeting a single platform/compiler and don't have endianness worries, then you could do it this way. All you need to do is reinterpret_cast the struct into an unsigned char* (or whatever type your send function takes). eg:

#pragma pack(push, 1)
struct MyStruct
{
    unsigned char c;
    unsigned int i;
};
#pragma pack(pop)
 
void send(unsigned char* buf, size_t length)
{
    // send buf
}
 
int main()
{
    MyStruct myObj;
    myObj.c = 'A';
    myObj.i = 1;
 
    send(reinterpret_cast<unsigned char*>(&myObj), sizeof(myObj));
 
    return 0;
}

#pragma pack(push, 1)
struct MyStruct
{
    unsigned char c;
    unsigned int i;
};
#pragma pack(pop)

void send(unsigned char* buf, size_t length)
{
    // send buf
}

int main()
{
    MyStruct myObj;
    myObj.c = 'A';
    myObj.i = 1;

    send(reinterpret_cast<unsigned char*>(&myObj), sizeof(myObj));

    return 0;
}

To copy to clipboard, switch view to plain text mode 

My personal preference is to write portable code. So I would only do it this way if performance absolutely demanded it. Instead I would probably detect the endianness of the host at runtime, construct an unsigned char array of the correct size, reinterpret_cast the array at the appropriate offsets to copy in the appropriate values - applying endian conversions if necessary. But to each their own.

Edit: I notice Qt provides qFromBigEndian to handle all the endian conversion stuff.