一、概念：
---之前讲过,我们可以把一个对象赋值给一个类型与之相同的变量。
---编译器将生成必要的代码把“源”对象各属性的值分别赋值给“目标”对象的对应成员。这种赋值行为称之为逐位赋值（bitwise copy）。
---这种行为在绝大多数数场合都没有问题，但如果某些成员变量时指针的话，那么问题来了：对象成员进行逐位复制的结果是你将拥有两个一模一样的实例，而这两个副本里的同名指针会指向相同的地址。
1.1 出现问题
----于是乎，当删除其中一个对象时，它包含的指针也将被删除，但万一此时另一个副本(对象)还在引用这个指针，就会出问题。空指针
----那聪明的程序员们这时候可能会说“如果我在第二个副本同事也删除指针，不就行了吗？”
----我们姑且认为这样做的逻辑上没有问题。但从实际上情况看是不可能的。因为你想啊，我们的CPU本身就是逐条指令执行的，那么就总会有个先慢的顺序。当试图第二次释放同一块内存，就肯定会导致程序崩溃。
1.2 如何解决这个问题呢？
---在遇到问题的时候，人总是会想要是当初怎怎怎，现在就能咋咋咋滴了。。。。。这听起来像是在后悔说的话，但对于编程来说，绝对是有后悔药的。
---要是程序员在当初进行对象“复制”时能够精确地表明应该复制些什么和如何赋值，那就理想了。
----C++语言的发明者早就预料到这个问题，并提出了一个解决方案，虽然方案有点曲折复杂，但是你不用担心，我们会适当放慢脚步带着你前进的，。。。。开始吧
分析下面几行代码：
MyClass obj1；
MyClass obj2；
obj2 = obj1；前两行代码很简单明了，他们创建除了两个MyClass类的实例obj1和obj2。第三行代码把obj1的值赋值给obj2，这里就可能埋下祸根了。祸根就是MyClass中可能有指针，导致我们上面讨论的问题出现。
那么，怎样才能截获这个赋值操作并告诉它应该如何处理那些埋下祸根的指针呢？
1.3 重载赋值操作符
-----答案就是对操作符进行重载！没错，提供重载机制，事实上就是提供给我们后悔药(+红)！
------我们知道几乎所有的C++操作符都可以重载，而赋值操作符"="恰好是几乎所有“中的一个”‘
------我们将重载“=”操作符，在其中对指针进行处理：
---MyClass &operator = （const MyClass &rhs）；
--------上面的语句告诉我们这个方法所预期的输入参数应该是一个MyClass类型的，不可改变的引用。
--------因为这里使用的参数是一个引用，所以编译器在传递输入参数时就不会再为它创建另外一个副本（否则可能导致无限递归）。
--------又因为这里只需要读取这个输入参数，而不用改变它的值，所以我们用const把那个引用声明为一个常量确保万无一失。
--------返回一个引用，该引用指向一个MyClass类的对象。如果看过我们待会实现的源码，可能会发觉这个没有必要。但是，这样确实是一个好习惯！另外的好处是方便我们把一组赋值语句串联起来，如a=b=c
#include <iostream>
#include <string>
using namespace std;
class MyClass
{
public:
MyClass(int *p);
~MyClass();
MyClass &operator = (const MyClass &rhs); //重载赋值符
void print();
private:
int *ptr;
};
MyClass::MyClass(int *p)
{
ptr = p;
}
MyClass::~MyClass()
{
delete ptr;
}
MyClass &MyClass::operator = (const MyClass &rhs)
{
if(this != &rhs)
{
delete ptr;
ptr = new int;
*ptr = *rhs.ptr;
cout << "赋值号两边为不同对象,做处理!\n";
}
else
{
cout << "赋值号两边为同个对象,不做处理!\n";
}
return *this;
}
void MyClass::print()
{
cout << *ptr << endl;
}
int main()
{
MyClass obj1(new int(1));
MyClass obj2(new int(2));
obj1.print();
obj2.print();
obj1 = obj1;/*没起作用*/
obj1.print();
obj2.print();
obj2 = obj1;/*起作用*/
obj1.print();
obj2.print();
return 0;
}运行结果
1
2
赋值号两边为同个对象,不做处理!
1
2
赋值号两边为不同对象,做处理!
1
1
这个代码是有问题的，今天的主菜还没有上呢？
但是，只对赋值符进行重载还不能完美地解决问题，正如刚才所说，C++的发明者把解决方案弄得有点复杂。
有个问题：为啥在VC上能编译，但运行时会程序中止。
以下代码通过构造一个副本构造器
//改下下测试代码：
MyClass obj1;
MyClass obj2=obj1;
这与刚才那三行代码的区别很细微，刚才是先创建两个对象，然后再把obj1赋值给obj2。
现在是先创建一个实例obj1,然后再创建实例Obj2的同时用obj1的值对它进行初始化。
虽然看起来好像一样，但编译器确生成完全不同的代码：编译器将在MyClass类里寻找一个副本构造器(copy constructor)，如果找不到，它会自行创建一个。
换句话说，如果遇到上面这样的代码，即使已经在这个类里面重载了赋值操作符，暗藏着隐患的“逐位复制”行为还是发生的，也就是说这种情况下=操作符的重载仍然没有起作用。
想要躲开这个隐患，还需要亲自定义一个副本构造器，而不是让系统帮我们生成。
---MyClass(const MyClass &rhs)
这个构造器需要一个固定不变(const)的MyClass类型的引用作为输入参数，就想赋值操作符那样。因为他是一个构造器，所以不需要返回类型，还记得吗？
#include <iostream>
#include <string>
using namespace std;
class MyClass
{
public:
MyClass(int *p);
MyClass(const MyClass &rhs); //副本构造器
~MyClass();
MyClass &operator = (const MyClass &rhs); //重载赋值符
void print();
private:
int *ptr;
};
MyClass::MyClass(int *p)+
{
cout << "进入主构造器\n";
ptr = p;
cout << "离开主构造器\n";
}
MyClass::MyClass(const MyClass &rhs)
{
cout << "进入副本构造器\n";
*this = rhs; //这里的赋值已经是重载之后的赋值符
cout << "离开副本构造器\n";
}
MyClass::~MyClass()
{
cout << "进入析构器\n";
delete ptr;
cout << "离开析构器\n";
}
MyClass &MyClass::operator = (const MyClass &rhs)
{
cout << "进入赋值语句重载\n";
if(this != &rhs)
{
delete ptr;
ptr = new int;
*ptr = *rhs.ptr;
cout << "赋值号两边为不同对象,做处理!\n";
}
else
{
cout << "赋值号两边为同个对象,不做处理!\n";
}
cout << "离开赋值语句重载\n";
return *this;
}
void MyClass::print()
{
cout << *ptr << endl;
}
int main()
{
MyClass obj1(new int(1));
MyClass obj2(new int(2));
obj2 = obj1;
obj1.print();
obj2.print();
cout << "-----------------------\n";
MyClass obj3(new int(3));
MyClass obj4 = obj3;
obj3.print();
obj4.print();
cout << "-----------------------\n";
MyClass obj5(new int(5));
obj5 = obj5;
obj5.print();
return 0;
}运行结果：
进入主构造器
离开主构造器
进入主构造器
离开主构造器
进入赋值语句重载
赋值号两边为不同对象,做处理!
离开赋值语句重载
1
1
-----------------------
进入主构造器
离开主构造器
进入副本构造器
进入赋值语句重载
double free or corruption (out)
已放弃 (核心已转储)解决方法：
#include <iostream>
#include <string>
using namespace std;
class MyClass
{
public:
MyClass(int *p);
MyClass(const MyClass &rhs); //副本构造器
~MyClass();
MyClass &operator = (const MyClass &rhs); //重载赋值符
void print();
private:
int *ptr;
};
MyClass::MyClass(int *p)
{
cout << "进入主构造器\n";
ptr = p;
cout << "离开主构造器\n";
}
MyClass::MyClass(const MyClass &rhs)
{
cout << "进入副本构造器\n";
this->ptr = rhs.ptr; //这里的赋值已经是重载之后的赋值符
cout << "离开副本构造器\n";
}
MyClass::~MyClass()
{
cout << "进入析构器\n";
delete ptr;
cout << "离开析构器\n";
}
MyClass &MyClass::operator = (const MyClass &rhs)
{
cout << "进入赋值语句重载\n";
if(this != &rhs)
{
delete ptr;
ptr = new int;
*ptr = *rhs.ptr;
cout << "赋值号两边为不同对象,做处理!\n";
}
else
{
cout << "赋值号两边为同个对象,不做处理!\n";
}
cout << "离开赋值语句重载\n";
return *this;
}
void MyClass::print()
{
cout << *ptr << endl;
}
int main()
{
MyClass obj1(new int(1));
MyClass obj2(new int(2));
obj2 = obj1;
obj1.print();
obj2.print();
cout << "-----------------------\n";
MyClass obj3(new int(3));
MyClass obj4 = obj3;
obj3.print();
obj4.print();
cout << "-----------------------\n";
MyClass obj5(new int(5));
obj5 = obj5;
obj5.print();
return 0;
}运行结果：
进入主构造器
离开主构造器
进入主构造器
离开主构造器
进入赋值语句重载
赋值号两边为不同对象,做处理!
离开赋值语句重载
1
1
-----------------------
进入主构造器
离开主构造器
进入副本构造器
离开副本构造器
3
3
-----------------------
进入主构造器
离开主构造器
进入赋值语句重载
赋值号两边为同个对象,不做处理!
离开赋值语句重载
5
进入析构器
离开析构器
进入析构器
离开析构器
进入析构器
free(): double free detected in tcache 2
已放弃 (核心已转储)解决方法：
#include <iostream>
#include <string>
using namespace std;
class MyClass
{
public:
MyClass(int *p);
MyClass(const MyClass &rhs); //副本构造器
~MyClass();
MyClass &operator = (const MyClass &rhs); //重载赋值符
void print();
private:
int *ptr;
};
MyClass::MyClass(int *p)
{
cout << "进入主构造器\n";
ptr = p;
cout << "离开主构造器\n";
}
MyClass::MyClass(const MyClass &rhs)
{
cout << "进入副本构造器\n";
//this->ptr = rhs.ptr; //这里的赋值已经是重载之后的赋值符
if(this != &rhs)
{
//delete ptr;
ptr = new int;
*ptr = *rhs.ptr;
cout << "副本构造器 赋值号两边为不同对象,做处理!\n";
}
else
{
cout << "副本构造器 赋值号两边为同个对象,不做处理!\n";
}
cout << "离开副本构造器\n";
}
MyClass::~MyClass()
{
cout << "进入析构器\n";
delete ptr;
cout << "离开析构器\n";
}
MyClass &MyClass::operator = (const MyClass &rhs)
{
cout << "进入赋值语句重载\n";
if(this != &rhs)
{
delete ptr;
ptr = new int;
*ptr = *rhs.ptr;
cout << "赋值号两边为不同对象,做处理!\n";
}
else
{
cout << "赋值号两边为同个对象,不做处理!\n";
}
cout << "离开赋值语句重载\n";
return *this;
}
void MyClass::print()
{
cout << *ptr << endl;
}
int main()
{
MyClass obj1(new int(1));
MyClass obj2(new int(2));
obj2 = obj1;
obj1.print();
obj2.print();
cout << "-----------------------\n";
MyClass obj3(new int(3));
MyClass obj4 = obj3;
obj3.print();
obj4.print();
cout << "-----------------------\n";
MyClass obj5(new int(5));
obj5 = obj5;
obj5.print();
return 0;
}运行结果：
进入主构造器
离开主构造器
进入主构造器
离开主构造器
进入赋值语句重载
赋值号两边为不同对象,做处理!
离开赋值语句重载
1
1
-----------------------
进入主构造器
离开主构造器
进入副本构造器
副本构造器 赋值号两边为不同对象,做处理!
离开副本构造器
3
3
-----------------------
进入主构造器
离开主构造器
进入赋值语句重载
赋值号两边为同个对象,不做处理!
离开赋值语句重载
5
进入析构器
离开析构器
进入析构器
离开析构器
进入析构器
离开析构器
进入析构器
离开析构器
进入析构器
离开析构器精益求精，防止重复delete'
#include <iostream>
#include <string>
using namespace std;
class MyClass
{
public:
MyClass(int *p);
MyClass(const MyClass &rhs); //副本构造器
~MyClass();
MyClass &operator = (const MyClass &rhs); //重载赋值符
void print();
private:
int *ptr;
};
MyClass::MyClass(int *p)
{
cout << "进入主构造器\n";
ptr = p;
cout << "离开主构造器\n";
}
MyClass::MyClass(const MyClass &rhs)
{
cout << "进入副本构造器\n";
//this->ptr = rhs.ptr; //这里的赋值已经是重载之后的赋值符
if(this != &rhs)
{
//if(ptr)
//{
//delete ptr;
//}
ptr = new int;
*ptr = *rhs.ptr;
cout << "副本构造器 赋值号两边为不同对象,做处理!\n";
}
else
{
cout << "副本构造器 赋值号两边为同个对象,不做处理!\n";
}
cout << "离开副本构造器\n";
}
MyClass::~MyClass()
{
cout << "进入析构器\n";
delete ptr;
cout << "离开析构器\n";
}
MyClass &MyClass::operator = (const MyClass &rhs)
{
cout << "进入赋值语句重载\n";
if(this != &rhs)
{
if(ptr)
{
delete ptr;
}
ptr = new int;
*ptr = *rhs.ptr;
cout << "赋值号两边为不同对象,做处理!\n";
}
else
{
cout << "赋值号两边为同个对象,不做处理!\n";
}
cout << "离开赋值语句重载\n";
return *this;
}
void MyClass::print()
{
cout << *ptr << endl;
}
int main()
{
MyClass obj1(new int(1));
MyClass obj2(new int(2));
obj2 = obj1;
obj1.print();
obj2.print();
cout << "-----------------------\n";
MyClass obj3(new int(3));
MyClass obj4 = obj3;
obj3.print();
obj4.print();
cout << "-----------------------\n";
MyClass obj5(new int(5));
obj5 = obj5;
obj5.print();
return 0;
}运行结果：
进入主构造器
离开主构造器
进入主构造器
离开主构造器
进入赋值语句重载
赋值号两边为不同对象,做处理!
离开赋值语句重载
1
1
-----------------------
进入主构造器
离开主构造器
进入副本构造器
副本构造器 赋值号两边为不同对象,做处理!
离开副本构造器
3
3
-----------------------
进入主构造器
离开主构造器
进入赋值语句重载
赋值号两边为同个对象,不做处理!
离开赋值语句重载
5
进入析构器
离开析构器
进入析构器
离开析构器
进入析构器
离开析构器
进入析构器
离开析构器
进入析构器
离开析构器
1206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
