C ++暗黙の型変換

https://www.cnblogs.com/solidblog/p/3381628.htmlより転載

暗黙的な変換とは何ですか？

これは、ウェルC ++の基本的なタイプが知られているデータの部分は暗黙の型変換を行うことができる間、反対に完全ではありません。

いわゆる暗黙の変換は、それがプライベートでユーザーの介入、コンパイラ型変換動作を必要としないです。何度もユーザーがコンバージョンを作ったのか分からないかもしれません。

 なぜ、暗黙的な変換？

C ++オブジェクト指向のマルチステートプロパティは、親クラスのサブクラスには、パッケージの種類によって達成されます。

暗黙的な変換することで、あなたは直接オブジェクトスーパークラスのサブクラスの戻り値の型を使用することができます。

例えば、数値やブール型変換、整数など浮動小数点変換。

いくつかの点で、C ++アプリケーション開発者への暗黙的な変換には、小さな利便性をもたらすありません。

C ++は、検査の種類は非常に厳格で、強く型付けされた言語です。

不便の多くをもたらすために、アプリケーション開発者を与える暗黙の型変換、のないタイプが存在しない場合。

もちろん、すべてが二つの側面、あなたが便利に楽しむ片側を持って、あなたはあまりにもスマート、あるいは完全にあなたのコントロールの外に直面しています。

リスクは、無意識のうちに登場しました。

 Cの原理暗黙的な変換++

• 変換のための基礎としての基本的な範囲へのデータタイプ基本データ型（精度が失われないことを確認するため）。
  >大転換-暗黙的な変換は、小型で行われます。例えば、intへチャーからの変換。
  INT-「長いから。
•  カスタムオブジェクトのサブクラスのオブジェクトは、暗黙的に親クラスのオブジェクトに変換します。

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

      - 「高精度の変換低精度：＃暗黙の変換は、上記の4つのケースでは、基本原理を満たします。

      この原則を満たしていない、暗黙の型変換が起きていません。

      もちろん、今回は以下の方法使って、（キャストとして知られている）に対して、明示的な型変換を使用することができます
       ;ダブル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作为初始化值        //… }

  2つの正規表現の比較：
  文字列S2（10）; // OK空の文字列の10のバイトを割り当てる
  ストリングS3 =文字列（10）; // OK 空の文字列に割り当てられた10バイト
  
  に書き込まれた両者のを比較疑問：
  ストリングS4 = 10; //コンパイラ、10バイトが割り当てられ、空の文字列
  の文字列S5 = ''; //コンパイラ、INTを分配する（ 'A'）バイト空の文字列
  int型のS4及びS5それぞれ、及びチャー、暗黙的に誤解を招く、空の文字列を割り当てられたバイト数に変換されます。
  リファレンス＃：http://blog.csdn.net/smilelance/article/details/1528737
•  例2
  以下の例：
  

  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; }

  次のように呼ばれる：
  （10）試験A;
  真ステートメント返す// IF（a.isSame（10））
  
  、本来2つのテストオブジェクト、およびint型にも等しくを比較するために使用します。
  これは、暗黙的な変換が起こるによるもので、実際の比較は、一時的な検査対象です。
  このプログラムは絶対に許されません。

暗黙的な変換を禁止

そんなに暗黙的な変換のリスクがあるため、どのようにそれはそれの暗黙的な変換を禁止発生する可能性があります。

暗黙的な変換を禁止することができ、キーワードの明示的なコンストラクタの宣言と組み合わせるとC​​ ++は、明示的なキーワードを提供します。次のように使用します。

1 2 3 4 5 6

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

 

プラスのキーワード後で、操作としては有効です。

1

Test(10);

操作後には違法次のようになります。

1	Test aa = 10;

これは事実上、それによってオブジェクトの品質を向上させるために、プログラムの正確な制御を可能にする、暗黙的な変換を防止することができます。

 

 

クラスの暗黙の型変換

 

「C ++  プライマー」は、言及されています。

「個々のコンストラクタ呼び出しのパラメータのクラス型への型パラメータから暗黙の型変換を定義します。」

ことに留意すべきである「とは、単一のパラメータを指定して呼び出すことができ、」唯一のコンストラクタのパラメータを意味するものではありませんが、それは、複数の仮パラメータを持つことができますが、それらはすべてのデフォルトパラメータ引数です。

だから、「暗黙の型変換は、」何を意味するのですか？この文の上にも、それが自動的にコンパイラのクラス型にコンストラクタのパラメータの型から変換された、と述べました。

さんがして、コードを見てみましょう：

#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只能用于类内部构造函数的声明。它虽然能避免隐式类型转换带来的问题，但需要用户能够显式创建临时对象（对用户提出了要求）。