Qt 序列化操作

應用需求：

在網盤開發過程中有這樣一個需求，即對文件版本進行控制，即記錄文件版本的更替信息，這裏說的更替信息僅僅是記錄不同時刻的文件變化，即文件的增、刪、改、重命名等操作。在每個待監控的目錄下都會保存一份文件，記錄文件變化的增量信息，每次低版本到高版本升級的時候就可以通過消元合併操作快速地進行。關於文件版本控制的具體實現方案會在開發完善後列出，這裏僅僅指出它的保存方式，即將文件操作的實例對象序列化後保存在文件中。

序列化的實現：

這裏我們採用QDataStream來實現序列化，QT針對不同的實例化對象有不同的要求。這裏主要分兩類，即：QT中原生的數據類型，例如：QString、QMap、QHash等，這對這種原生數據類型的序列化，我們不需要做其它額外的操作，直接就可以序列化到文件中。還有一類特殊的就是我們自己定義的數據結構或類，這種方式利用QDataStream不能直接實現序列化，我們必須重載<<和>>操作符，只有重載完之後纔可以按我們的要求實現序列化。下面就舉例來說明一下，我們自定義的數據結構或類應該如何實現序列化：

自定義的類：LHTFileVersionItem，該類用來記錄某一個操作，它的定義爲：

#ifndef LHT_FILEVERSIONITEM_H
#define LHT_FILEVERSIONITEM_H

#include <QDataStream>

struct FileVersionItem
{
    QString               m_sFileAbsolutePath ;

    QString               m_sFileOrgName ;
    QString               m_sFileNowName ;

    int               m_sFileType ;

    QString               m_sFileMoveFromAbsolutePath ;
    QString               m_sFileMoveToAbsolutePath ;
};

class LHTFileVersionItem
{
public:
    LHTFileVersionItem();
    ~LHTFileVersionItem();

    void setVersion(int version);
    void setOp(int op);

    int  GetVersion();
    int  GetOp();
    FileVersionItem* GetFileVersionPointer();

    friend QDataStream &operator<<(QDataStream & , const LHTFileVersionItem &);
    friend QDataStream &operator>>(QDataStream & , LHTFileVersionItem &);

private:
    int                   m_iVersion;

    //!-1:delete   1:crate           2:change
    //!3:rename    4:move
    int                   m_iOp;
    FileVersionItem       *m_hFileVersionPointer ;
};

#endif // LHT_FILEVERSIONITEM_H

其中，friend QDataStream &operator << 和 friend QDataStream &operator >>就是聲明的對操作符的重載。注意：這裏我們使用了friend來聲明爲友元函數，這裏對friend關鍵字做些介紹：

何謂友元？爲什麼要使用友元？我們知道，採用類的機制後實現了數據的隱藏和封裝，類的數據成員一般定義爲私有成員，成員函數一般定義爲公有的，依此提供類與外界間的訪問接口。但是，有時需要定義一些函數，注意：這些函數並不是類的一部分（因此在cpp文件中實現該函數時，函數前不需要使用，類名::函數名的方式），但又需要頻繁地訪問類的私有數據成員，這是可以將這些函數定義爲友元函數。除了友元函數外還有友元類，兩者統稱爲友元。友元的作用是提高了程序的運行效率（即：減少了類型檢查和安全性檢查等，這些操作都需要時間開銷），但是它同時也破壞了類的封裝性和隱蔽性，使得非成員函數可以訪問類的私有成員。

其實，這裏理解友元關注friend就可以了，friend代指“朋友”、“關係友好”的意思，只有兩者（函數與類友好形成友元函數；類與類友好形成友元類）關係友好，我才允許它訪問我的私有成員。

自定義的類：LHTFileVersionItem的實現：

#include "lht_fileversionitem.h"

LHTFileVersionItem::LHTFileVersionItem()
{
    m_hFileVersionPointer = new FileVersionItem();
}

LHTFileVersionItem::~LHTFileVersionItem()
{
}

void LHTFileVersionItem::setVersion(int version)
{
    this->m_iVersion = version ;
}

void LHTFileVersionItem::setOp(int op)
{
    this->m_iOp = op ;
}

int LHTFileVersionItem::GetVersion()
{
    return this->m_iVersion ;
}

int LHTFileVersionItem::GetOp()
{
    return this->m_iOp ;
}

FileVersionItem* LHTFileVersionItem::GetFileVersionPointer()
{
    return this->m_hFileVersionPointer;
}

//! 重載操作符<<的實現
QDataStream &operator<<(QDataStream &output , const LHTFileVersionItem & item)
{
    output << item.m_iVersion << item.m_iOp << item.m_hFileVersionPointer->m_sFileAbsolutePath << \
              item.m_hFileVersionPointer->m_sFileMoveFromAbsolutePath << item.m_hFileVersionPointer->m_sFileMoveToAbsolutePath << \
              item.m_hFileVersionPointer->m_sFileNowName << item.m_hFileVersionPointer->m_sFileOrgName ;
    return output ;
}

//! 重載操作符>>的實現
QDataStream &operator>>(QDataStream & input, LHTFileVersionItem & item)
{
    input >> item.m_iVersion >> item.m_iOp >> item.m_hFileVersionPointer->m_sFileAbsolutePath >> \
             item.m_hFileVersionPointer->m_sFileMoveFromAbsolutePath >> item.m_hFileVersionPointer->m_sFileMoveToAbsolutePath >> \
             item.m_hFileVersionPointer->m_sFileNowName >> item.m_hFileVersionPointer->m_sFileOrgName ;
    return input ;
}

繼承自Object後會出現的問題：

如果我們自定義的類繼承自QObject，在使用時可能會出現這樣的編譯錯誤：error C2248 'QObject::QObject' : cannot access private member declared in class 'QObject'如下所示：

爲什麼加了繼承自QObject就會出現這種問題呢，肯定是QObject的問題，查看源碼中在private中有這樣一句：

private:
    Q_DISABLE_COPY(QObject)
    Q_PRIVATE_SLOT(d_func(), void _q_reregisterTimers(void *))

/*
   Some classes do not permit copies to be made of an object. These
   classes contains a private copy constructor and assignment
   operator to disable copying (the compiler gives an error message).
*/
#define Q_DISABLE_COPY(Class) \
    Class(const Class &); \
    Class &operator=(const Class &);

從上面的註釋和實現可以看出繼承自QObject後它不允許對象的賦值操作，即=，我查找我所有調用的函數裏面沒有看到直接賦值的操作啊，那爲什麼會出現這樣的問題呢？原因在於在函數調用時形參的傳遞也會被認爲是賦值操作。因此，出現這樣問題，直接將QObject的繼承去掉就可以，我們沒有使用到QObject獨特的特定。

局部變量使用對性能的影響以及進程的堆和棧：

由於在代碼中我使用了QMulitHash<QString , LHFilteVersionItem> tmp;這一局部變量來保存某一目錄下的文件，由於在寫測試代碼期間，我利用循環模擬了50萬的數據序列化後保存在文件中，在運行期間我發現讀取函數耗費很長的時間，而函數裏面最耗時的讀取操作也只花費了很短的時間，但是函數一直無法立即退出，在等待了大約30s後才能退出，相關代碼如下：

void LHTWORKFLOW::ReadAllDataFromFile(QMultiHash<QString, LHTFILEITEM> &m_hFileItemInfo)
{
    if (NULL == m_fFileInfoHandle)
    {
        OpenFile(m_sFileItemInfoAbsolutePath , 0);
    }

    m_fFileInfoHandle->seek(0);

    QDataStream input(m_fFileInfoHandle);

	QMultiHash<QString, LHTFILEITEM> final;
    while (!input.atEnd())
    {
        QMultiHash<QString, LHTFILEITEM> tmp ;
        input >> tmp ;
        final += tmp ;
    }

	m_hFileItemInfo = final ;
    CloseFile(m_fFileInfoHandle);
}

經過仔細分析和思考，發現問題就出在局部變量final上，由於是局部變量，因此當函數執行完畢後局部變量就要銷燬，由於是QMultiHash類型的變量，我們知道Hash相比數組來說它的一大好處是數據地址不連續，元素在內存控件中佔用的內存地址是不連續的，而數據量又大，因此在銷燬的過程中應該是逐步遍歷去釋放內存指針去了。如果是數組這種連續的數據結構的話，釋放會很快，只需要把該塊內存的標誌設爲無用它就又可以被系統回收利用了。這種情況還是我第一次碰到，感到很有意思，對我以後的代碼編寫也有一定的知道意義，於是我就查閱了進行相關堆和棧的相關內容。

以下內容的參考鏈接：http://blog.csdn.net/hairetz/article/details/4141043 ，爲了加深理解我這裏再列出一點吧。

1> 預備知識—程序的內存分配

一個由C++編譯的程序佔用的內存分爲一下幾個部分：

1) 棧區（stack）— 由編譯器自動分配釋放，存放函數的參數值，局部變量的值等。其操作方式類似於數據結構中的棧。

2) 堆區（heap）— 一般由程序員分配釋放，若程序員不釋放，程序結束時可能又操作系統回收。

3) 全局區（靜態區）(static) — 全局變量和靜態變量的存儲是放在一起的，初始化的全局變量和靜態變量在一塊區域，未初始化的全局變量和未初始化的靜態變量在相鄰的另一塊區域，程序結束和由系統釋放。

4) 文字常量區— 常量字符串就是放在這裏的。程序結束後由系統釋放。

5) 程序代碼區— 存放函數體的二進制代碼。

2> 堆和棧的對比

1) 申請方式

棧（stack）由系統自動分配。例如，聲明在函數中的一個局部變量 int b ; 系統自動在棧中爲b開闢空間。

堆（heap）需要程序員自己申請，並指明大小，在c中malloc函數如：p1 = (char *)malloc(10) ; 在C++中用new運算符如：p2 = new char[10];

但注意：p1、p2本身是在棧中的，只是通過malloc和new分配的空間是在堆中的。

3> 申請後的系統響應

棧（stack）：只要棧的剩餘空間大於所申請的空間，系統將爲程序提供內存，否則將報異常提示棧溢出。

堆（heap）：首先應該知道操作系統有一個記錄空閒內存地址的鏈表，當系統收到程序的申請時，會遍歷該鏈表，尋找第一個空間大於所申請空間的堆節點，然後將該節點從空閒節點鏈表中刪除，並將該節點的空間分配給程序，另外，對於大多數系統，會在這塊內存空間中的首地址處記錄本次分配的大小，這樣代碼中的delete語句才能正確的釋放本內存空間。另外，由於找到堆節點的大小不一定正好等於申請的大小，系統會自動的將多餘的那部分重新放入空閒鏈表中。

4> 申請大小的限制

棧：在Windows下，棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂和棧的最大容量是系統預先規定好的，在windows下，棧的大小是2M，如果申請的空間超過棧的剩餘空間時，將提示溢出，因此，能從棧獲得的空間較小。

堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是由於系統使用鏈表連存儲的空閒內存地址的，自然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。由此可見，堆獲得的空間比較靈活，也比較大。

5> 申請效率的比較

棧：由系統自動分配，速度較快。但程序員是無法控制的。

堆：是由new分配的內存，最好的方式是用VirtualAlloc分配虛擬內存，它既不是在堆也不是在棧，而是直接在進程的地址空間中保留一塊內存，雖然用起來最不方便，但是速度快也最靈活。

6> 堆和棧中的存儲內容

棧：在函數調用時，第一個進棧的是主函數中後的下一條指令（函數調用語句的下一條可執行語句）的地址，然後是函數的各個參數，在大多數的C編譯器中，參數是由右向左入棧的，然後是函數中的局部變量。注意：靜態變量是不入棧的。當本次函數調用結束後，局部變量先出棧，然後是參數，最後棧頂指針指向最開始存的地址，也就是主函數中的下一條指定，程序由該點繼續運行。

堆：一般是在堆的頭部用一個字節存放堆的大小。堆中的具體內容由程序員安排。

總結：

通過這塊內容的分析，對影響程序執行性能的幾個方面有了更清除的瞭解，對進程的堆棧也有了更深入的瞭解，感覺自己開始慢慢關注那些實質性的東西，這點我感覺是很好的，加油，對每個不懂的問題都要認真總結。

Qt 序列化操作

Qt 序列化操作

QT跨目錄編譯及多工程集成

Qt 如何正確的讓程序睡眠

.pro、.pri、.prf、.prl文件介紹和使用

Qt 信號槽機制與事件機制四提升篇

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結