我们都知道,可以把一个对象赋值给一个类型与之相同的变量。
编译器将生成必要的代码把“源”对象各属性的值分别赋值给“目标”对象的对应成员。这种赋值行为称之为逐位赋值(bitwise copy)
这种行为在绝大多数场合都没有问题,但如果某些成员变量是指针的话,问题就来了:对象成员进行逐位复制的结果是你将拥有两个一模一样的实例,而这两个副本里的同名指针会指向相同的地址。
于是乎,当删除其中一个对象时,它包含的指针也将被删除,但万一此时另一个副本(对象)还在引用这个指针,就是出问题!
可是有人就会问:“如果我在第二个副本同时也删除指针,不就行了吗?”
姑且认为这样做逻辑上没有问题,但从实际情况上来看是不可能的,因为你想啊,我们的CPU本身就是逐条指令执行的,那么就总会有个先后顺序。当试图第二次释放同一块内存,就肯对会导致程序崩溃。
解决办法
就是在进行对象“复制”的时候能够精确地表明应该复制些什么和如何复制就行了
分析下面几行代码:
MyClass obj1;
MyClass obj2;
obj2 = obj1;
前两行代码很建明,它们创建出了两个MyClass类的实例obj1和obj2.第三行代码把obj1的值赋给了obj2,这里就可能会埋下祸根。因为指针。
那么,怎样才能截获这个赋值操作并告诉它应该如何处理那些指针呢?
答案就是对操作符进行重载!
我们知道几乎所有的C++操作符都可以重载,而赋值操作符“=”就可以。
我们将重载“=”操作符,在其中对指针进行处理:
MyClass &operator=(const MyClass &rhs)
上边的语句告诉我们,这个方法所预期的输入参数应该是一个MyClass类型的,不可改变的引用。
因为这里使用的参数是一个引用,所以编译器在传递输入参数时就不会再为它创建另外一个副本(否则可能导致无线递归)
又因为这里只需要读取这个输入参数,而不用改变它的值,所以我们用const把这个引用声明为一个常量确保万无一失。
返回一个引用,该引用指向一个MyClass类的对象。如果看过我们待会的源码,可能会发觉这个没有必要,但是,这样确实是一个好习惯,另外的好处就是方便我们把一组赋值语句串联起来,如a = b = c;
#include <iostream>
#include <string>
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;
}
else
{
std::cout << "赋值号两边为同个对象,不作处理!" << std::endl;
}
return *this;
}
void MyClass::print()
{
std::cout << *ptr << std::endl;
}
int main()
{
MyClass obj1(new int(1));
MyClass obj2(new int(2));
obj1.print();
obj2.print();
obj2 = obj1;
obj1.print();
obj2.print();
return 0;
}
输出结果
还没完
只对赋值操作符进行重载还不能完美地解决问题,改写下测试代码:
MyClass obj1;
MyClass obj2 = obj1;
这与刚才那个三行的区别很细微,刚才是先创建两个对象,然后再把obj1赋值给obj2.
现在是先创建一个实例obj1,然后再创建实例obj2的同时用obj1的值对它进行初始化。
虽然看起来好像一样,但编译器却生成完全不同的代码:编译器将在MyClass类里寻找一个副本构造器(copy constructor),如果找不到,它会自行创建一个。
即使我们对赋值操作符进行了重载,由编译器创建的副本构造器扔以“逐位复制”方式把obj1赋值给obj2。
换句话说,如果遇到上面这样的代码,即时已经在这个类里重载了赋值操作符,暗藏着隐患的“逐位复制”行为还是会发生。
想要躲开这个隐患,还需要亲自定义个副本构造器,而不是让系统帮我们生成。
MyClass(const MyClass &rhs);
这个构造器需要一个固定不变(const)的MyClass类型的引用作为输入参数,就像赋值操作符那样,因为它是一个构造器,所以不需要返回类型。
#include <iostream>
#include <string>
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)
{
std::cout << "进入主构造器" << std::endl;
ptr = p;
std::cout << "离开主构造器" << std::endl;
}
MyClass::MyClass(const MyClass &rhs)
{
std::cout << "进入副本构造器" << std::endl;
*this = rhs;
std::cout << "离开副本构造器" << std::endl;
}
MyClass::~MyClass()
{
std::cout << "进入析构器" << std::endl;
delete ptr;
std::cout << "离开析构器" << std::endl;
}
MyClass &MyClass::operator=(const MyClass &rhs)
{
std::cout << "进入赋值语句重载" << std::endl;
if (this != &rhs)
{
delete ptr;
ptr = new int;
*ptr = *rhs.ptr;
}
else
{
std::cout << "赋值号两边为同个对象,不作处理!" << std::endl;
}
std::cout << "离开赋值语句重载" << std::endl;
return *this;
}
void MyClass::print()
{
std::cout << *ptr << std::endl;
}
int main()
{
MyClass obj1(new int(1));
MyClass obj2(new int(2));
obj2 = obj1;
obj1.print();
obj2.print();
std::cout << "---------------------------------" << std::endl;
MyClass obj3(new int(3));
MyClass obj4 = obj3;
obj3.print();
obj4.print();
std::cout << "---------------------------------" << std::endl;
MyClass obj5(new int(5));
obj5 = obj5;
obj5.print();
return 0;
}
慢慢理解