C++ explicit关键字的应用方法详细讲解

最新推荐文章于 2024-07-22 12:18:48 发布
丶Shining
最新推荐文章于 2024-07-22 12:18:48 发布
阅读量448
点赞数
分类专栏：面向对象编程
面向对象编程专栏收录该内容
4 篇文章 0 订阅
订阅专栏
 
 
  
  来源：http://www.jb51.net/article/41526.htm
 
 
 
 
  
  C++编程语言中有很多比较重要的关键字在实际编程中起着非常重要的作用。我们今天为大家介绍的C++ explicit关键字就是其中一个应用比较频繁的关键字。下面就让我们一起来看看这方面的知识吧。
  
  C++ explicit关键字用来修饰类的构造函数，表明该构造函数是显式的，既然有"显式"那么必然就有"隐式"，那么什么是显示而什么又是隐式的呢？
  
  如果c++类的构造函数有一个参数，那么在编译的时候就会有一个缺省的转换操作：将该构造函数对应数据类型的数据转换为该类对象，如下面所示：
  
  
   
   代码如下:
  
  
  
  
   
   
class MyClass
{
public:
 MyClass(int num)
 {
  number=num;
 }
   
   
   
   private:
 int number;
};
//.
MyClass obj=10; //ok, convert int to MyClass

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

  
  
   
   代码如下:
  
  
  
  
   
   
MyClass temp(10); 
MyClass obj = temp;

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

  
  
   
   代码如下:
  
  
  
  
   
   
class MyClass
  {  public: 

  
  
  
  

  
  
   
   代码如下:
  
  
  
  
   
   
          explicit MyClass( int num ); 
  }  

  
  
  
  

  
  
   
   代码如下:
  
  
  
  
   
   
//.  
MyClass obj = 10;
 //err,can't non-explict convert 

  
  
  
  

  
  
  
  按照默认规定，只有一个参数的构造函数也定义了一个隐式转换，将该构造函数对应数据类型的数据转换为该类对象，如下面所示：

  
  
   
   代码如下:
  
  
  
  
   
   
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关键字用来修饰类的构造函数，表明构造函数是显示的，相对的是implicit关键字。
首先这个关键字只能用在类内部的构造函数声明上，而不能用在类外部的函数定义上，它的作用是不能进行隐式转换。

  
  
   
   代码如下:
  
  
  
  
   
   
    class gxgExplicit  //没有关键字explicit的类
    {
      public:
          int _size;
         gxgExplicit(int size)
        {
           _size = size;
        }
     };

  
  
  
  

  
  下面是调用
  
  

  
     gxgExplicit gE1(24);     //这样是没有问题的
  
  

  
     gxgExplicit gE2 = 1;     //这样也是没有问题的
  
  

  
     gxgExplicit gE3;         //这样是不行的，没有默认构造函数
  
  

  
     gE1 = 2;                 //这样也是没有问题的
  
  

  
     gE2 = 3;                 //这样也是没有问题的
  
  

  
     gE2 = gE1;               //这样也是没有问题的
  
  
  
  但是假如gxgExplicit修改为Stack，我们的_size代表的是堆栈的大小，那么调用的第二句就显得不伦不类，而且容易让人疑惑。这并不是可以让代码阅读者明白和接受的形式，虽然它是合法的（编译器可以通过编译）。这是因为编译器默认情况下有隐式转换的功能，你输入gE2 = 1就编译成同第一句相同的结果。所以，explicit就派上了用场。修改代码为：

  
  
   
   代码如下:
  
  
  
  
   
   
class gxgExplicit
    {
      public:
           int _size;
           explicit gxgExplicit(int size)
           {
             _size = size;
           }
    };

  
  
  
  

  
  继续上面的调用:
  
  

  
     gxgExplicit gE1(24);     //这样是没有问题的
  
  

  
     gxgExplicit gE2 = 1;     //这样是不行的，关键字取消了隐式转换
  
  

  
     gxgExplicit gE3;         //这样是不行的，没有默认构造函数
  
  

  
     gE1 = 2;                 //这样是不行的，关键字取消了隐式转换
  
  

  
     gE2 = 3;                 //这样是不行的，关键字取消了隐式转换
  
  

  
     gE2 = gE1;               //这样是不行的，关键字取消了隐式转换，除非类实现操作符“=”的重载。
  
  
  
  这是编译器（vs2005）显示：cannot convert from 'int' to 'gxgExplicit'。
从这里也就看出这个关键字的作用是将编译器隐式转换的功能给屏蔽掉。
MSDN上有一个注意点描述了下面的事实，当构造函数参数超过两个时自动取消隐式转换。例如

  
  
   
   代码如下:
  
  
  
  
   
   
    class gxgExplicit
    {
      private:
         int _size;
         int _age;
      public:
          explicit gxgExplicit(int age,int size)
         {
            _age = age;
            _size = size;
         }
     };

  
  
  
  

  
  这是有没有关键字效果是一样的。那就是相当于有这个关键字。
  
  

  
  但是另外一种情况例外：其中只有一个必须输入的参数，其余的为有默认值的参数。
  
  

  
  
   
   代码如下:
  
  
  
  
   
   
class gxgExplicit
{
private:
   int _size;
   int _age;
public:
   explicit gxgExplicit(int age,int size = 0)
   {
      _age = age;
      _size = size;
   }
};
class gxgExplicit
{
private:
   int _size;
   int _age;
int _hight;
public:
   explicit gxgExplicit(int age,int size = 0)
   {
      _age = age;
      _size = size;
      _hight = hight;
   }
};

  
  
  
  

  
  

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