explicit关键字的作用

explicit作用:

在C++中，explicit关键字用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能以显示的方式进行类型转换。

explicit使用注意事项:

explicit 关键字只能用于类内部的构造函数声明上。

explicit 关键字作用于单个参数的构造函数。

 在C++中，explicit关键字用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换

先来看下面一道例题：

#include "stdafx.h"  
#include <iostream>  
#include <string>  
#include <vector>  
  
class B  
{  
private:  
    int data;  
public:  
    B()  
    {  
        std::cout<<"default constructor!"<<std::endl;  
    }  
    B(B &)  
    {  
        std::cout<<"copy constructor!"<<std::endl;  
    } 

    ~B()  
    {  
        std::cout<<"destructed!"<<std::endl;  
    }  
    B(int i) : data(i)  
    {  
        std::cout<<"constructed by parameter "<<data<<std::endl;  
    }  
};  
B Play(B b)  
{  
    return b;  
}  
int _tmain(int argc, _TCHAR* argv[])  
{  
    B temp = Play(5); //这里发生了隐式转换；（B）5 
    return 0;  
}  

问题：

（1）该程序输出的结果是什么？为什么会有这样的输出？

（2）B(int i):data(i)，这种用法的专业术语叫什么？

（3）Play(5)，形参类型是类，而5是个常量，这样写合法吗？为什么？【英国著名图形图像公司A2008年面试题】

（1）程序的输出结果为：

  onstructedby parameter 5

copy constructor;//temp=b;

destructor;  //B b;

destructor;  // temp;

 

注：5首先转换成B类型，调用一个有参的构造函数，然后Play返回之后，局部变量b会被析构掉。整个程序返回后，temp会调用析构函数。

为什么只有一个构造函数呢？？？这里又设计到另外一个问题，等会儿在后面接着讲。

（2）带参数的构造函数，冒号后面是成员变量初始化列表（members initialization list）。

（3）合法。单个参数的构造函数如果不添加explicit关键字，会定义一个隐含的类型转换，调用了相应的构造函数。（从参数的类型转换到自己）；添加explicit关键字会消除这种隐含转换。

但是如果添加了explicit关键字来修饰构造函数后：问题3将变得不合法！

如果是 explicit B(int i ):data(i);

那么问题三就变的不合法：必须传：

B play(5); 

没有加之前可以是：B play=B(5);

看下面的实例：

    class A  //没有关键字explicit的类
    {
      public:
          int size;
         A(int _size)
        {
           size = _size;
        }
     };

如果没有explicit：

则

A a1(12);//OK

A a2=12;//OK  A a2=A(12);

A a3;  //error ,没有默认的构造函数；

a1=11;//OK

a2=13;//OK

a2=a1;//OK

BUT

如果加了explicit关键字：

   class A  //有关键字explicit的类
    {
      public:
          int size;
         explicit A(int _size)
        {
           size = _size;
        }
     };

A a1(12);//OK

A a2=12;//error

A a3;  //error ,没有默认的构造函数；

a1=11;//error

a2=13;//error 不 能做相应的隐形的转换；

a2=a1;//error 如果重载了operator=就可以了；

calss Cnum
{
public：
int data;
Cnum(int  i):data(i)
{
	cout<<"constructor"<<endl;
};
 operator int()
{
	return data;
}
int  operator=( Cnum num)
{
	int a;
	a=num.data;
	return a;
}
};
Cnum num;
num=100;

num=100; //先看看有没有operator=，若没有而进行隐式转换类型，在调用相应的构造函数；

int a=num; //运算符重载：

//