c++中 explicit关键字的含义和用法

上面的所有的操作即是所谓的"隐式转换".
如果要避免这种自动转换的功能，我们该怎么做呢？嘿嘿这就是关键字explicit的作用了，将类的构造函数声明为"显示"，也就是在声明构造函数的时候 前面添加上explicit即可，这样就可以防止这种自动的转换操作，如果我们修改上面的MyClass类的构造函数为显示的，那么下面的代码就不能够编 译通过了，如下所示：
{
public:
MyClass( int num );
}
....
MyClass obj = 10; //ok，convert int to MyClass
在上面的代码中编译器自动将整型转换为MyClass类对象，实际上等同于下面的操作：
MyClass temp（10）；
MyClass obj = temp；
Sales_item& operator+(const Sales_item &lhs，const Sales_item rhs){if(!lhs.same_isbn(rhs)) throw isbn_mismatch("isbn missmatch"，lhs.book()，rhs.book());Sales_item ret(lhs);ret+rhs;return ret;}
The implicit type conversion of const char * to a string object enables its users to write the following:string s;s = "Hello";The compiler implicitly transforms this intostring s;//pseudo C++ code:s = string ("Hello"); //create a temporary and assign it to sOn the other hand， if you declare this constructor explicit， you have to use explicit type conversion:class string{//...public:explicit string(const char *);};int main(){string s;s = string("Hello"); //explicit conversion now requiredreturn 0;}Extensive amounts of legacy C++ code rely on the implicit conversion of constructors. The C++ Standardizationcommittee was aware of that. In order to not make existing code break， the implicit conversion was retained. However， anew keyword， explicit， was introduced to the languageto enable the programmer to block the implicit conversionwhen it is undesirable. As a rule， a constructor that can be invoked with a single argument needs to be declaredexplicit. When the implicit type conversion is intentional and well behaved， the constructor can be used as animplicit conversion operator.
Sales_item item1，item2，sum;while(cinitem1item2){try{ sun=item1+item2;}catch(const isbn_mismatch &e){ cerre.what()"left isbn is:"e.left"right isbn is:"e.rightendl;}}
class MyClass
{
public:
explicit MyClass( int Class obj = 10; //err，can‘t non-explict convert
class isbn_mismatch:public std::logic_error{public:explicit isbn_missmatch(const std::string &s):std:logic_error(s){}isbn_mismatch(const std::string &s，const std::string &lhs，const std::string &rhs):std::logic_error(s)，left(lhs)，right(rhs){}const std::string left，right;virtual ~isbn_mismatch() throw(){}};
Consider the following:int main(){string s = "hello"; //OK， convert a C-string into a string objectint ns = 0;s = 1; // 1 oops， programmer intended to write ns = 1，}In the expression s= 1;， the programmer simply mistyped the name of the variable ns， typing s instead. Normally，the compiler detects the incompatible types and issues an error message. However， before ruling it out， the compiler firstsearches for a user-defined conversion that allows this expression; indeed， it finds the constructor that takes int.Consequently， the compiler interprets the expression s= 1; as if the programmer had writtens = string(1);You might encounter a similar problem when calling a function that takes a string argument. The following examplecan either be a cryptic coding style or simply a programmer‘s typographical error. However， due to the implicitconversion constructor of class string， it will pass unnoticed:int f(string s);int main(){f(1); // without a an explicit constructor，//this call is expanded into: f ( string(1) );//was that intentional or merely a programmer‘s typo?}‘In order to avoid such implicit conversions， a constructor that takes one argument needs to be declared explicit:class string{//...public:explicit string(int size); // block implicit conversionstring(const char *); //implicit conversion~string();};An explicit constructor does not behave as an implicit conversion operator， which enables the compiler to catch thetypographical error this time:int main(){string s = "hello"; //OK， convert a C-string into a string objectint ns = 0;s = 1; // compile time error ; this time the compiler catches the typo}Why aren‘t all constructors automatically declared explicit? Under some conditions， the automatic type conversion isuseful and well behaved. A good example of this is the third constructor of string:string(const char *);
这个 《ANSI/ISO C++ Professional Programmer‘s Handbook 》是这样说的
explicit ConstructorsA constructor that takes a single argument is， by default， an implicit conversion operator， which converts its argument toan object of its class (see also Chapter 3， "Operator Overloading"). Examine the following concrete example:class string{private:int size;int capacity;char *buff;public:string();string(int size); // constructor and implicit conversion operatorstring(const char *); // constructor and implicit conversion operator~string();};Class string has three constructors: a default constructor， a constructor that takes int， and a constructor thatconstructs a string from const char *. The second constructor is used to create an empty string object with aninitial preallocated buffer at the specified size. However， in the case of class string， the automatic conversion isdubious. Converting an int into a string object doesn‘t make sense， although this is exactly what this constructor does.