[Merged] copying data from structure to a ByteArray and vise versa

  • Can someone provide me and example on how to get this to work?

  • How can I access ByteArray┬┤s underlying data buffer so I can use memmove to copy data from a structure to a ByteArray data type? Please provide example. Thanks!

  • Sorry this post is under the wrong thread...

  • Have You tried QDataStream with a QBuffer.
    struct YourStruct
    quint8 x;
    quint16 y;
    float z;

    YourStruct(const YourStruct& other)
    bool operator == (const WeaponStats& other) const
    bool operator < (const WeaponStats& other) const
    bool operator > (const WeaponStats& other) const


    inline QDataStream& operator<<(QDataStream& out, const YourStruct& str)
    out << str.x;
    out << str.y;
    out << str.z;
    return out;

    inline QDataStream& operator>>(QDataStream& in, YourStruct& str)
    in >> str.x;
    in >> str.y;
    in >> str.z;
    return in;


    //before using call

    or just have a look "here":http://www.qtcentre.org/wiki/index.php?title=Using_custom_data_types_with_Qt#QDataStream

  • Post Irrelevant since Merged

  • is there not a way I can use memmove?

  • char * QByteArray::data ()
    Returns a pointer to the data stored in the byte array.
    Have You tried this.

  • yes I have... the following code I have does not seem to work. I checked under the memory window after the memmove function but do not see the result I am expecting.

    struct_MtrTxMsgType TX_Msg;
    int txcnt, rcvLen;
    QByteArray TX_Buffer;
    QByteArray RX_Buffer;
    bool ok;

    memset(&TX_Msg.WakeUp[0], 0xFE, sizeof(TX_Msg.WakeUp));
    TX_Msg.Header = 0x68;
    TX_Msg.Address[0] = 0x09;
    TX_Msg.Address[1] = 0x90;
    TX_Msg.Address[2] = 0x78;
    TX_Msg.Address[3] = 0x56;
    TX_Msg.Address[4] = 0x34;
    TX_Msg.Address[5] = 0x12;
    TX_Msg.Delimeter = 0x68;
    TX_Msg.R_W = 0x01;
    TX_Msg.DataLength = 0x02;
    memmove((void *)TX_Buffer.data(), &TX_Msg, sizeof(TX_Msg));


  • Do you need memmove for speedup or for something else? In first case I think using QByteArray will remove all advantages of using memmove.

  • Denis: Why? You can reserve a chunk of memory and qMemCopy into it. Why is that slower as using some other method?

  • phamtv: I'd recommend using qMemCopy/qMemSet from QtCore/QtGlobal. I think those are not documented, so they are not officially supported, but they work well for me.

  • Tobias, hm, I mostly saying that from my point of view memmove and other c things should be used now only if you are know what you are doing (e.g. if you need to speed up your memory management). In common cases such low-level work is not needed. And in case of mixing memmove for initializing data and using QByteArray to work with it I think initial speedup from memmove will be neglected by QByteArray abstractions.

  • Denis: You are right that you should not need these low level functionality 95% of the time... but it is still very useful for the last 5%:-)

    I actually do not think that the QByteArray overhead is that big by the way (I did not do any measurements though), it is just a wrapper around a piece of memory after all. Resizing the buffer is of course expensive and needs to be avoided.

  • phamtv: You did read the "documentation of QByteArray":http://doc.trolltech.com/4.7/qbytearray.html, didn't you? It states quite clearly how to access its buffer.

  • yes I have read the QByteArray document. I am still puzzled on the benefits of a QByteArray. My background with byte arrays have always been something similar to quint8 arr[] in which I can later cast to whatever my data structure is. Besides dynamic resizing of the array size, are there any other advantages to QByteArray over the quint8[]? Also, is it true that if I use the QByteArray, I should use the qMemCopy/qMemSet from QtCore/QtGlobal instead of the memmove, memcpy???

  • To quote the documentation:

    QByteArray can be used to store both raw bytes (including '\0's) and traditional 8-bit '\0'-terminated strings. Using QByteArray is much more convenient than using const char *. Behind the scenes, it always ensures that the data is followed by a '\0' terminator, and uses implicit sharing (copy-on-write) to reduce memory usage and avoid needless copying of data.

    Using QByteArray or not does not matter for qMemCopy or memcpy. The first is just a wrapper around the latter anyway. qMemCopy will be there wherever Qt is available, and it is in a Qt header which is included in almost all Qt code.

  • Thank you Tobias. As always, your continual support is greatly appreciated!

  • That time tests:

    @ QByteArray ba1(2048, 0);
    QByteArray ba2(2048, 255);
    QByteArray ba3(1024, 255);
    char *ba1data = ba1.data();
    char *ba2data = ba2.data();

    QElapsedTimer timer;

    for (int i = 0; i < 100000000; i++)
    //ba2.replace(1000, 1024, ba1.data()+1000, 1024); // For 12324 ms.
    //ba2.replace(1000, 1024, ba1.mid(1000, 1024)); // For 33228 ms.
    //ba3 = ba1.left(1024); // For 45615 ms. <- ?!
    //ba3 = ba1.right(1024); // For 29640 ms.
    //ba3 = ba1.mid(1000, 1024); // For 29859 ms.

    //memcpy(ba2data+1000, ba1data+1000, 1024);       // For 7722 ms.
    qMemCopy(ba2data+1000, ba1data+1000, 1024);     // For 11981 ms.


    qDebug() << timer.elapsed();@

Log in to reply