C++隐式类型转换

- 日理万妓 2021-11-26 13:02 351阅读 0赞

转载自https://www.cnblogs.com/solidblog/p/3381628.html

## 什么是隐式转换？ ##

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

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

##  为什么要进行隐式转换？ ##

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

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

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

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

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

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

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

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

##  C++隐式转换的原则 ##

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

## C++隐式转换发生条件 ##

*  混合类型的算术运算表达式中。例如：  
    
    
    <table> 
     <tbody> 
      <tr> 
       <td> 
        <div>
          1 
        </div> 
        <div>
          2 
        </div> 
        <div>
          3 
        </div> </td> 
       <td> 
        <div> 
         <div> 
          <code>int</code>&nbsp; 
          <code>a = 3;</code> 
         </div> 
         <div> 
          <code>double</code>&nbsp; 
          <code>b = 4.5;</code> 
         </div> 
         <div> 
          <code>a + b;&nbsp;</code> 
          <code>// a将会被自动转换为double类型，转换的结果和b进行加法操作</code> 
         </div> 
        </div> </td> 
      </tr> 
     </tbody> 
    </table>
 *   不同类型的赋值操作。例如：  
    
    
    <table> 
     <tbody> 
      <tr> 
       <td> 
        <div>
          1 
        </div> 
        <div>
          2 
        </div> </td> 
       <td> 
        <div> 
         <div> 
          <code>int</code>&nbsp; 
          <code>a =&nbsp;</code> 
          <code>true</code> 
          <code>; (</code> 
          <code>bool</code> 
          <code>类型被转换为</code> 
          <code>int</code> 
          <code>类型)</code> 
         </div> 
         <div> 
          <code>int</code>&nbsp; 
          <code>* ptr = null;（null被转换为</code> 
          <code>int</code> 
          <code>*类型）</code> 
         </div> 
        </div> </td> 
      </tr> 
     </tbody> 
    </table>
 *   函数参数传值。例如：  
    
    
    <table> 
     <tbody> 
      <tr> 
       <td> 
        <div>
          1 
        </div> 
        <div>
          2 
        </div> </td> 
       <td> 
        <div> 
         <div> 
          <code>void</code>&nbsp; 
          <code>func(</code> 
          <code>double</code>&nbsp; 
          <code>a);</code> 
         </div> 
         <div> 
          <code>func(1);&nbsp;</code> 
          <code>// 1被隐式的转换为double类型1.0</code> 
         </div> 
        </div> </td> 
      </tr> 
     </tbody> 
    </table>
 *   函数返回值。例如：  
    
    
    <table> 
     <tbody> 
      <tr> 
       <td> 
        <div>
          1 
        </div> 
        <div>
          2 
        </div> 
        <div>
          3 
        </div> 
        <div>
          4 
        </div> </td> 
       <td> 
        <div> 
         <div> 
          <code>double</code>&nbsp; 
          <code>add(</code> 
          <code>int</code>&nbsp; 
          <code>a,&nbsp;</code> 
          <code>int</code>&nbsp; 
          <code>b)</code> 
         </div> 
         <div> 
          <code>{ </code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
          <code>return</code>&nbsp; 
          <code>a + b;</code> 
         </div> 
         <div> 
          <code>}&nbsp;</code> 
          <code>//运算的结果会被隐式的转换为double类型返回</code> 
         </div> 
        </div> </td> 
      </tr> 
     </tbody> 
    </table>

\#参考：[http://developer.51cto.com/art/201002/183139.htm][http_developer.51cto.com_art_201002_183139.htm]

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

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

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

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

## 隐式转换的风险 ##

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

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

*   例一  
    如下面所示：  
    
    
    <table> 
     <tbody> 
      <tr> 
       <td> 
        <div>
          1 
        </div> 
        <div>
          2 
        </div> 
        <div>
          3 
        </div> 
        <div>
          4 
        </div> 
        <div>
          5 
        </div> 
        <div>
          6 
        </div> 
        <div>
          7 
        </div> 
        <div>
          8 
        </div> </td> 
       <td> 
        <div> 
         <div> 
          <code>class</code>&nbsp; 
          <code>String</code> 
         </div> 
         <div> 
          <code>{ </code> 
         </div> 
         <div> 
          <code>public</code> 
          <code>:</code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
          <code>String (&nbsp;</code> 
          <code>const</code>&nbsp; 
          <code>char</code> 
          <code>* p );&nbsp;</code> 
          <code>// 用C风格的字符串p作为初始化值</code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
          <code>//…</code> 
         </div> 
         <div> 
          <code>}</code> 
         </div> 
         <div>
           &nbsp; 
         </div> 
         <div> 
          <code>String s1 = “hello”;&nbsp;</code> 
          <code>//OK 隐式转换，等价于String s1 = String（”hello”）</code> 
         </div> 
        </div> </td> 
      </tr> 
     </tbody> 
    </table>
    
    但是有的时候可能会不需要这种隐式转换，如下：  
    
    
    <table> 
     <tbody> 
      <tr> 
       <td> 
        <div>
          1 
        </div> 
        <div>
          2 
        </div> 
        <div>
          3 
        </div> 
        <div>
          4 
        </div> 
        <div>
          5 
        </div> 
        <div>
          6 
        </div> 
        <div>
          7 
        </div> 
        <div>
          8 
        </div> </td> 
       <td> 
        <div> 
         <div> 
          <code>class</code>&nbsp; 
          <code>String</code> 
         </div> 
         <div> 
          <code>{ </code> 
         </div> 
         <div> 
          <code>public</code> 
          <code>:</code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
          <code>String (&nbsp;</code> 
          <code>int</code>&nbsp; 
          <code>n );&nbsp;</code> 
          <code>//本意是预先分配n个字节给字符串</code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
          <code>String (&nbsp;</code> 
          <code>const</code>&nbsp; 
          <code>char</code> 
          <code>* p );&nbsp;</code> 
          <code>// 用C风格的字符串p作为初始化值</code> 
         </div> 
         <div>
           &nbsp; 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
          <code>//…</code> 
         </div> 
         <div> 
          <code>}</code> 
         </div> 
        </div> </td> 
      </tr> 
     </tbody> 
    </table>
    
    下面两种写法比较正常：  
    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.csdn.net/smilelance/article/details/1528737][http_blog.csdn.net_smilelance_article_details_1528737]
 *   例二  
    如下例：  
    
    
    <table> 
     <tbody> 
      <tr> 
       <td> 
        <div>
          1 
        </div> 
        <div>
          2 
        </div> 
        <div>
          3 
        </div> 
        <div>
          4 
        </div> 
        <div>
          5 
        </div> 
        <div>
          6 
        </div> 
        <div>
          7 
        </div> 
        <div>
          8 
        </div> 
        <div>
          9 
        </div> 
        <div>
          10 
        </div> 
        <div>
          11 
        </div> 
        <div>
          12 
        </div> </td> 
       <td> 
        <div> 
         <div> 
          <code>class</code>&nbsp; 
          <code>Test</code> 
         </div> 
         <div> 
          <code>{ </code> 
         </div> 
         <div> 
          <code>public</code> 
          <code>:</code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;</code> 
          <code>Test(</code> 
          <code>int</code>&nbsp; 
          <code>a);</code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;</code> 
          <code>bool</code>&nbsp; 
          <code>isSame(Test other)</code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;</code> 
          <code>{ </code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;&nbsp;&nbsp;</code> 
          <code>return</code>&nbsp; 
          <code>m_val == other.m_val;</code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;</code> 
          <code>}</code> 
         </div> 
         <div>
           &nbsp; 
         </div> 
         <div> 
          <code>private</code> 
          <code>：</code> 
         </div> 
         <div> 
          <code>&nbsp;&nbsp;</code> 
          <code>int</code>&nbsp; 
          <code>m_val;</code> 
         </div> 
         <div> 
          <code>}</code> 
         </div> 
        </div> </td> 
      </tr> 
     </tbody> 
    </table>
    
    如下调用：  
    Test a(10);  
    If(a.isSame(10)) //该语句将返回true  
      
    本来用于两个Test对象的比较，竟然和int类型相等了。  
    这里就是由于发生了隐式转换，实际比较的是一个临时的Test对象。  
    这个在程序中是绝对不能允许的。

## 禁止隐式转换 ##

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

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

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> </td> 
   <td> 
    <div> 
     <div> 
      <code>class</code>&nbsp; 
      <code>Test</code> 
     </div> 
     <div> 
      <code>{ </code> 
     </div> 
     <div> 
      <code>explicit</code>&nbsp; 
      <code>Test(</code> 
      <code>int</code>&nbsp; 
      <code>a);</code> 
     </div> 
     <div> 
      <code>……</code> 
     </div> 
     <div>
       &nbsp; 
     </div> 
     <div> 
      <code>}</code> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

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

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

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

隐式类类型转换

《C++ Primer》中提到：

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

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

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

**下面通过代码来看一看：**

![复制代码][copycode.gif]

#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");
    }

![复制代码][copycode.gif]

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

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

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

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

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

![022139435219592.png][]

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

**  总结一下：**

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

转载于:https://www.cnblogs.com/xwt19970518/p/11069785.html

[http_developer.51cto.com_art_201002_183139.htm]: http://developer.51cto.com/art/201002/183139.htm
[http_blog.csdn.net_smilelance_article_details_1528737]: http://blog.csdn.net/smilelance/article/details/1528737
[copycode.gif]: /images/20211126/b6565c9369214c0592a7a987db348208.png
[022139435219592.png]: /images/20211126/fb4ddd1af4604c6ca2d9f917be1047af.png