🌈个人主页：羽晨同学 

💫个人格言:“成为自己未来的主人~”  

首先，我们先来看一段正常的构造和拷贝构造的代码：

#include<iostream>
using namespace std;
class A
{
public://单参数构造函数//explicit A(int a)A(int a):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}
private:int _a;int _a1;int _a2;
};
int main()
{A aa1(1);A aa2 = aa1;//A aa1 = 3;return 0;
}

在这段代码当中，我们用到了拷贝构造和构造。

大家再来看下面的一段代码：

#include<iostream>
using namespace std;
class A
{
public://单参数构造函数//explicit A(int a)A(int a):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}
private:int _a;int _a1;int _a2;
};
int main()
{//A aa1(1);//A aa2 = aa1;A aa1 = 3;return 0;
}

这段代码，将3直接给了aa1，但是代码并不会进行报错，这是为什么呢？

 

在这个其中，涉及到了一个很重要的知识点，叫做隐式类型转换。

什么意思呢？就是3构造了一个A类型的临时变量，然后a类型的临时变量进行拷贝构造，给了aa1

所以，在这个过程中涉及到了两步，第一步是默认构造，第二步是拷贝构造，但是这种连续构造编译器会进行优化，所以显示出来的结果为直接构造

明白了这个道理之后，我们再来看下面的这个代码：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class A
{
public://单参数构造函数//explicit A(int a)A(int a):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}
private:int _a;int _a1;int _a2;
};
int main()
{//A aa1(1);//A aa2 = aa1;//A aa1 = 3;A& raa = 3;return 0;
}

这个代码会进行报错，这是为什么呢？

 

原因就是这个的raa是3类型转换之后产生的临时变量的别名，但是临时变量具有常性，不能进行修改。所以，为了保证权限不被放大，我们应该在前面加一个const来进行修饰。

	const A& raa = 3;

上面我们讲的是单参数构造的情况，那么多参数构造的情况呢？

我们来看下面的这部分代码：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class A
{
public://单参数构造函数//explicit A(int a)//A(int a)//	:_a(a)//{//	cout << "A(int a)" << endl;//}//A(const A& aa)//	:_a(aa._a)//{//	cout << "A(const A& aa)" << endl;//}A(int a1, int a2):_a(0),_a1(a1),_a2(a2){}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}
private:int _a;int _a1;int _a2;
};
int main()
{//A aa1(1);//A aa2 = aa1;//A aa1 = 3;//const A& raa = 3;A aaa1(1, 2);A aaa2 = aaa1;const A& aaa3 = { 1,2 };return 0;
}

上面的这个就是多参数构造部分的代码，我们可以看到的是，和单参数构造是差别不大的。

好了，本期的文章就到这里，我们下一期再见。