• <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>
            

    
            

            




            







												


        




            
	
		


            隨筆 - 87 
文章 - 279 
trackbacks - 0


             
	

            

            
	
		
            
			
            
	
            
		
            <2025年5月>
            
	
            日一二三四五六
            27282930123
            45678910
            11121314151617
            18192021222324
            25262728293031
            1234567
            

            

            
			


            
	潛心看書研究！

            

			

            常用鏈接
            


            留言簿(19)
            




		
            隨筆分類(81)
            
		
				
			
	
		
            文章分類(89)
            
		
				
			
	
		
            相冊
            
		
				
			
	
		
            ACM OJ
            
		
				
			
	
		
            My friends
            
		
				
			
	




            搜索
            

              
	
            • 
		
            •  
	
              • 

            


            積分與排名
            

              
	
            • 
		積分 -
		216667
	
            • 
		排名 -
		117
	
              • 

            


            最新評論
	
            

            
	
			
		

            


            閱讀排行榜
            



            評論排行榜
            


            		
	

            

            
	
					


            
	
	發覺計算機很多東西都是相同的，記得操作系統時候學過這一概率 copy on write，在Reference Counted中徹底用到，代碼的設計確實精妙，可以在不修改客戶端得類，利用RCIPtr間接指針，對客戶端的類實現引用計數，太妙了，詳細見代碼吧，代碼中Widget為已有的客戶端的類，RCIPtr是一個間接指針，RCObject是引用計數的基類，所有需要引用計數的類都必須繼承他，換句話說，RCObject類將引用計數邏輯封裝了，而RCIPtr則是連接客戶端類的紐帶.
            代碼如下:
            RCIPtr.h
            

            #ifndef RCIPTR_H
            #define RCIPTR_H

            #include             "RCObject.h"

            template            <class T>
            class RCIPtr {
            public :
                RCIPtr(T            * realPtr = 0);                        
                RCIPtr(            const RCIPtr& rhs);
                            ~RCIPtr();
                RCIPtr            & operator=(const RCIPtr& rhs);
                            const T* operator->() const;                    //const version ->
                T* operator->();                                
                            const T& operator*() const;                    //const version *
                T& operator*();
                            int getRefCount() const;                    //測試用，獲取指針所指向的對象的引用數
            private :
                            struct CountHolder : public RCObject {                //T的實際的指針保寸的地方
                    ~CountHolder() {delete pointee;};
                    T            * pointee;
                }            ;
                CountHolder             *counter;
                            void init();                            //初始化公共代碼
                void makeCopy();                        //Copy On Write的調用函數
            }            ;

            #include             "RCIPtr.cpp"

            #endif
            

            RCIPtr.cpp
            

            #ifdef RCIPTR_H 

            template            <class T> 
            void RCIPtr<T>::init() {
                            if (counter->isShareable() == false) {
                    T            * oldValue = counter->pointee;
                    counter             = new CountHolder;
                    counter            ->pointee = new T(*oldValue);
                }
                counter            ->addReference();
            }

            template            <class T>                                 
            void RCIPtr<T>::makeCopy() {
                            if (counter->isShared()) {
                    counter            ->removeReference();
                    T            * oldValue = counter->pointee;    
                    counter             = new CountHolder;
                    counter            ->pointee = new T(*oldValue);
                    counter            ->addReference();
                }
            }

            template            <class T> 
            RCIPtr            <T>::RCIPtr(T* realPtr) : counter(new CountHolder) {
                counter            ->pointee = realPtr;
                init();
            }

            template            <class T> 
            RCIPtr            <T>::RCIPtr(const RCIPtr& rhs) : counter(rhs.counter) {
                init();
            }

            template            <class T> 
            RCIPtr            <T>::~RCIPtr() {
                counter            ->removeReference();
            }

            template            <class T> 
            RCIPtr            <T>& RCIPtr<T>::operator=(const RCIPtr& rhs) {
                            if (counter != rhs.counter) {
                    counter            ->removeReference();
                    counter             = rhs.counter;
                    init();
                }
                            return *this;
            }

            template            <class T> 
            const T* RCIPtr<T>::operator->() const {
                            return counter->pointee;
            }                        

            template            <class T> 
            T            * RCIPtr<T>::operator->() {
                makeCopy(); 
                            return counter->pointee;
            }

            template            <class T>                                 
            const T& RCIPtr<T>::operator*() const {
                            return *(counter->pointee);
            }


            template            <class T>                                 
            T            & RCIPtr<T>::operator*() {
                makeCopy();
                            return *(counter->pointee);
            }

            template            <class T>
            int RCIPtr<T>::getRefCount() const {
                            return counter->getRefCount();
            }

            #endif
            

            RCObject.h

            #ifndef RCOBJECT_H
            #define RCOBJECT_H

            /**
             *    base class, 用于reference-counted objects
                         */
            class RCObject {
            public :
                            void addReference();                        //添加reference
                void removeReference();                        //刪除reference
                void markUnshareable();                        //標記object不可共享
                bool isShareable() const;                    //判斷object是否可被共享
                bool isShared() const;                        //判斷object是否被共享中
                int getRefCount() const;                    //獲取對象的引用數
            protected :
                RCObject();                                                //RCObject default-constructor
                RCObject(const RCObject& rhs);                //RCObject copy-constructor 
                RCObject& operator=(const RCObject& rhs);    //RCObject assignment
                virtual ~RCObject() = 0;
            private :
                            int refCount;                                //引用計數
                bool shareable;                                //可否共享標記
            }            ;

            #endif
            

            RCObject.cpp
            

            #include "RCObject.h"

            RCObject::RCObject() : refCount(            0), shareable(true) {
            }

            RCObject::RCObject(            const RCObject& rhs) : refCount(0), shareable(true) {
            }

            RCObject            & RCObject::operator =(const RCObject& rhs) {
                            return *this;
            }

            void RCObject::addReference() {
                refCount            ++;
            }

            void RCObject::removeReference() {
                            if (--refCount == 0) delete this;
            }

            void RCObject::markUnshareable() {
                shareable             = false;
            }

            bool RCObject::isShareable() const {
                            return shareable;
            }

            bool RCObject::isShared() const {
                            return refCount > 1;
            }

            int RCObject::getRefCount() const {
                            return refCount;
            }

            RCObject::            ~RCObject() {
            //    delete this;
            }
            

            Widget.h
            

            #ifndef WIDGET_H
            #define WIDGET_H

            /**
             * Widget測試類
                         */
            class Widget {
            public :
                Widget(            int size);
                Widget(            const Widget& rhs);
                            ~Widget();
                Widget            & operator=(const Widget& rhs);
                            void setSize(int size);
                            int getSize() const;
                            void showSize() const;
            private :
                            int mSize;
            }            ;

            #endif
            

            Widget.cpp
            

            #include "Widget.h"
            #include             <iostream>
            using namespace std;


            Widget::Widget(            int size) : mSize(size) {
            }

            Widget::Widget(            const Widget& rhs) : mSize(rhs.mSize) {
            }

            Widget::            ~Widget() {
            }

            Widget            & Widget::operator=(const Widget& rhs) {
                            if (this == &rhs) {
                                return *this;
                }
                mSize             = rhs.getSize();
                            return *this;
            }

            void Widget::setSize(int size) {
                mSize             = size;
            }

            int Widget::getSize() const {
                            return mSize;
            }

            void Widget::showSize() const {
                cout             << "Size of this Widget is " << mSize << endl;
            }
            

            RCWidget.h
            

            #ifndef RCWIDGET_H
            #define RCWIDGET_H

            #include             "RCIPtr.h"
            #include             "Widget.h"

            class RCWidget {
            public :
                RCWidget(            int size);
                            void setSize(int size);
                            int getSize() const;
                            void showSize() const;
                            int getRefCount() const;
            private :
                RCIPtr            <Widget> value;
            }            ;

            #endif 
            

            RCWidget.cpp
            

            #include "RCWidget.h"

            RCWidget::RCWidget(            int size) : value(new Widget(size)) {
            }

            void RCWidget::setSize(int size) {
                value            ->setSize(size);
            }

            int RCWidget::getSize() const {
                            return value->getSize();
            }

            void RCWidget::showSize() const {
                value            ->showSize();
            }

            int RCWidget::getRefCount() const {
                            return value.getRefCount();
            }
            

            test.cpp
            

            #include "RCWidget.h"
            #include             <iostream>
            using namespace std;

            int main() {
                RCWidget w(            100);
                RCWidget v(w);
                v.showSize();
                w.showSize();
                cout             << "v RCWidget RefCount is " << v.getRefCount() << endl;
                cout             << "w RCWidget RefCount is " << w.getRefCount() << endl;
                v.setSize(            20);
                v.showSize();
                w.showSize();
                cout             << "v RCWidget RefCount is " << v.getRefCount() << endl;
                cout             << "w RCWidget RefCount is " << w.getRefCount() << endl;
                            return 0;
            }
            


            Result :
            Size of this Widget is 100
            Size of this Widget is 100
            v RCWidget RefCount is 2
            w RCWidget RefCount is 2
            Size of this Widget is 20
            Size of this Widget is 100
            v RCWidget RefCount is 1
            w RCWidget RefCount is 1
            Press any key to continue
            

             只要每次寫一個類似的RC類，就不用修改客戶端已有的類，而又可以實現Reference-Counting了
            

	
            posted on 2008-04-09 21:36 豪 閱讀(550) 評論(0)  編輯 收藏 引用  所屬分類: C++之夢 
            

            







            
	    
    




            






            

				
	



            


    
    







            
	   
	



亚洲中文字幕无码一久久区|
91精品国产91热久久久久福利|
亚洲精品高清国产一久久|
漂亮人妻被黑人久久精品|
伊人久久大香线蕉综合5g|
久久久精品人妻无码专区不卡|
国产亚州精品女人久久久久久|
久久综合久久综合久久|
国产福利电影一区二区三区久久久久成人精品综合|
久久伊人五月天论坛|
久久综合狠狠综合久久97色|
久久久国产一区二区三区|
亚洲人AV永久一区二区三区久久|
久久精品中文字幕有码|
7777精品伊人久久久大香线蕉|
日日狠狠久久偷偷色综合0|
色综合久久夜色精品国产|
久久久精品国产免大香伊|
久久亚洲AV成人出白浆无码国产|
99久久99久久久精品齐齐|
久久久久国产成人精品亚洲午夜|
亚洲国产成人精品无码久久久久久综合|
久久国产精品免费|
久久久久久久久久久精品尤物|
亚洲午夜久久久久妓女影院|
99久久er这里只有精品18|
久久精品国产色蜜蜜麻豆|
午夜精品久久久久久99热|
国产精品热久久毛片|
亚洲午夜无码久久久久|
亚洲国产精品久久久久婷婷老年|
精品国产综合区久久久久久|
国产精品99久久久精品无码
|
久久99精品国产自在现线小黄鸭
|
久久国产精品免费|
亚洲综合日韩久久成人AV|
国产精久久一区二区三区|
无码AV波多野结衣久久|
久久精品无码专区免费|
久久国产精品-国产精品|
怡红院日本一道日本久久|