• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            huaxiazhihuo

             

            輕量級共享對象的靈巧指針的實現

                毫無疑問,shared_ptr的功能不可謂不強大,設計不可謂不精巧,它的抽象級別不是一般的高,不僅要管理一般的C++內存資源,更染指其他的非C++資源,比如文件、比如連接、……,只要給它一個支點(釋放資源的函數),不僅如此,還能頑強地生存于各種惡劣的環境,好比多線程、引用循環。當然,代價是有的,它背地里做了很多不為人知的勾當,表面上僅僅一行的帶有構造函數shared_ptr的定義代碼,編譯器卻要很無奈地生成一個莫明其妙的多態模板類(_Ref_count_base的繼承類,帶有虛函數表,意味著不能內聯,用以在恰當的時機,釋放資源),更別提要多了一堆指令,當然,在當今硬件性能蓬勃發展的美好時代,這點代價根本就不算什么,比之于那些什么所謂的虛擬機,甚至可以忽略不計。但是,總是有那么一批老古董,總會強迫假想自己寫的程序會運行于各種資源非常苛刻的環境下,內心就是沒法原諒shared_ptr所帶來的極細微的損失。好比區區在下,每一次一用到shared_ptr,心里的那種負罪感啊,又多了幾條廢指令,又浪費多了十幾個的堆字節,是否將生成內存碎片啊。終于有一刻頂不住了啦,去你媽的shared_ptr,老子不過想讓你老老實實的代理內存資源,本本分分地做好你的分內之事,不勞你費心照顧其他的系統資源對象,那些場合本座自然有更好的解決方式。于是,制造輪子的悲劇又再次誕生了,雖然,他們一直在內心深處抵制新輪子的愚蠢行為,但是,……,只能說,知我者謂我心憂,不知我者謂我何求。
                每次想到shared_ptr要new一個_Ref_count_base的對象來管理計數,有人就恨得牙根發癢,巴不得把_Ref_count_base的數據成員搬過來,放之于那個要管理的對象的身上,以減少一小塊內存。假如,客戶傳到shared_ptr構造函數的指針,此指針所指的內存,能再多幾個字節(一個字節也行,最大值255,已足矣),以供我等存放一個long型的計數器,那就好辦了。白癡也知道,這是不可能的事情。除非,此對象由shared_ptr來構造,那么還有辦法再放多點額外內存進去。此話怎講?大家都知道,C++中, new一個對象時,即意味著兩步操作:1、分配一塊內存;2、在此塊內存上執行對象的構造函數。如果第1步的分配內存,能作多點手腳,比如說,分配一塊比對象本身所占空間還要大的內存,那么我們的shared_ptr就可以把計數器放進對象之中了,也無須再new一個新的_Ref_count_base對象來管理計數器了。兩塊內存,合二為一,雙劍合璧,妙哉妙哉。但,這如何做到呢?
                以下,是一個類從簡單到復雜的物種進化歷程。C++中,只要是通用類,即使再簡單的需求,要寫得可以被普遍承認,可以高高興興地到處使用,都絕非易事。而且,更悲劇的是,辛辛苦苦,嘔心瀝血造出來的輪子,還很有可能一問世就直接被槍斃,就算能茍且活下來,也不會有車愿意組裝這一個廢輪子。
                廢話不說,書接上文,很明顯,對象的new操作應該由我們的shared_ptr來掌控。任由用戶來new,就太遲了,對象的內存塊已經確定下來了,沒文章可做啦。換句話說,shared_ptr必須模擬標準的new的兩在操作分配內存和調用構造函數。由此可知,以下所探討的shared_ptr運用場合也很有限,只適合于那些能看到構造函數并且知道其大小的C++類,所以,請大伙兒不要抱怨。唯其需求簡單明確,所以才能高效。
            首先,用一結構體__SharedObject來包含計數器和對象,如下所示:
            struct __SharedObject
            {
                
            void* Object()    // 返回對象的地址,由于不知對象的類型,所以只能是void*,表示內存地址
                { return this+1; }
               
            long Incref() { return InterlockedIncrement(&m_nRef); }
                
            long Decref() { return InterlockedDecrement(&m_nRef); }
               
            long m_nRef;
            };
                是否很簡陋,本座沒法也不想把它整得更加好看了。
                我們的shared_ptr,就暫時叫TShared_Ptr好了,其包含的數據成員,暫時很簡單。就只有一個__SharedObject的指針而已,后面由于多繼承多態的原因,將被迫多增加一個指針。
                好了,先看看TShared_Ptr的使用之道,此乃class template。由于共享對象由TShared_Ptr所造,所以,在其誕生之前,首先勢必定義一TShared_Ptr變量,好比,TShared_Ptr<int> pInt;考慮TShared_Ptr的構造函數,如果在里面就急急忙忙給共享對象分配內存,將沒法表達空指針這個概念,所以它的無參構造函數只是簡單地將m_pShared置為NULL。然后,TShared_Ptr必須提供分配內存并執行構造函數的操作,叫Construct吧;然后,析構函數也絕不含糊,執行對象的析構函數并釋放內存。于是,TShared_Ptr的基本代碼就出爐了。
            template<typename _Ty>
            class TShared_Ptr
            {
            public:
                TShared_Ptr() {m_pShared 
            = NULL; }
                TShared_Ptr(
            const TShared_Ptr& _Other)
                {    
                    
            if (m_pShared != NULL)
                    {
                        m_pShared 
            = const_cast<__SharedObject*>(_Other.m_pShared);
                        m_pShared
            ->Incref();
                    }
                    
            else
                        m_pShared 
            = NULL;
                }

                
            ~TShared_Ptr()
                {
                    
            if (m_pShared != NULL)
                    {
                        
            if (m_pShared->Decref() <= 0)
                        {
                            
            if (m_pShared->m_nRef == 0)
                                DestroyPtr(
            get());
                            free(m_pShared);
                        }
                    }
                }
                _Ty
            & operator*() const _THROW0() { return *get(); }
                _Ty 
            *operator->() const _THROW0(){return (get());}

                
            void Construct()
                {
                    ::
            new (m_pShared->Object()) _Ty();    // 調用構造函數
                    m_pShared->Incref();    // 構造函數拋出異常,這一行將不執行
                }
                void alloc()    // 假設malloc總能成功
                {
                    m_pShared 
            = static_cast<__SharedObject*>(malloc(sizeof(_Ty)+sizeof(__SharedObject)));
                    m_pShared
            ->m_nRef = 0;
                }

                _Ty 
            *get() const _THROW0() {   return (_Ty*)(m_pShared->Object());}
                __SharedObject
            * m_pShared;
            };

            可以寫代碼測試了,
                TShared_Ptr<int> pInt;
                pInt.Construct();
                (*pInt)++;
                TShared_Ptr<int> pInt1 = pInt;
                (*pInt1)++;
                咦,假如共享對象的構造函數帶有參數,咋辦呢?不要緊,重載多幾個Construct就行了,全部都是template 成員函數。由于要實現參數的完美轉發,又沒有C++2011的move之助,我還在堅持C++98ISO,要寫一大打呢,先示例幾個,很痛苦,或者,可通過宏來讓內心好受一點。
                template<typename T1>void Construct(const T1& t1);
                template<typename T1>void Construct(T1& t1);
                template<typename T1, typename T2>void Construct(const T1& t1, const T1& t2);
                template<typename T1, typename T2>void Construct(const T1& t1, T1& t2);
                template<typename T1, typename T2>void Construct(T1& t1, const T1& t2);
                template<typename T1, typename T2>void Construct(T1& t1, T1& t2);

                接下來就很清晰了,將shared_ptr的各種構造、賦值函數改寫一遍就是了。然后,就可以高高興興地測試使用了。以上,是最理想環境下TShared_Ptr的很簡單的實現,其操作接口多么的確簡明扼要。
                開始,考慮各種變態環境,其實也不變態,完全很正當的需求。各種也不多,就兩個而已:1、構造函數拋出異常,這個不是問題,由于TShared_Ptr的構造函數不拋出異常,其析構函數將被執行,檢查到計數器為0,所以不調用共享對象的析構函數;
                2、多繼承,這個有點頭痛了。先看看代碼,假設 class D : public B1, public B2,B1、B2都非空類;然后,B2* pB2 = pD,可以保證,(void*)pB2的值肯定不等于pD,也即是(void*)pB2 != (void*)pD。個中原因,在下就不多說了。但是,TShared_Ptr完全沒法模擬這種特性,假如,堅持這樣用,設pD為TShared_Ptr<D> ; 然后TShared_Ptr<B2>=pD,后果將不堪設想。一切皆因TShared_Ptr只有一條指向共享對象的指針,它還須擁有指向共享對象的基類子對象的指針,為此,必須添加此指向子對象的指針m_ptr,為_Ty*類型。因此,TShared_Ptr將內含兩個指針,大小就比普通指針大了一倍,無論如何,到此為止,不能讓它增大了。此外,TShared_Ptr增加了m_ptr成員后,還帶來一些別的好處,類型安全倒也罷了,關鍵是在VC中單步調試下,可清晰地看到共享對象的各種狀態,原來沒有m_ptr的時候,就只能悶聲發大財。
            template<typename _Ty>
            class TShared_Ptr
            {
            public:
                
                template
            <typename _OtherTy>
                TShared_Ptr(
            const TShared_Ptr<_OtherTy>& _Other)
                {    
                    m_ptr 
            = _Other.m_ptr;    // 類型安全全靠它了
                    m_pShared = const_cast<__SharedObject*>(_Other.m_pShared);
                    
            if (m_ptr != NULL)
                        m_pShared
            ->Incref();
                }
                
                __SharedObject
            * m_pShared;
                _Ty
            * m_ptr;
            };
                本輪子自然不美觀,使用也頗不方便,但勝在背地里做的勾當少,一切均在預料之中。好像多線程下,還有點問題,但那只是理論上的疑惑,實際運行中,該不會那么巧吧。
                咦,都什么年代,還在研究茴香豆的四種寫法,在下也承認,確實沒啥意義,但樂趣很無窮呢,我就是喜歡。珍惜生命,遠離C++。對了,想要完整的代碼嗎,沒那么容易

            posted on 2012-10-30 15:39 華夏之火 閱讀(1722) 評論(5)  編輯 收藏 引用 所屬分類: c++技術探討

            評論

            # re: 輕量級共享對象的靈巧指針的實現[未登錄] 2012-10-31 13:07

            1.“還能頑強地生存于各種惡劣的環境,好比多線程、引用循環”
            shared_ptr解決循環引用了?! "_Ref_count_base"看似基于引用計數實現

            2.“做了很多不為人知的勾當”
            個人認為最好具體詳細分析一下做了哪些“不為人知的勾當”,這些“勾當”有哪些缺點,是否還有其他優點,個人覺得你只這么泛泛的一說,不夠專業,也不具有說服力,沒法體現你的實現品真正能帶來哪些好處。

            3.對象計數管理一定要有一塊內存來記錄被指對象的引用次數,根據這塊內存在哪,設計分為侵入式和非侵入式,各有不同特點。

            4.認為拷貝構造函數中 if (m_pShared != NULL) 無意義,初值是一個隨機值,此判斷99%為true,是我看錯了還是你寫錯了,析構貌似也不夠嚴謹

            5.“實際運行中,該不會那么巧吧。” 巧與不巧不是你能決定的  回復  更多評論   

            # re: 輕量級共享對象的靈巧指針的實現 2012-10-31 13:40 華夏之火

            @無
            2、在下覺得shared_ptr背后做的事情太多了,超出了它的原本要求。3、侵入式的理解,應該是針對是否影響了類的代碼而言,與內存在哪應該無關,好比在下的這個實現,就是非侵入式。4、拷貝構造函數中確實筆誤了,可參考后文改進版,析構也有改進,只是沒寫出來。5、開玩笑而已,感覺應該沒問題的,在下暫時還看不出來,你幫忙分析分析  回復  更多評論   

            # re: 輕量級共享對象的靈巧指針的實現 2012-10-31 18:31 羅朝輝

            這個實現還有一些值得考究的地方。比如:

            1,如下可以編譯通過么?
            TShared_Ptr<int> pInt;
            if (!pInt) {
            }

            if(pInt == 0) {
            }

            2,TShared_Ptr<int> 與 int * 的可置換性考慮沒?
            void normalize(int * pt);
            TShared_Ptr<int> pInt;
            normalize(pInt); //可否?

            3,考慮了賦值構造操作符沒?

            4,智能指針若不能直接從原生指針構造,那還算智能么?
            int a = 0;
            TShared_Ptr<int> pInt = new TShared_Ptr<int>(&a);

              回復  更多評論   

            # re: 輕量級共享對象的靈巧指針的實現 2012-10-31 23:45 華夏之火

            @羅朝輝
            本靈巧指針只為構造共享對象,自產自毀,從不考慮承接外界的原生指針。提供思路而已,至于具體語法形式的考究,在下也不大感興趣。  回復  更多評論   

            # re: 輕量級共享對象的靈巧指針的實現 2012-11-01 09:00 羅朝輝

            @華夏之火

            那些僅是語法形式的考究?那您自娛自樂吧  回復  更多評論   

            導航

            統計

            常用鏈接

            留言簿(6)

            隨筆分類

            隨筆檔案

            搜索

            積分與排名

            最新評論

            閱讀排行榜

            評論排行榜

            波多野结衣久久| 午夜精品久久久久9999高清| 久久久久久久综合狠狠综合| 亚洲精品国产综合久久一线| 中文字幕无码免费久久| 99999久久久久久亚洲| 亚洲成人精品久久| 2021国内久久精品| 精品九九久久国内精品| 久久久久婷婷| 午夜天堂精品久久久久| 99久久精品国产综合一区| 午夜精品久久久久久影视777| 波多野结衣AV无码久久一区| 久久99精品国产一区二区三区| 欧美久久一区二区三区| 中文字幕热久久久久久久| 欧美777精品久久久久网| 久久99这里只有精品国产| 国产精品久久久久久久久鸭 | 亚洲午夜久久久| 精品久久久久久中文字幕| 一级女性全黄久久生活片免费 | 久久久噜噜噜www成人网| 国产69精品久久久久99尤物| 精品久久久久久无码专区不卡| 日韩美女18网站久久精品| 亚洲国产天堂久久综合网站| 久久免费的精品国产V∧| 精品人妻伦九区久久AAA片69| 性做久久久久久免费观看| 久久国产精品国产自线拍免费| 久久一日本道色综合久久| 无码任你躁久久久久久久| 日产久久强奸免费的看| 中文字幕久久欲求不满| 99久久99久久精品国产片| 狠狠色噜噜狠狠狠狠狠色综合久久| 久久久久久久亚洲Av无码| 婷婷综合久久中文字幕蜜桃三电影| 久久久久免费精品国产|