c++ - 外部存储器上的 QDataStream？

Question

我想将 QVector 序列化为 char* 数组。我通过以下代码执行此操作:

QVector<int> in;
...
QByteArray bytes;
QDataStream stream(&bytes, QIODevice::WriteOnly);
stream << in;
std::copy(bytes.constData(), bytes.constData() + bytes.size(), out);

我保证 out 足够大。由于这段代码被调用得非常频繁，我想避免这种不必要的 std::copy 操作，并制作 QByteArray 或 QDataStream在 out 指向的预分配用户内存上工作。那可能吗？有什么好主意吗？

更新:QByteArray::fromRawData() 不符合需求，因为它不允许更改创建它的 char* 缓冲区，换句话说， QByteArray 在第一次修改此类创建的实例时执行深度复制。像他们说的那样。 这确保原始数据数组本身永远不会被 QByteArray 修改。

解决方案:@skyhisi提出的解决方案非常符合我的需求。完整代码如下。

1. SimpleBuffer.hpp

   #pragma once
   #include <QtCore/QIODevice>
   
   class SimpleBuffer : public QIODevice {
     Q_OBJECT
     Q_DISABLE_COPY(SimpleBuffer)
   
   public:
     SimpleBuffer(char* const begin, const char* const end) :
       _begin(begin),
       _end(end){}
   
     virtual bool atEnd() const {
       return _end == _begin;
     }
   
     virtual bool isSequential() const {
       return true;
     }
   
   protected:
     virtual qint64 readData(char*, qint64) {
       return -1;
     }
   
     virtual qint64 writeData(const char* const data, const qint64 maxSize) {
       const qint64 space = _end - _begin;
       const qint64 toWrite = qMin(maxSize, space);
       memcpy(_begin, data, size_t(toWrite));
       _begin += toWrite;
       return toWrite;
     }
   
   private:
     char* _begin;
     const char* const _end;
   };
   

2. main.cpp

   #include "SimpleBuffer.hpp"
   #include <QtCore/QVector>
   #include <QtCore/QDataStream>
   #include <QtCore/QByteArray>
   
   int main(int, char**) {
     QVector<int> src;
     src << 3 << 7 << 13 << 42 << 100500;
     const size_t dataSize = sizeof(quint32) + src.size() * sizeof(int);
     char* const data = new char[dataSize];
   
     // prepare stream and write out the src vector
     {
       SimpleBuffer simpleBuffer(data, data + dataSize);
       simpleBuffer.open(QIODevice::WriteOnly);
       QDataStream os(&simpleBuffer);
       os << src;
     }
   
     // read vector with QByteArray
     QVector<int> dst;
     {
       const QByteArray byteArray = QByteArray::fromRawData((char*)data, dataSize);
       QDataStream is(byteArray);
       is >> dst;
     }
     delete [] data;
   
     // check we've read exactly what we wrote
     Q_ASSERT(src == dst);
   
     return 0;
   }
   

Answer 1

我想你可能需要实现一个QIODevice，你可以很容易地制作一个非常简单的顺序设备。这是我快速拼凑的一个，我还没有检查它是否有效(随意让它工作并编辑帖子)。

class SimpleBuffer : public QIODevice
{
    Q_OBJECT
    public:
        SimpleBuffer(char* begin, char* end):mBegin(begin),mEnd(end){}

        virtual bool atEnd() const {return mEnd == mBegin; }

        virtual bool isSequential() const { return true; }

    protected:
        virtual qint64 readData(char*, qint64) { return -1; }

        virtual qint64 writeData(const char* data, qint64 maxSize)
        {
            const qint64 space = mEnd - mBegin;
            const qint64 toWrite = qMin(maxSize, space);
            memcpy(mBegin, data, size_t(toWrite));
            mBegin += toWrite;
            return toWrite;
        }

   private:
        char* mBegin;
        char* mEnd;

        Q_DISABLE_COPY(SimpleBuffer)
};