• <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年5月>
            293012345
            6789101112
            13141516171819
            20212223242526
            272829303112
            3456789

            常用鏈接

            留言簿

            隨筆分類

            隨筆檔案

            搜索

            •  

            最新評論

            閱讀排行榜

            評論排行榜

            運算符重載的目的:使操作更明確,更方便
            可以是成員函數,也可以是全局函數。成員函數的好處是:返回值可以調用函數。全局函數的好處是:運算符兩邊的對象都可以進行隱式類型轉化。但是,如果定義了一個全局的運算符,將有機會覆蓋掉標準的運算。
            不能重載的運算符:
            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 閱讀(269) 評論(0)  編輯 收藏 引用
            久久成人精品| 国内精品久久久久影院网站| 欧美亚洲另类久久综合婷婷| 日韩十八禁一区二区久久| 狠狠色丁香久久婷婷综合| 欧美亚洲色综久久精品国产| 少妇高潮惨叫久久久久久| 99国内精品久久久久久久| 色播久久人人爽人人爽人人片AV| 青草国产精品久久久久久| 精品久久久久久无码中文字幕| 2021国内久久精品| 狠狠色丁香婷婷综合久久来 | 国产午夜福利精品久久2021| 99久久国产主播综合精品| 久久亚洲欧美国产精品| 狠狠色丁香久久婷婷综合图片| 777米奇久久最新地址| 久久人妻AV中文字幕| 中文字幕亚洲综合久久| 久久夜色精品国产网站| 久久久久久久久66精品片| 国产69精品久久久久9999| 国产精品一区二区久久国产| 久久久久亚洲av成人网人人软件| 久久综合久久综合久久综合| 蜜臀久久99精品久久久久久小说| 久久久国产精品| 国产亚州精品女人久久久久久 | 亚洲美日韩Av中文字幕无码久久久妻妇 | 国产精品青草久久久久福利99| 久久精品国产乱子伦| 亚洲欧美一区二区三区久久| 国产精品gz久久久| 精品久久久久久无码中文野结衣| 狠狠狠色丁香婷婷综合久久俺| 精品无码久久久久国产| 久久99国产精品尤物| 久久国产精品99久久久久久老狼 | 少妇精品久久久一区二区三区| 2021国产精品久久精品|