explicit 用法

explicit关键字用于取消构造函数的隐式转换,对有多个参数的构造函数使用explicit是个语法错误。


In C++ it is possible to declare constructors for a class, taking a single parameter, and use those constructors for doing type conversion. For example:

 
 
class  A { public :         A( int ); }; void  f(A) {} void  g() {          A a1  =   37 ;          A a2  =  A( 47 );          A a3( 57 );          a1  =   67 ;          f( 77 ); }
A declaration like:  A a1 = 37; says to call the A(int) constructor to create an A object from the integer value. Such a constructor is called a "converting constructor".

However, this type of implicit conversion can be confusing, and there is a way of disabling it, using a new keyword "explicit" in the constructor declaration:

 
 
class  A { public :         explicit  A( int ); }; void  f(A) {} void  g() {           A a1  =   37 ;       //  illegal           A a2  =  A( 47 );    //  OK           A a3( 57 );        //  OK           a1  =   67 ;         //  illegal           f( 77 );           //  illegal }
Using the explicit keyword, a constructor is declared to be
"nonconverting", and explicit constructor syntax is required:

 
 
class  A { public :          explicit  A( int );         }; void  f(A) {} void  g() {         A a1  =  A( 37 );         A a2  =  A( 47 );         A a3( 57 );         a1  =  A( 67 );         f(A( 77 )); }

Note that an expression such as:

        A(47)

is closely related to function-style casts supported by C++. For example:

        double d = 12.34;

        int i = int(d);


 

 

 

 

 

 

explicit,和构造函数一起使用.  

 explicit   constructor指明构造函数只能显示使用,目的是为了防止不必要的隐式转化.  

  举个例子:  

      有这样一段代码:  

   

  class   A  

  {  

        public:  

            A(int);  

        private:  

            int   num;  

  };  

   

  int   Test(const   A&)   //   一个应用函数  

  {  

        ...  

  }  

   

  Test(2);   //   正确  

  过程是这样的:   编译器知道传的值是int而函数需要的是A类型,但它也同时知道调用A的构造函数将int转换成一个合适的A,所以才有上面成功的调用.换句话说,编译器处理这个调用时的情形类似下面这样:  

      const   A   temp(2);             //   从2产生一个临时A对象  

      Test(temp);           //   调用函数  

   

   

  如果代码写成如下样子:  

  class   A  

  {  

        public:  

         explicit   A(int);  

        private:  

            int   num;  

  };  

   

  int   Test(const   A&)   //   一个应用函数  

  {  

        ...  

  }  

   

  Test(2);   //   失败,不能通过隐式类型转换将int类型变量构造成成A类型变量 

禁止單參數的構造函數隐式转化為參數類型!

explicit  

  C++   Specific    

   

  This   keyword   is   a   declaration   specifier   that   can   only   be   applied   to   in-class   constructor   declarations.   Constructors   declared  explicit   will   not   be   considered   for   implicit   conversions.   For   example:  

  这是一个指定用于类构造函数处声明的一个关键字。在类外部进行构造类中的构造函数,不支持隐式的转换,例如:  

  class   X   {  

  public:  

        explicit   X(int);             //legal(合法)  

        explicit   X(double)   {       //legal(合法)  

              //   ...  

        }  

  };  

   

 explicit   X::X(int)   {}             //illegal(非法)  

   

  An   explicit   constructor   cannot   take   part   in   implicit   conversions.   It   can   only   be   used   to  explicitly   construct   an   object.   For   example,   with   the   class   declared   above:  

  外部的构造器不能参与部分的隐式转换,只能明确的构造一个对象,例如,用上面的例子:  

   

  void   f(X)   {}  

  void   g(int   I)   {  

        f(I);             //   will   cause   error(将会引起错误)  

  }  

  void   h()   {  

        X   x1(1);             //   legal(合法)  

  }  

   

  The   function   call   f(I)   fails   because   there   is   no   available   implicit   conversion   from   int   to   X.  

  g()函数中,调用f(I)出错的原因:“没有一个可用的隐式转换可从int到X类型。”  

   

  Note       It   is   meaningless   to   apply  explicit   to   constructors   with   multiple   arguments,   since   such   constructors   cannot   take   part   in   implicit   conversions.  

  注释:多参数的构造器直接应用explicit关键字是无意义的,应用了explicit后,构造器不能进行部分的隐式转换.  

  END   C++   Specific  

explicit:   禁止隐式类型转换操作  

   

   

 explicit 它与   virtual、inline   合称为“函数限定符”。它只适用于构造函数。若一个类拥有只带一个参数的构造函数,则可以使用   MyClass   object(x)   或   MyClass   object   =   x  

  来初始化对象,这实际是进行了从参数类型到类类型的转换。若在在构造函数前加上限定符  

 explicit   ,将不再允许这种转换,即不允许   MyClass   object   =   x   这种形式。

转载于:https://www.cnblogs.com/zhiweiyouzhishenghuo/archive/2012/05/27/5005534.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值