Qt learning path (56): binary file read/write

Today, we start to enter another part of Qt: file read/write, that is, IO. File read/write is required in many applications. Qt provides IO abstraction through QIODevice, which has the ability to read and write bytes. Common IO read/write classes include the following:

QFlie	Access the local file system or embed Resources
QTemporaryFile	Create and access temporary files in the local file system
QBuffer	Read/write QByteArray
QProcess	Run external programs to process inter-process communication
QTcpSocket	TCP Network Data Transmission
QUdpSocket	Transmit UDP Packets
QSslSocket	Use SSL/TLS to transmit data

QProcess, QTcpSocket, QUdpSoctet, and QSslSocket are sequential access devices. Their data can only be accessed once, that is, you can only access the device from the first byte until the last byte. QFile, QTemporaryFile, and QBuffer are random access devices. You can access the device any number of times from any location, and use the QIODevice: seek () function to locate the file pointer. In terms of access methods, Qt provides two high-level abstractions: Using QDataStream for binary access and using QTextStream for text access. These classes can help us control byte sequence and text encoding, freeing programmers from this problem. QFile is very convenient for accessing independent files, whether in the file system or in the Application resource file. Qt also provides two classes, QDir and QFileInfo, for processing folder-related transactions and viewing file information. This time we will start with reading and writing binary files. The simplest way to access data in binary format is to instantiate a QFile object, open the file, and then use QDataStream for access. QDataStream provides a platform-independent method for accessing data formats, including standard C ++ types, such as int and double; multiple Qt types, such as QByteArray, QFont, QImage, QPixmap, QString and QVariant, and Qt container classes, such as QList <T> and QMap <K, T>. First look at the following code:

 
 

  
  
QImage image("philip.png");  
  
  
 
  
  
QMap<QString, QColor> map;  
  
  
map.insert("red", Qt::red);  
  
  
map.insert("green", Qt::green);  
  
  
map.insert("blue", Qt::blue);  
  
  
 
  
  
QFile file("facts.dat");  
  
  
if (!file.open(QIODevice::WriteOnly)) {  
  
  
    std::cerr << "Cannot open file for writing: " 
  
  
              << qPrintable(file.errorString()) << std::endl;  
  
  
    return;  
  
  
}  
  
  
 
  
  
QDataStream out(&file);  
  
  
out.setVersion(QDataStream::Qt_4_3);  
  
  
 
  
  
out << quint32(0x12345678) << image << map; 
 
 

Here, we first create a QImage object, a QMap <QString, QColor>, then use QFile to create a file named "facts. dat", and then open it in write-only mode. If it fails to be opened, return directly; otherwise, we will use the QFile pointer to create a QDataStream object and set the version. This will be explained in detail later, just like the cout of std, use the <operator to output the result. 0x12345678 becomes a "magic number", which is often used in binary file output. The binary format we define usually has such a "magic number" for marking the file format. For example, when writing 0x12345678 to a file, we first check whether the number is 0x12345678. If not, this is not a recognizable format, therefore, you do not need to read data. Generally, the binary format has such a magic number. For example, the magic number of the Java class file is 0 xCAFE BABE (a very Java name), which can be viewed using a binary viewer. The magic number is a 32-bit unsigned integer, so we use the quint32 macro to obtain a platform-independent 32-bit unsigned integer. In this Code, we use a qPrintable () Macro, which converts the QString object to const char *. Note that we are using the C ++ standard error output cerr, so this conversion is required. Of course, the QString: toStdString () function can also perform the same operation. The read process is very simple. It should be noted that the read process must correspond to the write process one by one, that is, the first magic number written to the quint32 type, the first read must also be in quint32 format, such

 
 

  
  
quint32 n;  
  
  
QImage image;  
  
  
QMap<QString, QColor> map;  
  
  
 
  
  
QFile file("facts.dat");  
  
  
if (!file.open(QIODevice::ReadOnly)) {  
  
  
    std::cerr << "Cannot open file for reading: " 
  
  
              << qPrintable(file.errorString()) << std::endl;  
  
  
    return;  
  
  
}  
  
  
 
  
  
QDataStream in(&file);  
  
  
in.setVersion(QDataStream::Qt_4_3);  
  
  
 
  
  
in >> n >> image >> map; 
 
 

Okay, I read the data. Please use it everywhere! What is the use of this version? For binary read/write, with the upgrade of Qt, the same content may have different read/write methods, for example, it may be changed from large-end writing to small-end writing, in this case, the content written in the old version of Qt cannot be correctly read, so you need to set a version number. For example, here we use QDataStream: Qt_4_3, Which means we use Qt 4.3 to write data. In fact, the current maximum version number is QDataStream: Qt_4_6. In this case, Qt versions earlier than MySQL 4.3 cannot read and write the file content correctly. So the question is: Isn't it possible to use the latest Qt to read and write this version in a hard-coded manner? One solution is to write not only a magic number, but also the version of the file. For example:

 
 

  
  
QFile file("file.xxx");  
  
  
file.open(QIODevice::WriteOnly);  
  
  
QDataStream out(&file);  
  
  
 
  
  
// Write a header with a "magic number" and a version  
  
  
out << (quint32)0xA0B0C0D0;  
  
  
out << (qint32)123;  
  
  
 
  
  
out.setVersion(QDataStream::Qt_4_0);  
  
  
 
  
  
// Write the data  
  
  
out << lots_of_interesting_data; 
 
 

The version number of this file. xxx file is 123. In our opinion, if the version number is 123, it can be read using Qt_4_0. Therefore, to read the code, you need to determine the following:

 
 

  
  
QFile file("file.xxx");  
  
  
 file.open(QIODevice::ReadOnly);  
  
  
 QDataStream in(&file);  
  
  
 
  
  
 // Read and check the header  
  
  
 quint32 magic;  
  
  
 in >> magic;  
  
  
 if (magic != 0xA0B0C0D0)  
  
  
     return XXX_BAD_FILE_FORMAT;  
  
  
 
  
  
 // Read the version  
  
  
 qint32 version;  
  
  
 in >> version;  
  
  
 if (version < 100)  
  
  
     return XXX_BAD_FILE_TOO_OLD;  
  
  
 if (version > 123)  
  
  
     return XXX_BAD_FILE_TOO_NEW;  
  
  
 
  
  
 if (version <= 110)  
  
  
     in.setVersion(QDataStream::Qt_3_2);  
  
  
 else 
  
  
     in.setVersion(QDataStream::Qt_4_0);  
  
  
 
  
  
 // Read the data  
  
  
 in >> lots_of_interesting_data;  
  
  
 if (version >= 120)  
  
  
     in >> data_new_in_XXX_version_1_2;  
  
  
 in >> other_interesting_data; 
 
 

In this way, we can process binary data read and write perfectly.

This article is from the "bean space" blog, please be sure to keep this source http://devbean.blog.51cto.com/448512/293892