构造函数的赋值特例与类型转换问题（explicit）

=====================构造函数的赋值特例=====================

      一般地，我们可以利用构造函数对成员变量进行赋值，比如说下例：

1 2 3 4 5 6 7

class Demo{ public:       Demo (int a,int b){x=a;y=b;} private:       int x;       int y; }

      那么我们在调用该构造函数的时候，就可以直接把参数传进去：

Demo *demo=new Demo(1,2);

      但是，有两个特例，需要我们注意一下：

1. 构造带有const的成员变量
2. 构造带有引用的成员变量

由于const成员或者是引用成员都是不可赋值的，所以我们在利用构造函数操作这些成员的时候，不能进行赋值，只能进行初始化！如下例：

1 2 3 4 5 6 7

class Demo{ public:       Demo (int a,int b):x(a),y(b){} private:       const int x;       int &y; }

 上面这个类的第三行就是用构造函数如何初始化（注意，是初始化！！不是赋值！！）这两种特殊的成员函数的例子。

=====================类型转换问题（explicit）=====================

在C++中，我们可以把一个参数当做对象赋给另外一个对象。但是这种情况仅限于该对象的构造函数中仅仅有一个参数时才有用。这种情况出现的时候，编译器要做的工作如下：

1. 对参数进行类型转换
2. 判断该类的构造函数的参数是否与该参数匹配，假如匹配：
3. 调用构造函数创建一个临时的对象
4. 将该临时对象赋值给左边的对象
5. 调用析构函数删除这个临时对象

现在，我们来看看编译器从第3步到最后一步到底都干了什么......

首先我们定义一个类demo及其带有一个参数的构造函数demo：

class demo

{

public:

      demo(int x){i=x};

private:

      int i;

};

 如果我们在下面程序第二行中写了这样一句话：

1 2	demo de(0);//声明一个对象de de=10;//调用构造函数进行强制类型转换

那么，编译器会重新编辑上例中的“de=10”这行代码：

1 2 3

demo temp(10);//实例化一个临时对象 de=temp;//用“=”把temp对象赋值到de对象中 temp.demo::~demo();//调用temp对象的析构函数，删除这个临时对象

这样一来，我们就可以把10强行赋值给de对象了。下面，我们来看一个实际点的例子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#include <iostream> using namespace std; class A { public:     A(int x){i=x;cout<<"构造函数执行!"<<endl;}     ~A(){cout<<"析构函数执行!"<<endl;}     void get(){cout<<i<<endl;} private:     int i; }; int main() {     A a(99);     a.get();       a=1000;     a.get();                cout<<endl;     a=A(2);                 a.get();                return 0; }

该程序的输出为：

      我们可以看到输出窗口里面绿色的那一栏，即程序的第14行，声明了一个对象啊，并调用构造函数，所以输出“构造函数执行”。之后在程序的第17行我们强制把1000赋给对象a，那么编译器就可以自动调用临时对象来把这个值赋给对象a，同时赋值完成之后再删除这个对象，所以可以看到“构造函数执行”+“析构函数执行”（上图红色框），这两句话是因为临时对象的创建和销毁所致地。后面的同样输出了这两句话得原因是因为了程序第20行的作用，强行赋值到a，所以输出了如上图蓝色框中的提示。最后，在程序结束的时候，调用析构函数销毁了对象a。

      像上面这样做的好处就是可以快速地对一个对象进行赋值，但是值得注意的是，这样的转换又是可能会导致一些意外。因此我们需要使用关键字explicit来关闭这种特性，explicit可以用在构造函数中：

explicit A(int x){};

如果声明了这个关键字，上面这个程序就无法执行了，程序会在第17行报出输出错误：
“二进制“=”: 没有找到接受“int”类型的右操作数的运算符(或没有可接受的转换)”

补充：

explicit作用:

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

explicit使用注意事项:

    *

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

    *

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

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

例子：

未加explicit时的隐式类型转换

   1. class Circle  
   2. {  
   3. public:  
   4.     Circle(double r) : R(r) {}  
   5.     Circle(int x, int y = 0) : X(x), Y(y) {}  
   6.     Circle(const Circle& c) : R(c.R), X(c.X), Y(c.Y) {}  
   7. private:  
   8.     double R;  
   9.     int    X;  
  10.     int    Y;  
  11. };  
  12.   
  13. int _tmain(int argc, _TCHAR* argv[])  
  14. {  
  15. //发生隐式类型转换  
  16. //编译器会将它变成如下代码  
  17. //tmp = Circle(1.23)  
  18. //Circle A(tmp);  
  19. //tmp.~Circle();  
  20.     Circle A = 1.23;   
  21. //注意是int型的，调用的是Circle(int x, int y = 0)  
  22. //它虽然有2个参数，但后一个有默认值，任然能发生隐式转换  
  23.     Circle B = 123;  
  24. //这个算隐式调用了拷贝构造函数  
  25.     Circle C = A;  
  26.       
  27.     return 0;  
  28. } 

加了explicit关键字后，可防止以上隐式类型转换发生

   1. class Circle  
   2. {  
   3. public:  
   4.     explicit Circle(double r) : R(r) {}  
   5.     explicit Circle(int x, int y = 0) : X(x), Y(y) {}  
   6.     explicit Circle(const Circle& c) : R(c.R), X(c.X), Y(c.Y) {}  
   7. private:  
   8.     double R;  
   9.     int    X;  
  10.     int    Y;  
  11. };  
  12.   
  13. int _tmain(int argc, _TCHAR* argv[])  
  14. {  
  15. //一下3句，都会报错  
  16.     //Circle A = 1.23;   
  17.     //Circle B = 123;  
  18.     //Circle C = A;  
  19.       
  20. //只能用显示的方式调用了  
  21. //未给拷贝构造函数加explicit之前可以这样  
  22.          Circle A = Circle(1.23);  
  23.         Circle B = Circle(123);  
  24.         Circle C = A;  
  25.   
  26. //给拷贝构造函数加了explicit后只能这样了  
  27.          Circle A(1.23);  
  28.         Circle B(123);  
  29.         Circle C(A);  
  30.     return 0;  
  31. }