• <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>
            隨筆 - 55  文章 - 15  trackbacks - 0
            <2012年3月>
            26272829123
            45678910
            11121314151617
            18192021222324
            25262728293031
            1234567

            常用鏈接

            留言簿

            隨筆分類

            隨筆檔案

            搜索

            •  

            最新評論

            閱讀排行榜

            評論排行榜

            運算符重載的目的:使操作更明確,更方便
            可以是成員函數,也可以是全局函數。成員函數的好處是:返回值可以調用函數。全局函數的好處是:運算符兩邊的對象都可以進行隱式類型轉化。但是,如果定義了一個全局的運算符,將有機會覆蓋掉標準的運算。
            不能重載的運算符:
            1. 成員選擇operator.()。如果允許重載,就不能用普通的方法訪問成員,只能用operator->()訪問。
            2. 成員指針間接引用operator.*()。
            3. 不存在的用戶自定義的運算符。
            ps:不能改變優先級,也不能改變運算符的參數。否則很難記憶。
            幾個比較重要的運算符:

            Class Byte
            {
            int b;
            public:
             
            const Byte& operator++()// prefix ++byte
             {
                b
            ++;
                
            return *this;
             }


             
            const Byte& operator++(int)//postfix byte++
             {
                Byte before(b);
                b
            ++;
                
            return before;
             }

            }
            ;

            /////////////
            class Integer{
            long i;
            public:
              Integer(
            long ll = 0):i(ll){}
              friend 
            const Integer operator-(const Integer& left, const Integer& right);
            }
            ;
            const Integer operator-(const Integer& left, const Integer& right)
            {
                
            return Integer(left.i - right.i);
            }
            //返回值優化,構造一個對象并交給返回值。


            operator->靈巧指針,是一個類看起來像指針 :必須返回一個對象(或對象的引用),該對 象也有一個指針間接引用運算符;或者必須返回一個指針。

            class Obj{
             
            public:
              
            void f() const {cout << "f()" << endl;}
            }
            ;
            class ObjContainer{
              vector
            <Obj*> a;
              friend 
            class SmartPointer;
            }
            ;
            class SmartPointer{
              ObjContainer
            & oc;
              
            int index;
            public:
              SmartPointer(ObjContainer
            & objc):oc(objc){
                 index 
            = 0;
               }

              Obj
            * operator->()const{
                 
            return oc.a[index];
               }

            }
            ;

            ObjContainer oc;
            SmartPointer sp(oc);
            sp
            ->f();  

            一般將智能指針嵌入它所服務的類中。

            operator->*(),二元運算符,必須有一個operator(),且必須是成員函數。operator()允許里面有任意參數,使得對象看起來像一個真正的函數。
            class Dog{
              
            public:
               
            int run(int i) const{}
               
            int eat(int i) const{}


            typedef 
            int(Dog::*PMF)(int)const;

            class FunctionObject{
              Dog
            * ptr;
              PMF pmem;
             
            public:
              FunctionObject(Dog
            * dp, PMF pmf):ptr(dp), pmem(pmf){}
              
            int operator()(int i)const{
                 
            return (ptr->*pmem)(i);
                }

              }
            ;
             FunctionObject 
            operator->*(PMF pmf){
                
            return FunctionObject(this,pmf);//automaticlly invoke operator()
             }

            }
            ;

            int main()
            {
              Dog w;
              Dog::PMF pmf 
            = &Dog::run;
              (w
            ->*pmf)(1);
              pmf 
            = &Dog::eat;
              (w
            ->*pmf)(2);
              
            return 0;
            }

            operator->*返回一個FunctionObject對象,其中有對象*this,也有指向成員的指針pmem。


            賦值運算符
            從有到有。
            MyType b;
            MyType a 
            = b;//a沒出現過,調用拷貝構造函數
            = b;//a已經出現,調用operator=()
            因為是從一個對象賦值至已有的對象,以為著這個對象不再使用,所以要進行一些處理。并且應該判斷是否賦值給自己。
            引用計數的引入:所有的指針都指向一塊內存,所以,增加一塊引用就應該增加一次計數。當計數為0時,表示沒有指針指向它,可以delete掉。
            但是,如果修改了這塊內存,意味著所有指向它的引用都被修改了,所以出現了寫拷貝。判斷引用計數是否為1,為1的話說明沒有其他指針指向它,可以修改。如果大于1,說明有很多指針指向它,那就重新開辟一塊內存,將那塊內存的內容復制過來,再進行修改,同時,指向最初內存的引用計數應該減1.

            自動類型轉換
            轉型構造函數:必須只有一個參數,隱式轉換。如果想顯式轉換,使用explicit定義拷貝構造函數。
            運算符轉換:
            class Three{
               
            int i;
              
            public:
                Three(
            int ii = 0int = 0):i(ii){}
            }
            ;

            class Four{
                
            int x;
              
            public:
                Four(
            int xx):x(xx){}
                
            operator Three()constreturn Three(x);}
            }
            ;

            void g(Three){}
            int main()
            {
              Four four(
            1);
              g(four);
              g(
            1);
            }



























            1
                            
            posted on 2012-06-01 16:48 Dino-Tech 閱讀(274) 評論(0)  編輯 收藏 引用
            久久91精品久久91综合| 国产精品美女久久久久网| 国内精品伊人久久久影院| 午夜视频久久久久一区 | 久久久久久综合一区中文字幕| 亚洲精品高清久久| 一本色道久久HEZYO无码| 色综合久久综精品| 伊人久久精品无码二区麻豆| 99久久久久| 性色欲网站人妻丰满中文久久不卡 | 久久久久99精品成人片欧美 | 久久se精品一区二区| 精品久久久一二三区| 国产精品综合久久第一页 | 久久久久久免费一区二区三区| 国内精品综合久久久40p| 狠狠色丁香婷婷综合久久来来去 | aaa级精品久久久国产片| 国产精品久久久久久五月尺| 国产精品成人精品久久久| 久久精品国产亚洲av日韩| 久久WWW免费人成一看片| 色婷婷综合久久久久中文字幕| 伊人久久综合热线大杳蕉下载| 久久青青草原亚洲av无码app| 亚洲美日韩Av中文字幕无码久久久妻妇 | 国产一区二区精品久久| 欧美黑人激情性久久| 伊人久久大香线蕉亚洲| 国内精品伊人久久久久777| 国产成人精品久久| 亚洲国产精品无码久久98| 久久午夜无码鲁丝片秋霞| 久久AV高潮AV无码AV| 亚洲第一极品精品无码久久| 久久久久久精品成人免费图片 | 久久人人爽人人爽人人片AV麻烦 | 青青热久久国产久精品| 一本久久a久久精品综合香蕉| 伊人久久大香线蕉综合网站|