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

            MyMSDN

            MyMSDN記錄開發新知道

            單參數構造函數的問題,single-argument construct

            關于單一參數構造函數的問題,主要是因為單一參數被編譯器用作隱式類型轉換,從而導致一些不可預期的事件的發生,請參見代碼詳細注釋:

            /*
             * single_argument_ctor.cpp
             *
             *  Created on: 2010-3-29
             *      Author: Volnet
             *      Compiler: GNU C++(version 3.4.5)
             *                MSVC CL(version 15.00.30729.01)
             */
            
            #include <stdlib.h>
            #include <iostream>
            #include <sstream>
            
            // single-argument class
            class SingleArgumentClass {
            private:
                int _inner;
            public:
                SingleArgumentClass()
                    :_inner(-1)
                {
            
                }
                SingleArgumentClass(int actual)
                    :_inner(actual)
                {
            
                }
                bool operator==(const SingleArgumentClass& rhs);
                std::string str(){
                    // we'd better to use boost::lexical_cast to cast.
                    // #region cast
                    std::stringstream strStream;
                    strStream << _inner;
                    std::string str;
                    strStream >> str;
                    // #endregion
                    return str;
                }
            };
            bool
            SingleArgumentClass::operator ==(const SingleArgumentClass& rhs){
                if(_inner == rhs._inner)
                    return true;
                return false;
            }
            
            // single-argument class fixed bug by explicit keyword.
            class SingleArgumentClassFixedBugByExplicitKeyword {
            private:
                int _inner;
            public:
                SingleArgumentClassFixedBugByExplicitKeyword()
                    :_inner(-1)
                {
            
                }
                explicit SingleArgumentClassFixedBugByExplicitKeyword(int actual)
                    :_inner(actual)
                {
            
                }
                bool operator==(const SingleArgumentClassFixedBugByExplicitKeyword& rhs);
                std::string str(){
                    // we'd better to use boost::lexical_cast to cast.
                    // #region cast
                    std::stringstream strStream;
                    strStream << _inner;
                    std::string str;
                    strStream >> str;
                    // #endregion
                    return str;
                }
            };
            bool
            SingleArgumentClassFixedBugByExplicitKeyword::operator ==(const SingleArgumentClassFixedBugByExplicitKeyword& rhs){
                if(_inner == rhs._inner)
                    return true;
                return false;
            }
            
            // single-argument class fixed bug by helper class.
            class ActualType {
            public:
                ActualType(int value):_value(value){};
                int get_value(){ return _value; }
            private:
                int _value;
            };
            class SingleArgumentClassFixedBugByHelperClass {
            private:
                int _inner;
            public:
                SingleArgumentClassFixedBugByHelperClass()
                    :_inner(-1)
                {
            
                }
                SingleArgumentClassFixedBugByHelperClass(ActualType actual)
                    :_inner(actual.get_value())
                {
            
                }
                bool operator==(const SingleArgumentClassFixedBugByHelperClass& rhs);
                std::string str(){
                    // we'd better to use boost::lexical_cast to cast.
                    // #region cast
                    std::stringstream strStream;
                    strStream << _inner;
                    std::string str;
                    strStream >> str;
                    // #endregion
                    return str;
                }
            };
            bool
            SingleArgumentClassFixedBugByHelperClass::operator ==(const SingleArgumentClassFixedBugByHelperClass& rhs){
                if(_inner == rhs._inner)
                    return true;
                return false;
            }
            
            
            void Assert(bool status,
                    std::string strTrue = std::string("assert result is true;"),
                    std::string strFalse = std::string("assert result is false;"));
            int main(void){
                SingleArgumentClass obj(3);
                std::cout << obj.str() << std::endl;
            
                // our purpose.
                SingleArgumentClass obj1(1);
                SingleArgumentClass obj2(1);
                Assert(obj1 == obj2, "obj1 == obj2", "obj1 != obj2");
            
                int i = 3;
                // warning!!!
                // obj is a SingleArgumentClass object.
                // i is a integer.
                // operator== only define the equal between two SingleArgumentClass object.
                // In fact:
                //    obj == i:
                //        1.compiler found the operator== require two SingleArgumentClass object.
                //        2.compiler try to find a cast method for casting int to SingleArgumentClass.
                //        3.compiler found it can use the SingleArguementClass.Ctor(int)
                //            to create a new SingleArgumentClass.
                //         4.compiler try to create a new SingleArgumentClass object from i.
                //        5.so it without any warning and error, but it's logical not we need.
                Assert(obj == i, "obj == i //right?", "obj != i");
                // Assert(i == obj); // Compile ERROR: no match for 'operator==' in 'i == obj'
            
                // it's may encounter a compile-time error.
                // GNU G++: no match for 'operator==' in 'objFixed == i'    single_argument_ctor.cpp    single_argument_ctor/src    106    C/C++ Problem
                // MSVC: 錯誤    1    error C2679: 二進制“==”: 沒有找到接受“int”類型的右操作數的運算符(或沒有可接受的轉換)    {projectpath}\single_argument_ctor\src\single_argument_ctor.cpp    107    single_argument_ctor
                SingleArgumentClassFixedBugByExplicitKeyword objFixed(3);
                // Assert(objFixed == i, "objFixed == i", "objFixed != i");
            
                SingleArgumentClassFixedBugByHelperClass objFixedByHelper1(3);
                SingleArgumentClassFixedBugByHelperClass objFixedByHelper2(3);
                // it's may encounter a compile-time error.
                // GNU G++: no match for 'operator==' in 'objFixedAuto1 == i'    single_argument_ctor.cpp    single_argument_ctor/src    158    C/C++ Problem
                // MSVC: 錯誤    1    error C2679: 二進制“==”: 沒有找到接受“int”類型的右操作數的運算符(或沒有可接受的轉換)    {projectpath}\single_argument_ctor\src\single_argument_ctor.cpp    163    single_argument_ctor
                // Assert(objFixedByHelper1 == i);
            }
            void Assert(bool status,
                    std::string strTrue, std::string strFalse)
            {
                std::cout << (status  strTrue : strFalse) << std::endl;
            }
            

            解決方法:

            1、explicit關鍵字,在單參數構造函數前使用explicit參數,可以避免單參數構造函數被用于隱式轉換。

            2、利用中間類的方式,詳見代碼“SingleArgumentClassFixedBugByHelperClass相關部分”。如果編譯器不支持解決方法1,則建議使用此方法。上面代碼所提及的兩款主流編譯器均支持explicit關鍵字。

            posted on 2010-03-29 15:37 volnet 閱讀(1884) 評論(0)  編輯 收藏 引用 所屬分類: C/C++

            特殊功能
             
            av无码久久久久不卡免费网站 | 国产成人无码精品久久久免费| 亚洲精品乱码久久久久久蜜桃不卡| 久久精品人人做人人爽电影| 欧洲成人午夜精品无码区久久| 久久66热人妻偷产精品9| 久久国产免费直播| 日本强好片久久久久久AAA| 国产精品成人99久久久久| 亚洲精品乱码久久久久久久久久久久| 国产一区二区三区久久| 午夜精品久久久久| 国产激情久久久久影院小草| 国产成人精品三上悠亚久久| yellow中文字幕久久网| 久久A级毛片免费观看| 精品综合久久久久久97| 久久午夜综合久久| 99久久99久久精品国产片| 精品乱码久久久久久久| 久久精品国产亚洲AV不卡| 久久精品夜色噜噜亚洲A∨| 久久er热视频在这里精品| 综合久久国产九一剧情麻豆| 亚洲AV伊人久久青青草原| 久久精品夜色噜噜亚洲A∨| 88久久精品无码一区二区毛片| 99久久超碰中文字幕伊人| 亚洲AV日韩AV天堂久久| 久久久久精品国产亚洲AV无码| 亚洲欧美日韩精品久久亚洲区| 久久中文字幕无码专区| 国产精品成人久久久久久久| 伊人久久精品线影院| 精品国产青草久久久久福利| 久久精品国产一区二区| 狠狠综合久久综合中文88| 久久人妻少妇嫩草AV无码蜜桃| 久久精品中文字幕第23页| 久久精品国产亚洲5555| 久久亚洲精品国产亚洲老地址|