如果要 typedef，搞出來的都是些很惡心的名字，自己看了也生氣，還是不搞好了，就 size_t 和 int 玩到底吧。

把 Array 的接口又改得一塌糊涂了，重新貼一下：

namespace xl
{
    template <typename ValueType>
    class Array
    {
    public:
        Array(size_t nSize = 0);
        Array(size_t nSize, const ValueType &tValue);
        Array(const Array<ValueType> &that);
        ~Array();

    public:
        class Iterator
        {
        public:
            Iterator();
            Iterator(ValueType *pValue);
            Iterator(ValueType *pValue, ValueType *pStart, ValueType *pEof);
            Iterator(const Iterator &that);

        private:
            ValueType *m_pStart;
            ValueType *m_pEof;
            ValueType *m_pCurrent;

        public:
            ValueType &operator * ();
            ValueType *operator -> ();

        public:
            Iterator &operator = (const Iterator &that);
            bool operator == (const Iterator &that) const;
            bool operator != (const Iterator &that) const;

        public:
            Iterator &operator ++ ();
            Iterator operator ++ (int);
            Iterator &operator -- ();
            Iterator operator -- (int);

        public:
            Iterator operator +(int nDistance) const;
            Iterator operator -(int nDistance) const;
            Iterator &operator +=(int nDistance);
            Iterator &operator -=(int nDistance);
        };

        class ReverseIterator : public Iterator
        {
        public:
            ReverseIterator &operator ++ ();
            ReverseIterator operator ++ (int);
            ReverseIterator &operator -- ();
            ReverseIterator operator -- (int);
        };

    public:
        Iterator Begin() const;
        Iterator End() const;
        ReverseIterator RBegin() const;
        ReverseIterator REnd() const;


    public:
        Array<ValueType> &operator=(const Array<ValueType> &that);
        bool operator==(const Array<ValueType> &that) const;
        bool operator!=(const Array<ValueType> &that) const;

    public:
        ValueType &operator[](size_t nIndex);
        const ValueType &operator[](size_t nIndex) const;

    public:
        bool Empty();
        size_t Size() const;
        void SetSize(size_t nSize);

    public:
        void Insert(const Iterator &itBeforeWhich, const ValueType &tValue);
        void Insert(const ReverseIterator &itBeforeWhich, const ValueType &tValue);
        void PushFront(const ValueType &tValue);
        void PushBack(const ValueType &tValue);
        template <typename IteratorType>
        void Insert(const Iterator &itBeforeWhich, const IteratorType &itFirstToInsert, const IteratorType &itAfterLastToInsert);
        template <typename IteratorType>
        void Insert(const ReverseIterator &itBeforeWhich, const IteratorType &itFirstToInsert, const IteratorType &itAfterLastToInsert);
        Iterator Delete(const Iterator &itWhich);
        ReverseIterator Delete(const ReverseIterator &itWhich);
        void PopFront();
        void PopBack();
        Iterator Delete(const Iterator &itFirstToInsert, const Iterator &itAfterLastToDelete);
        Iterator Delete(const ReverseIterator &itFirstToInsert, const ReverseIterator &itAfterLastToDelete);
        void Clear();
        void SetValue(const Iterator &itWhich, const ValueType &tValue);
        void SetValue(const ReverseIterator &itWhich, const ValueType &tValue);
        void SetValue(const Iterator &itFirstToSet, const Iterator &itAfterLastToSet, const ValueType &tValue);
        void SetValue(const ReverseIterator &itFirstToSet, const ReverseIterator &itAfterLastToSet, const ValueType &tValue);

    private:
        ValueType *m_pData;
        size_t m_nSize;
        size_t m_nStart;
        size_t m_nEof;

    private:
        void Release();
        size_t GetWellSize(size_t nSize) const;
        void MoveData(size_t nIndex, size_t nCount, int nDistance);
        void CopyData(size_t nIndex, size_t nCount, ValueType *pNewMem) const;

    };
}

主要的考慮，還是想實現“跨容器的 iterator”（抱歉，我還是覺得這么稱呼挺符合我的預期的）。只是，在沒有語言層面的 concepts 支持的情況下，如何顯式地讓用戶知道模板參數要符合哪些條件呢？

在這里再次感謝一下 OwnWaterloo 同學，上篇評論里的東西我會繼續慢慢琢磨的。^_^

     摘要: 打算先把基礎的東西組織起來，作為一個“大庫”（見上一篇《小庫還是大庫？》）。然后填加各個實用功能，作為一個個小庫或者大庫，過段時間再想辦法組織整理了。 首先是類型系統，我想來想去，覺得還是必須整理一下，尤其是 unsigned XXX 寫起來太難看了，可是這又帶來了問題——WinDef.h 把好聽的名字都占去了。然后，我只能在自己的命名空間下這樣來一番了： xlDef.h #ifndef ...  閱讀全文

我不知道這里有多少朋友是積累了自己的一套庫的。

嗯……說明白點，比如想讀寫文件了，操作系統 API 的那堆參數我記不住，也用不著那么靈活，于是自己寫一個自己記得住的，下次碰到同樣情況繼續用，并不斷完善。哪天想讀寫注冊表了，想讀寫 INI 文件了，想讀寫 XML 文件了，想用個動態數組了，想要個鏈表、樹了，可能都會形成自己的一套東西。這套東西可能是基于已有的第三方庫，也可能是純粹自己一點一滴寫起來的。好了，我想現在我大概表達得夠明白了，這就是我說的“庫”，這個庫可能不是非常完備，但起碼是自己積累的，有著（起碼對自己來說）友好接口的東東。

可能有朋友會說，你要自己的動態數組、鏈表干嗎？STL 很好啊！你要讀寫文件的干嗎？CFile 哪里不好？你要讀 INI？不是有 API 嗎？……諸如此類。如果有朋友持這樣的觀點，我想我們是不同的一類人。如果您只是能完成某項任務就好，那么確實，不需要這些玩意兒。但是，如果哪一天這種普通的工作做得麻木了，來思考一下另一個層面的事情，您也許會覺得這些也是比較有意思的事。廢話到此。

那么，不知道這些庫，是以什么形式存在的呢？稍微極端開來講，可能有兩個做法——

第一種做法。我每寫成一個功能模塊，都是一個（或幾個）.h、一個（或幾個）.cpp，它們是自我獨立的，不依賴于任何別的東西（或者不依賴標準庫以外的東西、不依賴于操作系統 API 以外的東西）——總之是不依賴于當前編譯系統以外的東西。以后需要使用，就把那幾個文件拷到當前項目來使用。然后一個個這樣的互不依賴的功能模塊構成了我現在所擁有的庫。

第二種做法呢，就是我把這個庫作系統的規劃，劃分為很多小的功能模塊，這些功能模塊可能會彼此依賴，當庫龐大以后，甚至連你自己都該不太清楚誰依賴誰了。要使用這個庫的功能，就必須把整個庫拿進來。到最后，我將這整套東西編譯為一個 .lib，這個 .lib 的源程序會一直維護下去。但使用的時候，我就拿編譯好的 .lib 來用。

前一種做法就是標題里所說的小庫，后一種做法我稱之為大庫。我的問題是，作為個人的積累，小庫好還是大庫好？如果可能，我是比較喜歡小庫的。但是，經常會有這樣的問題，各個功能模塊中可能會涉及同一個基礎功能，而這個基礎功能我已經做過了的，到底是用還是不用？如果用，“互不依賴”就會被打破，最終會發展成一個凌亂的大庫；如果不用，我必須把代碼抄一遍，那么這兩份完全一樣的代碼在以后同步更新就比較麻煩了。再說大庫，一個規劃的很好的大庫也是不錯。但是前期積累的時候，往往沒法規劃；就算等到有一定的積累了以后再來積累，也會在模塊組織上猶豫不決：我到底要不要來一個統一的 typedef 作為我的類型系統？當我實現了 MyVector，MyString 以后，我的后續代碼勢必都會使用它們，那么與別人之間的代碼交流就成了問題了。

我最近一直困惑于這個問題。而我本人對此的理解也就如上文所述。希望有朋友指教、賜教。謝謝~~！

前幾天公司里一個項目要做 MUI 支持，于是要生成一堆 XXX.dll.mui 的文件。如果這些 MUI DLL 的工程手動去建立、維護的話，那就太!@#@!#!了。當時是另外一個同事去做這方面的工作的，后來他給了個工具，按照它定義的簡單格式來書寫多語言字符串，這個工具會從一個已經設定好的 DLL 項目出發，更改 RC 文件里的字符串，然后調用 VS 的 IDE 來生成 DLL。再然后調用 MUIRCT.exe 來生成 MUI 文件。

這可以節省很多時間。但是，由于是調用 VS IDE 來編譯的，一個帶有近百個 Project 的 Solution 編譯起來并不快，需要一到兩分鐘。這讓我有了另辟蹊徑的念頭。

何不自己來“編譯”生成 DLL 呢？

不錯，后來我就往這個方向琢磨了。之前曾寫過一個修改 PE 文件版本號的小工具，所以現在對于 PE 的資源格式有點并不那么恐懼了。但是，往細處做下去，問題就來了。現在網上的關于 PE 格式的文章，對 NTHeader 解釋得很詳細，而資源段往往只講到資源目錄、資源項，具體各項的存儲結構卻沒有詳細說明了。

這里，關于 PE 頭等就不多說了，請參考網上的文章，特別是 http://bbs.pediy.com/showthread.php?threadid=21932。本文將著眼于資源段。

首先來看一下幾個數據結構（這些內容好多文章也有提及）：

typedef struct _IMAGE_RESOURCE_DIRECTORY {
    DWORD   Characteristics;
    DWORD   TimeDateStamp;
    WORD    MajorVersion;
    WORD    MinorVersion;
    WORD    NumberOfNamedEntries;
    WORD    NumberOfIdEntries;
} IMAGE_RESOURCE_DIRECTORY, *PIMAGE_RESOURCE_DIRECTORY;

這是資源目錄，共 16 字節，其中最后兩個 WORD 加起來是緊跟在后面的子項的數目。

typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
    union {
        struct {
            DWORD NameOffset:31;
            DWORD NameIsString:1;
        };
        DWORD   Name;
        WORD    Id;
    };
    union {
        DWORD   OffsetToData;
        struct {
            DWORD   OffsetToDirectory:31;
            DWORD   DataIsDirectory:1;
        };
    };
} IMAGE_RESOURCE_DIRECTORY_ENTRY, *PIMAGE_RESOURCE_DIRECTORY_ENTRY;

這個就是緊跟在目錄后面的資源目錄項，共 8 字節。其中第一個成員為數據成員，最高位 1 表示數據是字符串，剩下 31 位是字符串的偏移；否則就是數值。第二個成員最高位為 1 表示下一層仍然是目錄，后 31 位指向另一個 IMAGE_RESOURCE_DIRECTORY 結構；否則整個成員指向一個 IMAGE_RESOURCE_DATA_ENTRY 結構（這個馬上會講到）。需要注意的是，這里的兩個 Offset 都表示從資源段開頭到目標位置的偏移。

最后來看 IMAGE_RESOURCE_DATA_ENTRY：

typedef struct _IMAGE_RESOURCE_DATA_ENTRY {
    DWORD   OffsetToData;
    DWORD   Size;
    DWORD   CodePage;
    DWORD   Reserved;
} IMAGE_RESOURCE_DATA_ENTRY, *PIMAGE_RESOURCE_DATA_ENTRY;

這個結構是資源數據項，也就是資源樹的葉子，共 16 字節。其中第一個成員 OffsetToData 指向具體的數據，這個偏移是個 RVA，跟前面兩個不一樣。Size 表示具體數據的總字節數。后兩個成員可以為 0，CodePage 不建議使用。

PE 文件中的資源就是通過這三個結構表示的，它們都在 WinNT.h 中定義。通常會有 3 層結構，第一層表示資源類型，第二層表示 ID，第三層標識語言。

以上所說的是我能查到的資料里能夠提到的最大程度的內容了。但是具體的數據如何存儲，卻幾乎沒有文章提及。于是，花了一兩天時間來慢慢的看、加上試驗，我認為我對字符串資源的格式基本清楚了。（下面內容是我自己分析得出，其正確性我并不保證）。

我們先來看一個具體的例子。這是一個資源 DLL，用 Resource Hacker 查看如圖：

 

其資源段數據如下：

我用桔色框起來的是資源目錄，用粉色框起來的是資源目錄項，用淺綠色框起來的是資源數據項。

先看第一行，這是第一層目錄，最后兩個 WORD 是 0x0000 和 0x0001，表示后面“命名”的目錄項有 0 個，使用 ID 的目錄項有 1 個。第二行開頭的 8 字節就是這個目錄項，DWORD 0x00000006 表示資源類型是 6，也就是字串表，后面的地址是 0x80000018，最高位為 1，表示指向的仍然是一個目錄，其偏移是 0x00000018，也就是 0218h 處。

0218h 處這個資源目錄是第二層了。最后仍然是 0 和 1，于是我們來看 0228h 處的目錄項。第一個 DWORD 是 1，這個跟 ID 有關，稍候討論。他的第二個 DWORD 是 0x80000030，仍然指向目錄。

0230 處的目錄是第三層目錄。注意到最后是 0 和 2，下面將有連續兩個目錄項。第一個目錄項值為 0x00000409（1033，英語(美國)），偏移地址 0x00000050，最高位 0，表示指向的是數據項，而不是目錄了。第二個目錄項值為 0x00000804（2052，中文(中國)），偏移地址 0x0000009C。

這三層結構和 Resource Hacker 中顯示的是一一對應的。

我們先來看英語的那個數據項，OffsetToData 是 0x00001060（RVA），Size 是 0x0000003C。這個 DLL 文件的資源段的 VirtualAddress 是 1000h，1060h-1000h+200h = 260h，我們來看 260h 處（其實就是緊接著的地方）。我第一次看這段數據的時候也很奇怪，為什么前面空了 2 個字節，后面有多出好多字節。于是我改它的 ID，試了好些次，終于找到規律了。資源目錄第二層的 ID（下文稱 ResID）和最終的字符串 ID（下文稱 StrID）有這么一個對應關系：ResID = StrID / 16 + 1。StrID 0 到 15 所對應的 ResID 都是 1， StrID 16 到 31 對應 ResID 2，……。反過來說，資源目錄中的 ResID 不能完全表達 StrID 的信息。所以，在 260h 開始的 3Ch 個字節的數據塊里，其實要存儲 16 個字符串，其 StrID 分別是 0，1，2，……，15。這 16 個字符串是連續存儲的，結構是：字符串長度（WORD）+字符串內容（不含結束符 0）。那些空位就由一個 WORD 0 來填充（也可理解為長度為 0 的字符串）。我在圖中用紅褐色的豎線劃出了這 16 個字符串的界限。后面那個中文的也是如此，就不重復說了。

到現在為止，對于字串表的結構，應該說差不多清楚了。于是拿程序去生成似乎不是難事了，不過要注意的是，目錄項必須緊跟在目錄后面，目錄項指向的位置可以隨意。

事實上上面這個 DLL 是我用程序生成的。我現在做到了從內部數據結構到資源 DLL 這個過程的實現。如果這也可以被稱為“編譯”的話，現在是實現了后端。至于前端，我還沒想好原始資源格式。要想讓這個工具有點用處，原始資源格式必須要：1、足夠簡單（至少比 RC 文件簡單），并且維護方便；2、足夠存儲多語言字符串。這方面我希望大家能給我一些建議。

當然，本文的主要內容還是討論字串表的格式，這個已經講完了，所以，over~ bow~

開篇語：這是在這里寫的第一篇日志。關于來到這里，主要源于前兩天在這里看到一個牛人（vczh）的文章，花了近兩天斷斷續續拜讀了其文章。他的文章我不是全部能看懂，事實上只看懂了一小部分。還看到一些評論的朋友，也都很牛。因此想到這里來更好的與牛人們交流。如此而已。我原先的博客在 CSDN（http://blog.csdn.net/cnStreamlet/），由于一直以來都比較浮躁，也沒寫什么有用的東西。現在想想，人家是 05 級，我也是 05 級，人家已經這么牛了，我卻還在金字塔的底層徘徊。人生短短幾個秋，年輕的時候是個學習的黃金時間，浪費了豈不太可惜？總之呢，不管能不能靜下心來，現在開始努力靜下心來，多學點技術，即便成不了牛人，至少可以多些茶余飯后的談資。

==========華麗的分割線==========

好了，言歸正傳。今年 3 月份，也就是上班的第一個月，那時候我還算比較淡定的，經常研究些玩意兒。那時寫了個很輕量級的智能指針。現在不妨拿出來復習一下，如果有朋友路過，歡迎指教。

我所理解的“智能指針”，就是達到 new 了之后不用 delete 的效果。利用棧變量在作用域結束后會自動釋放（對象自動析構）的機制，可以達到這個效果。設想有一個類，它以一個現有指針為參數進行構造，這個析夠的時候去 delete 這個指針，就可以了。然后問題來了，在這種情形下，這個類本身充當了指針這個角色，那么難免要被復制來復制去，這個類中的原始指針也要被復制，那么，顯然析構函數里不能簡單地 delete 了。這時候，比較流行的做法之一是使用引用計數，當某個對象被復制一次，計數加 1；被析構一次，計數減 1。當且僅當計數為 0 的時候才執行 delete。現在，這個類的雛形大概是：

template <typename T>
class QIPtr
{
public:
    QIPtr(T *pData);
    ~QIPtr();
private:
    T *m_pData;
    size_t m_cRef; // TBD
private:
    void AddRef();
    void Release();
};


我現在很隨意地放了一個 size_t m_cRef，但是細想一下這樣是不行的。假設有 QIPtr p1(new int);，又有 QIPtr p2 = p1（當然，拷貝構造函數以及賦值函數現在還沒實現，但這不妨礙我們想象他們的功能），p1 和 p2 里的 m_pData 共享一塊內存，而 m_cRef 卻是獨立的，也就是說，p1 的 Release() 操作將無法影響到 p2。為了解決這個問題，可以將引用計數也定為指針 size_t *m_pcRef，當一個對象被使用原始指針構造的時候，同時給 m_pcRef new 一個出來；如果是 QIPtr 對象之間拷貝拷貝去，則將他們的 m_pcRef 也同步拷貝，并且讓 *m_pcRef 自增即可。

當時我就做到這種程度（現在還是）。不過留有一個問題，這個智能指針不是線程安全的，原因在于 AddRef() 和 Release() 期間沒有加鎖。

代碼比較短，就 200 行左右，如下：

/*******************************************************************************

    Copyright (C) Streamlet. All rights reserved.

    File Name:   xlQIPtr.h
    Author:      Streamlet
    Create Time: 2009-03-22
    Description: Smart pointer

    Version history:
        2009-03-22 Created by Streamlet.
        2009-03-27 Released first version.(1.0.0.1)


*******************************************************************************/

#ifndef __XLQIPTR_H_B0788703_ABD1_457D_8FEC_E527581FD9EF_INCLUDED__
#define __XLQIPTR_H_B0788703_ABD1_457D_8FEC_E527581FD9EF_INCLUDED__


namespace xl
{

#ifndef NULL
#define NULL 0
#endif

    /// @brief Smart Pointer.
    template <typename T>
    class QIPtr
    {
    public:
        /**
         * @brief Default constructor.
         */
        QIPtr();

        /**
         * @brief Constructor. Must give an heap address. Sample use: QIPtr<int> p(new int);.
         * @param pData [in] A heap address, usually returned by operator new.
         * @remark operator delete must not be called, if using QIPtr.
         */
        QIPtr(T *pData);

        /**
         * @brief Copy construction.
         * @param that [in] The pointer to be copied.
         */
        QIPtr(const QIPtr<T> &that);

        /**
         * @brief Destroyer. Inside this function, the heap address will be released if there is no more references.
         */
        ~QIPtr();
    public:

        /**
         * @brief Operator *, use it as usual.
         * @return return a reference of T-typed object.
         */
        T &operator*() const;

        /**
         * @brief Operator ->, use it as usual.
         * @return return the address of the object.
         */
        T *operator->() const;

        /**
         * @brief Copy operator, use it as usual.
         * @param that [in] The pointer to be copied.
         * @return Reference of this object
         */
        QIPtr<T> &operator=(const QIPtr<T> &that);

        /**
         * @brief Compare operator, use it as usual.
         * @param that [in] The pointer to be compared.
         * @return Return true if the two points equals, return false otherwise.
         */
        bool operator==(const QIPtr<T> &that) const;

        /**
         * @brief Compare operator, use it as usual.
         * @param that [in] The pointer to be compared.
         * @return Return true if the two points do not equals, return false otherwise.
         */
        bool operator!=(const QIPtr<T> &that) const;

    private:
        void AddRef();
        void Release();

    private:
        T *m_pData;
        size_t *m_pcRefs;
    };

    template <typename T>
    inline void QIPtr<T>::AddRef()
    {
        if (this->m_pcRefs == NULL)
        {
            this->m_pcRefs = new size_t;
            *this->m_pcRefs = 0;
        }

        ++*this->m_pcRefs;
    }

    template <typename T>
    inline void QIPtr<T>::Release()
    {
        if (this->m_pcRefs == NULL)
        {
            return;
        }

        if (--*this->m_pcRefs > 0)
        {
            return;
        }
        
        delete this->m_pcRefs;

        //if (this->m_pData == NULL)
        //{
        //    return;
        //}

        delete this->m_pData;
    }


    template <typename T>
    inline QIPtr<T>::QIPtr() : m_pData(NULL), m_pcRefs(NULL)
    {
    }

    template <typename T>
    inline QIPtr<T>::QIPtr(T *pData) : m_pData(NULL), m_pcRefs(NULL)
    {
        this->m_pData = pData;
        this->AddRef();
    }

    template <typename T>
    inline QIPtr<T>::QIPtr(const QIPtr<T> &that) : m_pData(NULL), m_pcRefs(NULL)
    {
        this->m_pData = that.m_pData;
        this->m_pcRefs = that.m_pcRefs;
        this->AddRef();
    }

    template <typename T>
    inline QIPtr<T>::~QIPtr()
    {
        this->Release();
    }

    template <typename T>
    inline T &QIPtr<T>::operator*() const
    {
        return *this->m_pData;
    }

    template <typename T>
    inline T *QIPtr<T>::operator->() const
    {
        return this->m_pData;
    }

    template <typename T>
    inline QIPtr<T> &QIPtr<T>::operator=(const QIPtr<T> &that)
    {
        //if (this == &that)
        //{
        //    return *this;
        //}

        if (this->m_pData == that.m_pData)
        {
            return *this;
        }

        this->Release();

        this->m_pData = that.m_pData;
        this->m_pcRefs = that.m_pcRefs;
        this->AddRef();    

        return *this;
    }

    template <typename T>
    inline bool QIPtr<T>::operator==(const QIPtr<T> &that) const
    {
        return this->m_pData == that.m_pData;
    }

    template <typename T>
    inline bool QIPtr<T>::operator!=(const QIPtr<T> &that) const
    {
        return this->m_pData != that.m_pData;
    }


} // namespace xl

#endif // #ifndef __XLQIPTR_H_B0788703_ABD1_457D_8FEC_E527581FD9EF_INCLUDED__

寫了這么粗淺的文字，希望大家不要笑話。請多指教。

posted @ 2009-09-23 08:07 溪流 閱讀(572) | 評論 (4) | 編輯 收藏

僅列出標題

共18頁: First 10 11 12 13 14 15 16 17 18