Cでの明示的なキーワードを使用します++

比較的浅い、より明確に入れて、それをメモしておくために、明示的なキーワードを参照して読みます。

C ++では、我々は時々、自動型変換関数のコンストラクタとして使用することができます。この自動機能を閉じるために、C ++の新しいキーワードは、明示的なので、しかし、この自動機能は常に望ましいことではない、時には予想外の型変換につながります。すなわち修飾キーワード明示的なクラスのコンストラクタを自動的に暗黙的型変換、明示的な型変換することができません。

コンストラクタまたはNパラメータでのみコンストラクタパラメータが、N-1個のパラメータはデフォルト値を提供し、そのような場合は、キャストすることができる。注意してください。

以下のコードによって（明示的なケースなし）特定のアプリケーションを示しています。

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

4つのコンストラクタ上：

1引数のコンストラクタをキャストすることはできません！

2コンストラクタパラメータ型変換のような、実行されてもよいた：デモ試験;テスト= 12.2;そのような呼び出しは、入力に暗黙的に変換12.2デモと等価です。

3コンストラクタは、2つのパラメータがあり、デフォルト値は、それが型変換を使用することはできません！

4コンストラクタは、3つのパラメータを有し、2つのパラメータはデフォルト値を有し、それはのような暗黙的な変換であってもよい：デモテスト;テスト= 10 ;.

以下は、明示的なキーワードを使用した場合について説明します。

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

上記第二のコンストラクタにおいて、明示的なキーワードので、暗黙的な変換は不可能です。すなわち：デモテスト;テスト= 12.2;無効です！しかし、我々は、次のような変換の種類を表示することができます。

デモテスト;

テスト=デモ（12.2）;または

テスト=（デモ）12.2。

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

これは、ウェル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と、

使用キャストは、精度の損失につながるので、あなたが使用中に十分な把握を持っていることを確認してくださいすることができます。

リスク暗黙的な変換

リスク暗黙的な変換は、クラスコンストラクタが定義されたからで存在します。

既定の規則によって、唯一のコンストラクタパラメータは、クラスオブジェクトにデータ型コンストラクタデータに対応する、暗黙的な変換を定義します。

一例
を以下に示すとおり

class String

{

public:

String ( const char* p ); // 用C风格的字符串p作为初始化值

//…

}

String s1 = “hello”; //OK 隐式转换，等价于String s1 = String（”hello”）

次のようにしかし、時には、あなたは、この暗黙の型変換を必要としない場合があります。

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
以下の例：

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 ++は、明示的なキーワードを提供します。次のように使用します。

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类构造函数就不能用于隐式地创造对象了，编译上面的代码会出现这样的提示：

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

总结一下：

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