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

    
            

            




            







												


        




            
	
		
		
            

隨筆-159 
評論-223 
文章-30 
trackbacks-0

            
	

            

            
	
					


            
	
	   在面向對象開發(fā)時，對實際問題分析進而抽象出一種類型，往往會考慮到2個方面：1）類型的內部成員和方法的定義描述 2）類型的多實例存取操作。其中第1點是類型本身數(shù)據(jù)結構的設計，第2點是類型容器數(shù)據(jù)結構的選擇設計。在stl中，容器有序列式和關聯(lián)式兩種，前者代表有vector，list，deque等；后者代表有set，multiset，map，multimap等，對于一個類型的第2點，我們會考慮甚至是反復權衡選擇序列容器還是關聯(lián)容器？在確定選擇了一種之后，比如序列式容器，又會進一步的思考是選擇vetor、list、還是deque？實質上對它們的選擇主要取決于應用的需要，比如要求快速訪問就選擇vetor，要求快速插入刪除就選擇list，符合隊列模型就選擇deque。如果對性能要求較高，就得選擇關聯(lián)式容器，這樣訪問、插入、刪除元素都能得到較好的性能。如果操作太頻繁，這時set，map還不行，要選擇hash_set，hash_map等。
               本文僅探討序列式容器的選擇應用，對一個類型而言，既選擇了序列式容器，就意味在vector，list，deque間選擇（這里要說明的是，stack和queue雖然也是序列式容器，但從真正嚴格意義上講，它們只是一種適配器）那么有沒有辦法作一個通用的包裝類提供給開發(fā)者，讓開發(fā)者自己根據(jù)應用決定選擇具體的容器類型呢？同時這個包裝又不影響原容器的接口使用。關于包裝類的實現(xiàn)，代碼描述如下 

            

            

              1#ifndef _STL_COLLECTION_H
              2#define _STL_COLLECTION_H
              3
              4#include <memory>
              5#include <vector>
              6
              7 /**
              8    @class STLCollection
              9    @brief 基于STL序列容器實現(xiàn)的通用集合類
             10
             11    * 提供以索引作為外參的以下公共通用接口
             12    *  add    --- 向前或向后增加單個元素
             13    *  insert --- 插入單個元素
             14    *  erase --- 刪除單個或多個元素
             15    *  set    --- 修改某個元素
             16    *  get    --- 獲取某個元素
             17    *  front  --- 獲取第一個元素
             18    *  back  --- 獲取最后一個元素
             19*/
             20template<typename T,template<class T,class U > class C = std::vector,template <class T> class U = std::allocator>
             21class STLCollection : public C<T,U<T> >
             22{
             23    typedef U<T> Allocator;
             24    typedef C<T,Allocator> base;
             25
             26public:
             27    //為使用方便,重新定義實現(xiàn)構造函數(shù)及拷貝構造函數(shù),但賦值拷貝可以不用重新定義實現(xiàn)
             28    STLCollection()
             29    {
             30    }
             31    explicit STLCollection(const Allocator& al)
             32        :base(al)
             33    {
             34    }
             35    explicit STLCollection(size_t n)
             36        :base(n)
             37    {
             38    }
             39    STLCollection(size_t n,const T& t)
             40        :base(n,t)
             41    {
             42    }
             43    STLCollection(size_t n,const T& t,const Allocator& al)
             44        :base(n,t,al)
             45    {
             46    }
             47    STLCollection(const STLCollection& right)
             48        :base(right)
             49    {
             50    }
             51
             52    template<class InputIterator>
             53    STLCollection(InputIterator first,InputIterator last)
             54        :base(first,last)
             55    {
             56    }
             57
             58    template<class InputIterator>
             59    STLCollection(InputIterator first,InputIterator last,const Allocator& al)
             60        :base(first,last,al)
             61    {
             62    }
             63
             64public:
             65    //使基類的同名函數(shù)erase,insert,front,back可見
             66    using base::erase;
             67    using base::insert;
             68    using base::front;
             69    using base::back;
             70
             71    void add(const T& t,bool append = true)
             72    {
             73        if (append)
             74            base::insert(base::end(),t);
             75        else
             76            base::insert(base::begin(),t);
             77    }
             78    void insert(size_t index,const T& t)
             79    {
             80        insert_impl(index,t,typename std::iterator_traits<typename base::iterator>::iterator_category());
             81    }
             82    void erase(size_t index)
             83    {
             84        erase_impl(index,typename std::iterator_traits<typename base::iterator>::iterator_category());
             85    }
             86    void erase(size_t beg,size_t end)
             87    {
             88        erase_impl(beg,end,typename std::iterator_traits<typename base::iterator>::iterator_category());
             89    }
             90    void set(size_t index,const T& t)
             91    {
             92        T* p = get(index);
             93        if (p) *p = t;
             94    }
             95    T* get(size_t index) 
             96    {
             97        return get_impl(index,typename std::iterator_traits<typename base::iterator>::iterator_category());
             98    }
             99    const T* get(size_t index) const
            100    {
            101        return get_impl(index,typename std::iterator_traits<typename base::iterator>::iterator_category());
            102    }
            103    T* front()
            104    {
            105        if (base::empty()) return NULL;
            106        return &base::front();
            107    }
            108    const T* front() const
            109    {
            110        if (base::empty()) return NULL;
            111        return &base::front();
            112    }
            113    T* back()
            114    {
            115        if (base::empty()) return NULL;
            116        return &base::back();
            117    }
            118    const T* back() const
            119    {
            120        if (base::empty()) return NULL;
            121        return &base::back();
            122    }
            123    bool is_empty() const
            124    {
            125        return base::empty();
            126    }
            127
            128private:
            129    /*************************************************************************************
            130        下面函數(shù)僅作內部實現(xiàn),需要注意以下幾點
            131        (1) 不讓其子類和外部可見,故使用private訪問控制
            132        (2) 考慮到子類可能會使用using指令來引用,如果為重載形式,子類using引用同名函數(shù)
            133             會因為private出錯而不能引用public同名函數(shù),故特命名為xxx_impl而非重載形式
            134    *************************************************************************************/
            135    void insert_impl(size_t index,const T& t,std::random_access_iterator_tag tag)
            136    {
            137        if (index < base::size())
            138        {
            139            base::insert(base::begin()+index,t);
            140        }
            141    }
            142    void insert_impl(size_t index,const T& t,std::input_iterator_tag tag)
            143    {
            144        if (index < base::size())
            145        {
            146            typename base::iterator it = base::begin();
            147            while(index--) ++it;
            148            base::insert(it,t);
            149        }
            150    }
            151    void erase_impl(size_t index,std::random_access_iterator_tag tag)
            152    {
            153        if (index < base::size())
            154        {
            155            base::erase(base::begin()+index);
            156        }
            157    }
            158    void erase_impl(size_t index,std::input_iterator_tag tag)
            159    {
            160        if (index < base::size())
            161        {
            162            typename base::iterator it = base::begin();
            163            while(index--) ++it;
            164            base::erase(it);
            165        }
            166    }
            167    void erase_impl(size_t beg,size_t end,std::random_access_iterator_tag tag)
            168    {
            169        end = std::min(end,base::size());
            170        if (beg < end)
            171        {
            172            base::erase(base::begin()+beg,base::begin()+end);
            173        }
            174    }
            175    void erase_impl(size_t beg,size_t end,std::input_iterator_tag tag)
            176    {
            177        end = std::min(end,base::size());
            178        if (beg < end)
            179        {
            180            typename base::iterator it = base::begin();
            181            while(beg++ < end) it = base::erase(it);
            182        }
            183    }
            184    T* get_impl(size_t index,std::random_access_iterator_tag tag)
            185    {
            186        if (index>=base::size())
            187            return NULL;
            188        return &(*(base::begin()+index));
            189    }
            190    const T* get_impl(size_t index,std::random_access_iterator_tag tag) const
            191    {
            192        if (index>=base::size())
            193            return NULL;
            194        return &(*(base::begin()+index));
            195    }
            196    T* get_impl(size_t index,std::input_iterator_tag tag)
            197    {
            198        if (index>=base::size())
            199            return NULL;
            200        typename base::iterator it = base::begin();
            201        while (index--) ++it;
            202        return &(*it);
            203    }
            204    const T* get_impl(size_t index,std::input_iterator_tag tag) const
            205    {
            206        if (index>=base::size())
            207            return NULL;
            208        typename base::const_iterator it = base::begin();
            209        while(index--) ++it;
            210        return &(*it);
            211    }
            212}            ;
            213
            214#endif
            

               這樣一來，由于STLCollection類提供了通用的操作接口，在應用時如果想切換改變?yōu)榱硪环N容器，只需改變第2個模板參數(shù)即可，其它部分代碼都不用改變，大大方便了程序的維護擴展，還可以繼承STLCollection類，實現(xiàn)自己特殊的集合類，比如元素類型是_variant_t類型，代碼描述如下
            

            

            

              1#ifndef _VARIANT_COLLECTION_H
              2#define _VARIANT_COLLECTION_H
              3
              4#include <comutil.h>
              5#pragma comment(lib,"comsuppw.lib")
              6
              7class variant_collection : public STLCollection<_variant_t>
              8{
              9    typedef STLCollection<_variant_t> base;
             10
             11public:
             12    using base::add;
             13    using base::insert;
             14    using base::set;
             15
             16    void add(signed char val)
             17    {
             18        add<signed char>(val);
             19    }
             20    void add(unsigned char val)
             21    {
             22        add<unsigned char>(val);
             23    }
             24    void add(short val)
             25    {
             26        add<short>(val);
             27    }
             28    void add(unsigned short val)
             29    {
             30        add<unsigned short>(val);
             31    }
             32    void add(int val)
             33    {
             34        add<int>(val);
             35    }
             36    void add(unsigned int val)
             37    {
             38        add<unsigned int>(val);
             39    }
             40    void add(float val)
             41    {
             42        add<float>(val);
             43    }
             44    void add(double val)
             45    {
             46        add<double>(val);
             47    }
             48    void add(const char* val)
             49    {
             50        add<const char*>(val);
             51    }
             52  
             53    void insert(size_t index,signed char val)
             54    {
             55        insert<signed char>(index,val);
             56    }
             57    void insert(size_t index,unsigned char val)
             58    {
             59        insert<unsigned char>(index,val);
             60    }
             61    void insert(size_t index,short val)
             62    {
             63        insert<short>(index,val);
             64    }
             65    void insert(size_t index,unsigned short val)
             66    {
             67        insert<unsigned short>(index,val);
             68    }
             69    void insert(size_t index,int val)
             70    {
             71        insert<int>(index,val);
             72    }
             73    void insert(size_t index,unsigned int val)
             74    {
             75        insert<unsigned int>(index,val);
             76    }
             77    void insert(size_t index,float val)
             78    {
             79        insert<float>(index,val);
             80    }
             81    void insert(size_t index,double val)
             82    {
             83        insert<double>(index,val);
             84    }
             85    void insert(size_t index,const char* val)
             86    {
             87        insert<const char*>(index,val);
             88    }
             89   
             90    void set(size_t index,signed char val)
             91    {
             92        set<signed char>(index,val);
             93    }
             94    void set(size_t index,unsigned char val)
             95    {
             96        set<unsigned char>(index,val);
             97    }
             98    void set(size_t index,short val)
             99    {
            100        set<short>(index,val);
            101    }
            102    void set(size_t index,unsigned short val)
            103    {
            104        set<unsigned short>(index,val);
            105    }
            106    void set(size_t index,int val)
            107    {
            108        set<int>(index,val);
            109    }
            110    void set(size_t index,unsigned int val)
            111    {
            112        set<unsigned int>(index,val);
            113    }
            114    void set(size_t index,float val)
            115    {
            116        set<float>(index,val);
            117    }
            118    void set(size_t index,double val)
            119    {
            120        set<double>(index,val);
            121    }
            122    void set(size_t index,const char* val)
            123    {
            124        set<const char*>(index,val);
            125    }
            126
            127protected:
            128    template<typename T>
            129    void add(T val)
            130    {
            131        _variant_t var(val);
            132        base::add(var);
            133    }
            134    template<typename T>
            135    void insert(size_t index,T val)
            136    {
            137        _variant_t var(val);
            138        base::insert(index,var);
            139    }
            140    template<typename T>
            141    void set(size_t index,T val)
            142    {
            143        _variant_t* p_var = base::get(index);
            144        if (p_var) *p_var = val;
            145    }
            146}            ;
            147
            148#endif 
            
	
            posted on 2011-07-16 12:23 春秋十二月 閱讀(1892) 評論(0)  編輯 收藏 引用  所屬分類: Opensrc 
            

            







            
	    
    




            






            

				

            






    
    







            
	   
	



 久久综合狠狠综合久久激情 |
久久福利片|
久久国产一片免费观看|
99久久国语露脸精品国产|
亚洲精品乱码久久久久久按摩
|
亚洲午夜精品久久久久久人妖|
一本久久a久久精品亚洲|
性做久久久久久久久浪潮|
久久婷婷色综合一区二区|
久久激情亚洲精品无码?V|
国产L精品国产亚洲区久久|
伊人热人久久中文字幕|
国产女人aaa级久久久级|
久久久久无码中|
久久这里只精品99re66|
精品久久亚洲中文无码|
久久中文字幕人妻丝袜|
亚洲国产另类久久久精品小说
|
热久久这里只有精品|
99久久精品费精品国产|
午夜精品久久久久成人|
久久久久波多野结衣高潮|
成人资源影音先锋久久资源网|
伊人丁香狠狠色综合久久|
合区精品久久久中文字幕一区|
久久精品国产亚洲av麻豆蜜芽|
精品久久久久中文字幕日本|
久久免费视频观看|
狠狠色丁香婷婷久久综合五月|
97热久久免费频精品99|
久久91这里精品国产2020|
亚洲国产精品无码久久久秋霞2|
久久精品免费观看|
中文字幕无码久久人妻|
精品久久香蕉国产线看观看亚洲|
亚洲精品国精品久久99热|
久久国产精品-久久精品|
久久亚洲日韩看片无码|
国产精品青草久久久久福利99|
亚洲国产精品无码久久久不卡|
国产精品免费久久|