C++中explicit关键字的使用

看书看到了explicit关键字，就来做个笔记，讲得比较明白，比较浅。

 

在C++中，我们有时可以将构造函数用作自动类型转换函数。但这种自动特性并非总是合乎要求的，有时会导致意外的类型转换，因此，C++新增了关键字explicit，用于关闭这种自动特性。即被explicit关键字修饰的类构造函数，不能进行自动地隐式类型转换，只能显式地进行类型转换。

注意：只有一个参数的构造函数，或者构造函数有n个参数，但有n-1个参数提供了默认值，这样的情况才能进行类型转换。

下面通过一段代码演示具体应用（无explicit情形）：

 

 1 /* 示例代码1 */
 2 class Demo
 3 {
 4    public:
 5     Demo();    　　　　　　　　　　　　　　   /* 构造函数1 */
 6     Demo(double a);　　　　　　　　　　　　  /* 示例代码2 */
 7     Demo(int a,double b);　　　　　　　　   /* 示例代码3 */
 8     Demo(int a,int b=10,double c=1.6);　　/* 示例代码4 */
 9     ~Demo();
10     void Func(void);
11 
12     private:
13     int value1;
14     int value2;
15 };

 

上述四种构造函数：

构造函数1没有参数，无法进行类型转换！

构造函数2有一个参数，可以进行类型转换，如：Demo test; test = 12.2;这样的调用就相当于把12.2隐式转换为Demo类型。

构造函数3有两个参数，且无默认值，故无法使用类型转换！

构造函数4有3个参数，其中两个参数有默认值，故可以进行隐式转换，如：Demo test;test = 10;  。

 

下面讲述使用了关键字explicit的情况：

 

 1  1 /* 示例代码2 */
 2  2 class Demo
 3  3 {
 4  4    public:
 5  5     Demo();    　　　　　　　　　　　　　　   /* 构造函数1 */
 6  6     explicit Demo(double a);　　　　　　　 /* 示例代码2 */
 7  7     Demo(int a,double b);　　　　　　　　   /* 示例代码3 */
 8  8  
 9  9     ~Demo();
10 10     void Func(void);
11 11 
12 12     private:
13 13     int value1;
14 14     int value2;
15 15 };

 

在上述构造函数2中，由于使用了explicit关键字，则无法进行隐式转换。即：Demo test;test = 12.2;是无效的！但是我们可以进行显示类型转换，如：

Demo test;

test = Demo(12.2); 或者

test = (Demo)12.2;

 

 

 

什么是隐式转换？

众所周知，C++的基本类型中并非完全的对立，部分数据类型之间是可以进行隐式转换的。

所谓隐式转换，是指不需要用户干预，编译器私下进行的类型转换行为。很多时候用户可能都不知道进行了哪些转换。

 为什么要进行隐式转换？

C++面向对象的多态特性，就是通过父类的类型实现对子类的封装。

通过隐式转换，你可以直接将一个子类的对象使用父类的类型进行返回。

在比如，数值和布尔类型的转换，整数和浮点数的转换等。

某些方面来说，隐式转换给C++程序开发者带来了不小的便捷。

C++是一门强类型语言，类型的检查是非常严格的。

如果没有类型的隐式转换，这将给程序开发者带来很多的不便。

当然，凡事都有两面性，在你享受方便快捷的一面时，你不得不面对太过智能以至完全超出了你的控制。

风险就在不知不觉间出现。

 C++隐式转换的原则

• 基本数据类型 基本数据类型的转换以取值范围的作为转换基础（保证精度不丢失）。
  隐式转换发生在从小->大的转换中。比如从char转换为int。
  从int-》long。
•  自定义对象 子类对象可以隐式的转换为父类对象。

C++隐式转换发生条件

• 混合类型的算术运算表达式中。例如：

  1 2 3

  int a = 3; double b = 4.5; a + b; // a将会被自动转换为double类型，转换的结果和b进行加法操作

•  不同类型的赋值操作。例如：

  1 2	int a = true; (bool类型被转换为int类型) int * ptr = null;（null被转换为int*类型）

•  函数参数传值。例如：

  1 2	void func(double a); func(1); // 1被隐式的转换为double类型1.0

•  函数返回值。例如：

  1 2 3 4

  double add(int a, int b) {     return a + b; } //运算的结果会被隐式的转换为double类型返回

      #参考：http://developer.51cto.com/art/201002/183139.htm

      #以上四种情况下的隐式转换，都满足了一个基本原则：低精度 –》 高精度转换。

      不满足该原则，隐式转换是不能发生的。

      当然这个时候就可以使用与之相对于的显式类型转换（又称强制类型转换），使用方法如下：
       double a = 2.0;
       int b = (int)a;

     使用强制类型转换会导致精度的损失，因此使用时务必确保你已经拥有足够的把握。

隐式转换的风险

隐式转换的风险一般存在于自定义的类构造函数中。

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

•  例一
  如下面所示：

  1 2 3 4 5 6 7 8

  class String { public:     String ( const char* p ); // 用C风格的字符串p作为初始化值     //… }   String s1 = “hello”; //OK 隐式转换，等价于String s1 = String（”hello”）

  但是有的时候可能会不需要这种隐式转换，如下：

  1 2 3 4 5 6 7 8

  class String { public:     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型，隐式转换成了分配若干字节的空字符串，容易令人误解。
  #参考：http://blog.youkuaiyun.com/smilelance/article/details/1528737
•  例二
  如下例：

  1 2 3 4 5 6 7 8 9 10 11 12

  class Test { public:   Test(int a);   bool isSame(Test other)   {     return m_val == other.m_val;   }   private：   int m_val; }

  如下调用：
  Test a(10);
  If(a.isSame(10)) //该语句将返回true
  
  本来用于两个Test对象的比较，竟然和int类型相等了。
  这里就是由于发生了隐式转换，实际比较的是一个临时的Test对象。
  这个在程序中是绝对不能允许的。

禁止隐式转换

既然隐式转换存在这么多的风险，那如何能够禁止隐式转换的发生呢。

C++中提供了explicit关键字，在构造函数声明的时候加上explicit关键字，能够禁止隐式转换。使用方法如下：

1 2 3 4 5 6

class Test { explicit Test(int a); ……   }

 

加上该关键字以后，如下的操作是合法的：

1

Test(10);

如下的操作就变成非法的了：

1	Test aa = 10;

这样就可以有效的防止隐式转换的发生，从而能够对程序进行精确控制，达到提高品质的目的。

 

《C++ Primer》中提到：

“可以用 单个形参来调用 的构造函数定义了从 形参类型 到 该类类型 的一个隐式转换。”

这里应该注意的是， “可以用单个形参进行调用” 并不是指构造函数只能有一个形参，而是它可以有多个形参，但那些形参都是有默认实参的。

那么，什么是“隐式转换”呢？ 上面这句话也说了，是从 构造函数形参类型 到 该类类型 的一个编译器的自动转换。

下面通过代码来看一看：

 

#include "stdafx.h"
#include <string>
#include <iostream>
using namespace std ;
class BOOK  //定义了一个书类
{
    private:
        string _bookISBN ;  //书的ISBN号
        float _price ;    //书的价格

    public:
        //定义了一个成员函数，这个函数即是那个“期待一个实参为类类型的函数”
        //这个函数用于比较两本书的ISBN号是否相同
        bool isSameISBN(const BOOK & other ){
            return other._bookISBN==_bookISBN;
                }

        //类的构造函数，即那个“能够用一个参数进行调用的构造函数”（虽然它有两个形参，但其中一个有默认实参，只用一个参数也能进行调用）
        BOOK(string ISBN,float price=0.0f):_bookISBN(ISBN),_price(price){}
};

int main()
{
    BOOK A("A-A-A");
    BOOK B("B-B-B");

    cout<<A.isSameISBN(B)<<endl;   //正经地进行比较，无需发生转换

    cout<<A.isSameISBN(string("A-A-A"))<<endl; //此处即发生一个隐式转换：string类型-->BOOK类型，借助BOOK的构造函数进行转换，以满足isSameISBN函数的参数期待。
    cout<<A.isSameISBN(BOOK("A-A-A"))<<endl;    //显式创建临时对象，也即是编译器干的事情。
    
    system("pause");
}

 

     代码中可以看到，isSameISBN函数是期待一个BOOK类类型形参的，但我们却传递了一个string类型的给它，这不是它想要的啊！还好，BOOK类中有个构造函数，它使用一个string类型实参进行调用，编译器调用了这个构造函数，隐式地将stirng类型转换为BOOK类型（构造了一个BOOK临时对象），再传递给isSameISBN函数。

　　隐式类类型转换还是会带来风险的，正如上面标记，隐式转换得到类的临时变量，完成操作后就消失了，我们构造了一个完成测试后被丢弃的对象。

　　我们可以通过explicit声明来抑制这种转换:

explicit BOOK(string ISBN,float price=0.0f):_bookISBN(ISBN),_price(price){}

    explicit关键字只能用于类内部的构造函数声明上.这样一来，BOOK类构造函数就不能用于隐式地创造对象了，编译上面的代码会出现这样的提示：

  现在用户只能进行显示类型转换，显式地创建临时对象。

 

  总结一下：

1. 　　可以使用一个实参进行调用，不是指构造函数只能有一个形参。
2. 　　隐式类类型转换容易引起错误，除非你有明确理由使用隐式类类型转换，否则，将可以用一个实参进行调用的构造函数都声明为explicit。
3.       explicit只能用于类内部构造函数的声明。它虽然能避免隐式类型转换带来的问题，但需要用户能够显式创建临时对象（对用户提出了要求）。