认识 C++ 中的explicit 关键字

带单一参数的构造函数在缺省情况下隐含一个转换操作符，请看下面的代码：

1. class MyClass{
2. public:
3.      MyClass(int nParam);// 带一个参数的构造函数
4. private:
5.      int m_nData;
6. }
7. void fun(){
8.      MyClass c(0);
9.      c =5; // 将5隐式转换为MyClass对象
10. }

编译器重新编辑上述例子代码，如下： 
/
//"c=5;" 被编译器转换成下面这个样子：
/
MyClass temp(5);// 实例化一个临时对象,
c = temp; // 用 = 赋值
temp.MyClass::~MyClass(); // temp 的析构函数被激活
在很多情况下，这个转换是有意的，并且是正当的。但有时我们不希望进行这种自动的转换，例如：

1. class String {
2.    int size;
3.    char *p;
4. public:
5.    String (int sz); //这里不希望进行隐式转换操作
6. };
7. void f ()
8. {
9.    String s(10);
10.     // 下面是一个程序员的编码；发生一个意想不到的转换：
11.     s = 100; // 糟糕，100 被转换为一个 String，然后被赋值给 s
12. } 

为了避免这样的隐式转换，应该象下面这样显式声明该带单一参数的构造函数：

1. class String {
2.   int size;
3.   char *p;
4. //..
5. public:
6. // 不要隐式转换
7.   explicit String (int sz); 
8.   String (const char *s, int size n = 0); // 隐式转换
9. };
10. void f ()
11. {
12.     String s(10);
13.     s = 100; // 现在编译时出错；需要显式转换：
14.     s = String(100); // 好；显式转换
15.     s = "st"; // 好；此时允许隐式转换
16. }