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

    
            

            




            







												


        

            
	

            
	
            
		
            
			
				
            DraculaW
            
				
            
			            		
		
            
	
            

            

            
	
            
		
            
			
 
C++博客 ::
首頁 ::
新隨筆 ::
聯系 ::
聚合
 ::
管理 ::


			
			
				

            
	
            
		
            
			
			
			
				 
				19 
				隨筆 ::
				0 文章
				::
				7 評論
				::
				0 Trackbacks
			
		
            
	
            

            

			            		
		
            
	
            

            


            


            
	
					

            
	
	
	
            
		
              1#include "SharedPtr.h"
              2#include "gtest/gtest.h"
              3
              4using namespace std;
              5
              6TEST(SharedPtr_test, TestConstructer)
              7{
              8    SharedPtr<int> s1;
              9    EXPECT_EQ(NULL, s1.get());
             10    EXPECT_EQ(0, s1.use_count());
             11    
             12    int *pi = new int;
             13    SharedPtr<int> s2(pi);
             14    EXPECT_EQ(pi, s2.get());
             15    EXPECT_EQ(1, s2.use_count());
             16}            ;
             17
             18TEST(SharedPtr_test, TestAssign)
             19{
             20    SharedPtr<int> s1;
             21
             22    int *pi = new int;
             23    SharedPtr<int> s2(pi);
             24
             25    s1 = s2;
             26    EXPECT_EQ(s1.get(), s2.get());
             27    EXPECT_EQ(s1.use_count(), s2.use_count());
             28    
             29    EXPECT_EQ(pi, s1.get());
             30    EXPECT_EQ(2, s1.use_count());
             31
             32    int *p3 = new int;
             33    SharedPtr<int> s3(p3);
             34    s1 = s3;
             35    EXPECT_EQ(s1.get(), s3.get());
             36    EXPECT_EQ(s1.use_count(), s3.use_count());
             37
             38    EXPECT_EQ(pi, s2.get());
             39    EXPECT_EQ(1, s2.use_count());
             40
             41    s2 = s3;
             42    EXPECT_EQ(s1.get(), s2.get());
             43    EXPECT_EQ(3, s2.use_count());
             44    EXPECT_EQ(s1.use_count(), s2.use_count());
             45
             46    
             47    SharedPtr<int> s4;    
             48    SharedPtr<int> s5;
             49    s4 = s5;
             50    EXPECT_EQ(s4.get(), s5.get());
             51    EXPECT_EQ(s4.use_count(), s5.use_count());
             52
             53    SharedPtr<int> s6;    
             54    SharedPtr<int> s7(s6);
             55    EXPECT_EQ(s6.get(), s7.get());
             56    EXPECT_EQ(s6.use_count(), s7.use_count());
             57
             58    SharedPtr<int> s8;    
             59    SharedPtr<int> s9;    
             60    s8 = s9;
             61    int *p10 = new int;
             62    *p10 = 10;
             63    SharedPtr<int> s10(p10);
             64    s8 = s10;
             65    EXPECT_NE(s8.get(), s9.get());
             66    EXPECT_NE(s8.use_count(), s9.use_count());
             67    (*s10)--;
             68    EXPECT_EQ(9, *(s8.get()));
             69
             70}            ;
             71
             72//TEST(SharedPtr_test, TestNULL)
             73//{
             74//    SharedPtr<int> s1;
             75//
             76//    try{
             77//        s1.operator *();
             78//    }
             79//    catch(exception e)
             80//    {
             81//        EXPECT_EQ(e.what(), "There is a null pointer");
             82//    }
             83//
             84//    
             85//    try{
             86//        s1.operator ->();
             87//    }
             88//    catch(exception e)
             89//    {
             90//        EXPECT_EQ(e.what(), "There is a null pointer");
             91//    }
             92//}
             93
             94TEST(SharedPtr_test, TestOperatorEqual)
             95{
             96    SharedPtr<int> s1;
             97    SharedPtr<int> s2;
             98    SharedPtr<double> s3;
             99    SharedPtr<string> s4;
            100    
            101    int *p1 = new int;
            102    SharedPtr<int> s5(p1);
            103    SharedPtr<int> s6(s5);
            104    SharedPtr<int> s7 = s6;
            105    SharedPtr<int> s8;
            106    s8 = s7;
            107    int *p2 = new int;
            108    SharedPtr<int> s9(p2);
            109
            110    
            111    EXPECT_EQ(true, s1 == s2);
            112    EXPECT_EQ(false, s1 == s3);
            113    EXPECT_EQ(false, s1 == s4);
            114
            115    
            116    EXPECT_EQ(true, s5 == s6);
            117    EXPECT_EQ(false, s5 == s2);
            118    EXPECT_EQ(true, s5 == s7);
            119    EXPECT_EQ(true, s5 == s8);
            120    EXPECT_EQ(false, s5 == s9);
            121}
            122
            123TEST(SharedPtr_test, TestOperatorNotEqual)
            124{
            125    SharedPtr<int> s1;
            126    SharedPtr<int> s2;
            127    SharedPtr<double> s3;
            128    SharedPtr<string> s4;
            129    
            130    int *p1 = new int;
            131    SharedPtr<int> s5(p1);
            132    SharedPtr<int> s6(s5);
            133    SharedPtr<int> s7 = s6;
            134    SharedPtr<int> s8;
            135    s8 = s7;
            136    int *p2 = new int;
            137    SharedPtr<int> s9(p2);
            138
            139    
            140    EXPECT_NE(true, s1 != s2);
            141    EXPECT_NE(false, s1 != s3);
            142    EXPECT_NE(false, s1 != s4);
            143    
            144    EXPECT_NE(true, s5 != s6);
            145    EXPECT_NE(false, s5 != s2);
            146    EXPECT_NE(true, s5 != s7);
            147    EXPECT_NE(true, s5 != s8);
            148    EXPECT_NE(false, s5 != s9);
            149}
            150
            151TEST(SharedPtr_test, TestOther)
            152{
            153    int *pi = new int;
            154    SharedPtr<int> s1(pi);
            155    EXPECT_EQ(pi, s1.get());
            156    EXPECT_EQ(1, s1.use_count());
            157
            158    *s1 = 10;
            159    EXPECT_EQ(10, (*(s1.get())));
            160    EXPECT_EQ(10, (*s1));
            161
            162    UserCount *puc = new UserCount(19);
            163    SharedPtr<UserCount> sc(puc);
            164    EXPECT_EQ(puc, &(*sc));
            165    EXPECT_EQ(puc, sc.get());
            166    EXPECT_EQ(19, sc->GetCount());
            167}            ;
            168
            169int main(int argc, char **argv)
            170{
            171    testing::InitGoogleTest(&argc, argv);
            172    
            173    return RUN_ALL_TESTS();
            174    return 0;
            175}
            

            上面是測試 
            下面是代碼
            

              1#ifndef __SSA_SHARED_PTR__
              2#define __SSA_SHARED_PTR__
              3
              4#include <stdexcept>
              5
              6using namespace std;
              7
              8class NullPointerException: exception{
              9public:
             10    NullPointerException():exception("There is a null pointer"){};
             11}            ;
             12
             13template<typename T>
             14class UserObject{
             15    T* pObj;
             16
             17public:
             18    UserObject(T* v):pObj(v){};
             19    UserObject(const UserObject<T>& rl){
             20        this->pObj = rl.pObj;
             21    }            ;
             22
             23    UserObject &operator=(const UserObject<T>& rl){
             24        this->pObj = rl.pObj;
             25    }            ;
             26
             27    ~UserObject(){delete pObj;};
             28
             29    T & operator*() const    {
             30        if(pObj == NULL)  {
             31            throw NullPointerException();
             32        }
             33        return *pObj;
             34    }
             35
             36    T * operator->() const  {
             37        if(pObj == NULL)  {
             38            throw NullPointerException();
             39        }
             40        return pObj;
             41    }
             42
             43    T * get() const {
             44        return pObj;
             45    }
             46}            ;
             47
             48class UserCount{
             49public:
             50
             51    UserCount():_userCount(1){};
             52    UserCount(size_t count):_userCount(count){};
             53    size_t AddRef()    {
             54        _userCount++;
             55        return _userCount;
             56    }
             57
             58    size_t Release()    {
             59        _userCount--;
             60        return _userCount;
             61    }
             62
             63    size_t GetCount()    {
             64        return _userCount;
             65    }
             66    
             67private:
             68    size_t _userCount;
             69}            ;
             70
             71template<typename T> 
             72class SharedPtr{
             73public:
             74    SharedPtr(){
             75        pObj = new UserObject<T>(NULL);
             76        pn = new UserCount(0);
             77    }            ;
             78
             79    SharedPtr(T* v){
             80        pObj = new UserObject<T>(v);
             81        pn = new UserCount(1);
             82    }            ;
             83
             84    SharedPtr(const SharedPtr<T> &rl){
             85        this->pObj = rl.pObj;
             86        rl.pn->AddRef();
             87        this->pn = rl.pn;
             88    }
             89
             90    ~SharedPtr(){
             91        if(this->pn == NULL)        {
             92            return;
             93        }
             94
             95        if(this->pn->Release() == 0)        {
             96            delete this->pObj;
             97            delete this->pn;
             98        }
             99    }            ;
            100
            101    T & operator*() const    {
            102        return pObj->operator *();
            103    }
            104
            105    T * operator->() const  {
            106        return pObj->operator ->();
            107    }
            108
            109    T * get() const {
            110        return pObj->get();
            111    }
            112
            113    std::size_t use_count() const   {
            114        if(pn==NULL) return 0;
            115        return pn->GetCount();
            116    }
            117    
            118    SharedPtr<T>& operator=(SharedPtr<T> &rv){
            119
            120        if(this->pn->Release() == 0 )
            121        {
            122            delete this->pObj;
            123        }
            124
            125        this->pObj = rv.pObj;
            126        rv.pn->AddRef();
            127        this->pn = rv.pn;
            128
            129        return *this;
            130    }
            131
            132    template<typename T>
            133    friend bool  operator==(SharedPtr<T> &lv, SharedPtr<T> &rv);    
            134    template<typename T>
            135    friend bool operator==(const SharedPtr<T> &lv, const SharedPtr<T> &rv);    
            136    template<typename T, typename U>
            137    friend bool operator==(SharedPtr<T> &lv, SharedPtr<U> &rv);
            138    template<typename T, typename U>
            139    friend bool operator==(const SharedPtr<T> &lv, const SharedPtr<U> &rv);
            140    
            141    template<typename T>
            142    friend bool  operator!=(SharedPtr<T> &lv, SharedPtr<T> &rv);    
            143    template<typename T>
            144    friend bool operator!=(const SharedPtr<T> &lv, const SharedPtr<T> &rv);    
            145    template<typename T, typename U>
            146    friend bool operator!=(SharedPtr<T> &lv, SharedPtr<U> &rv);
            147    template<typename T, typename U>
            148    friend bool operator!=(const SharedPtr<T> &lv, const SharedPtr<U> &rv);
            149
            150private:
            151    UserObject<T> * pObj;
            152    UserCount* pn;
            153}            ;
            154
            155template<typename T>
            156bool operator==(SharedPtr<T> &lv, SharedPtr<T> &rv)
            157{
            158    return lv.get() == rv.get();
            159}
            160
            161template<typename T>
            162bool operator==(const SharedPtr<T> &lv, const SharedPtr<T> &rv)
            163{
            164    return lv.get() == rv.get();
            165}
            166
            167template<typename T, typename U> 
            168bool operator==(SharedPtr<T> &lv, SharedPtr<U> &rv)
            169{
            170    return false;
            171}
            172
            173template<typename T, typename U> 
            174bool operator==(const SharedPtr<T> &lv, const SharedPtr<U> &rv)
            175{
            176    return false;
            177}
            178
            179template<typename T>
            180bool operator!=(SharedPtr<T> &lv, SharedPtr<T> &rv)
            181{
            182    return lv.get() != rv.get();
            183}
            184
            185template<typename T>
            186bool operator!=(const SharedPtr<T> &lv, const SharedPtr<T> &rv)
            187{
            188    return lv.get() != rv.get();
            189}
            190
            191template<typename T, typename U> 
            192bool operator!=(SharedPtr<T> &lv, SharedPtr<U> &rv)
            193{
            194    return true;
            195}
            196
            197template<typename T, typename U> 
            198bool operator!=(const SharedPtr<T> &lv, const SharedPtr<U> &rv)
            199{
            200    return true;
            201}
            202
            203#endif //__SSA_SHARED_PTR__
            

            希望大家能幫我提一些意見 謝謝

	
            
	
	
            
		posted on 2008-11-28 17:39 DraculaW 閱讀(400) 評論(0)  編輯 收藏 引用  
	
            

            







            
	    
    




            






            

				

            



    
    







            
	   
	



亚洲综合熟女久久久30p|
成人亚洲欧美久久久久|
久久免费大片|
久久黄视频|
国内精品久久久久久久涩爱|
久久久久成人精品无码中文字幕|
久久久亚洲AV波多野结衣|
亚洲欧美日韩精品久久亚洲区|
精品欧美一区二区三区久久久|
亚洲国产精品久久久久|
精品久久久久久无码中文字幕
|
亚洲天堂久久久|
怡红院日本一道日本久久
|
久久狠狠高潮亚洲精品|
亚洲国产欧美国产综合久久|
久久精品亚洲精品国产色婷|
国产午夜久久影院|
久久久久国产视频电影|
手机看片久久高清国产日韩|
久久免费视频1|
国内精品久久久久久99蜜桃
|
久久青青草原亚洲av无码app|
久久狠狠高潮亚洲精品|
日本免费一区二区久久人人澡|
久久久WWW成人|
久久国产欧美日韩精品|
999久久久国产精品|
久久午夜无码鲁丝片秋霞|
AV无码久久久久不卡网站下载|
亚洲午夜精品久久久久久人妖|
亚洲国产精品综合久久网络|
亚洲精品乱码久久久久66|
中文精品久久久久国产网址|
国产成人综合久久精品红|
久久99中文字幕久久|
色欲综合久久躁天天躁|
91精品国产综合久久久久久|
久久久精品久久久久特色影视|
亚洲国产精品无码久久一区二区|
久久91这里精品国产2020|
色婷婷综合久久久久中文|