• c++ explicit


    C++ explicit关键字用来修饰类的构造函数,表明该构造函数是显式的,既然有"显式"那么必然就有"隐式",那么什么是显示而什么又是隐式的呢?

    果c++类的构造函数有一个参数,那么在编译的时候就会有一个缺省的转换操作:将该构造函数对应数据类型的数据转换为该类对象,如下面所示:

    1. class MyClass  
    2. {  
    3. public:  
    4. MyClass( int num );  
    5. }  
    6. //.  
    7. MyClass obj = 10; //ok,convert int to MyClass 

    在上面的代码中编译器自动将整型转换为MyClass类对象,实际上等同于下面的操作:

    1. MyClass temp(10);  
    2. MyClass obj = temp

    上面的所有的C++ explicit关键字相关的操作即是所谓的"隐式转换"。

    如果要避免这种自动转换的功能,我们该怎么做呢?嘿嘿这就是关键字explicit的作用了,将类的构造函数声明为"显式",也就是在声明构造函数的时候前面添加上explicit即可,这样就可以防止这种自动的转换操作,如果我们修改上面的MyClass类的构造函数为显式的,那么下面的代码就不能够编译通过了,如下所示:

    1. class MyClass  
    2. {  
    3. public:  
    4. explicit MyClass( int num );  
    5. }  
    6. //.  
    7. MyClass obj = 10; //err,can't non-explict convert 

    以上就是对C++ explicit关键字的相关介绍。

    按照默认规定,只有一个参数的构造函数也定义了一个隐式转换,将该构造函数对应数据类型的数据转换为该类对象,如下面所示:
    class String {
    String ( const char* p ); // 用C风格的字符串p作为初始化值
    //…
    }
    String s1 = “hello”; //OK 隐式转换,等价于String s1 = String(“hello”);
     
    但是有的时候可能会不需要这种隐式转换,如下:
    class String {
           String ( int n ); //本意是预先分配n个字节给字符串
    String ( const char* p ); // 用C风格的字符串p作为初始化值
    //…
    }
     
    下面两种写法比较正常:
    String s2 ( 10 );   //OK 分配10个字节的空字符串
    String s3 = String ( 10 ); //OK 分配10个字节的空字符串
     
    下面两种写法就比较疑惑了:
    String s4 = 10; //编译通过,也是分配10个字节的空字符串
    String s5 = ‘a’; //编译通过,分配int(‘a’)个字节的空字符串
     
    s4 和s5 分别把一个int型和char型,隐式转换成了分配若干字节的空字符串,容易令人误解。
    为了避免这种错误的发生,我们可以声明显示的转换,使用explicit 关键字:
    class String {
           explicit String ( int n ); //本意是预先分配n个字节给字符串
    String ( const char* p ); // 用C风格的字符串p作为初始化值
    //…
    }
    加上explicit就抑制了String ( int n )的隐式转换,
     
    下面两种写法仍然正确:
    String s2 ( 10 );   //OK 分配10个字节的空字符串
    String s3 = String ( 10 ); //OK 分配10个字节的空字符串
     
    下面两种写法就不允许了:
    String s4 = 10; //编译不通过,不允许隐式的转换
    String s5 = ‘a’; //编译不通过,不允许隐式的转换
     
    因此,某些时候,explicit 可以有效得防止构造函数的隐式转换带来的错误或者误解

    ----------------------------------------------------------
    explicit   只对构造函数起作用,用来抑制隐式转换。如:   
      class   A   {   
              A(int   a);   
      };   
      int   Function(A   a);   
        
      当调用   Function(2)   的时候,2   会隐式转换为   A   类型。这种情况常常不是程序员想要的结果,所以,要避免之,就可以这样写:   
        
      class   A   {   
              explicit   A(int   a);   
      };   
      int   Function(A   a);   
        
      这样,当调用   Function(2)   的时候,编译器会给出错误信息(除非   Function   有个以   int   为参数的重载形式),这就避免了在程序员毫不知情的情况下出现错误。

    总结:explicit   只对构造函数起作用,用来抑制隐式转换。

    参考:
    http://blog.csdn.net/smilelance/archive/2007/03/14/1528737.aspx
    http://topic.csdn.net/t/20040509/15/3046021.html
  • 相关阅读:
    网络七层
    微信小程序开发工具 常用快捷键
    BZOJ 1026 windy数 (数位DP)
    BZOJ 1026 windy数 (数位DP)
    CodeForces 55D Beautiful numbers (SPOJ JZPEXT 数位DP)
    CodeForces 55D Beautiful numbers (SPOJ JZPEXT 数位DP)
    HDU 3709 Balanced Number (数位DP)
    HDU 3709 Balanced Number (数位DP)
    UVA 11361 Investigating Div-Sum Property (数位DP)
    UVA 11361 Investigating Div-Sum Property (数位DP)
  • 原文地址:https://www.cnblogs.com/youxin/p/3691601.html
Copyright © 2020-2023  润新知