C++ 之 重载赋值操作符

Widget 中,有一个 Bitmap 型指针  pb

class Bitmap;

class Widget {
private:
Bitmap *pb; // ptr to a heap-allocated object
};

1  重载 “op=” 

在 Widget 类中重载 "=" 时,需考虑以下方面

1.1  链式赋值

整数 15 首先赋值给 z,得到新值的 z 再赋值给 y,接着得到新值的 y 最后再赋值给 x,如下所示:

int x, y, z;

x = y = z = ; // chain of assignments

相当于

x = (y = (z = ));

为了实现链式赋值,函数的返回值须是一个实例自身的引用,也即 *this; 同理,重载其它的复合赋值运算符 (如 +=, -=, *=, /=),也必须在函数结束前返回 *this

Widget& Widget::operator=(const Widget& rhs)
{
delete pb; // stop using current bitmap pb = new Bitmap(*rhs.pb); // start using a copy of rhs's bitmap return *this;
}

1.2  自赋值

其次要考虑的是,关于自赋值的情况,虽然显式的自赋值并不常见,但潜在的隐式自赋值仍需注意

Widget  w;
...
w = w; // explict assignment to self a[i] = a[j]; // potential assignment to self *px = *py; // potential assignment to self

解决方法是,在函数内加一个 if 语句,判断当前实例 (*this) 和传入的参数 rhs 是不是同一个实例,也即判断是不是自赋值的情况

如果是自赋值,则不作任何处理,直接返回 *this;如果不是自赋值,首先释放实例自身已有内存,然后再分配新的内存,如下所示:

Widget& Widget::operator=(cosnt Widget& rhs)
{
if (this == &rhs) return *this; // identity test: if a self-assignment, do nothing delete pb;
pb = new Bitmap(*rhs.pb); return *this;
}

1.3  异常安全

上例中,假如在分配内存时,因内存不足或 Bitmap 的拷贝构造函数异常,导致 "new Bitmap" 产生异常 (exception),则 pb 指向的是一个已经被删除的 Bitmap

考虑异常安全,一个方法是先用 new 分配新内容,再用 delete 释放如下代码的内容,如下所示:当 "new Bitmap" 抛出一个异常时,pb 指针并不会改变

Widget& Widget::operator=(cosnt Widget& rhs)
{
if (this == &rhs) return *this; // identity test
Bitmap *pOrig = pb; // remember original pb pb = new Bitmap(*rhs.pb); // 注意:"." 的优先级高于 "*"
delete pOrig; // delete the original pb return *this;
}

如果不考虑效率的问题,那么即使没有对自赋值进行判断的 if 语句,其后面的语句也足以应付自赋值的问题

2  拷贝-交换

上例中,因为效率的问题,保留了 if 语句,但实际上,因为自赋值出现的概率很低,所以上述代码看似“高效”,其实并不然

最常用的兼顾自赋值和异常安全 (exception safety) 的方法是 “拷贝-交换” (copy-and-swap),如下所示:

Widget& Widget::operator=(const Widget& rhs)
{
Widget temp(rhs); // make a copy of rhs's data swap(temp); // swap *this's data with the copy's return *this;
}

2.1  std::swap

std::swap 属于标准算法,其实现如下:

namespace std 
{
template<typename T> // typical implementation of std::swap
void swap(T& a, T& b) // swaps a's and b's values
{
T temp(a);
a = b;
b = temp;
}
}

以上有三个拷贝:首先拷贝 a 给 temp,然后拷贝 b 给 a,最后拷贝 temp 给 b

2.2  Widget::swap

对于 Widget 类,实现两个 Widget 对象的值交换,只需互换 Bitmap *pb 即可,这称为 pimpl (pointer to implementation)

首先,定义一个 swap 公有成员函数,如下:

void Widget::swap(Widget& other)
{
using std::swap;
swap(pb, other.pb); // to swap Widgets, swap their pb pointers
}

然后,模板特例化 std::swap 函数,调用上面的 swap 函数,实现指针互换

namespace std
{
template<> // revised specialization of std::swap
void swap<Widget>(Widget& a, Widget& b)
{
a.swap(b); // to swap Widgets, call their swap member function
}
}

3  智能指针

综上所述,重载赋值操作符,需要考虑链式赋值、自赋值和异常安全,颇为繁琐

一个简化方法是,在 Widget 类中声明一个智能指针

class Widget {
...
private:
std::unique_ptr<Bitmap> pBitmap; // smart pointer
};

此时,重载 "op=",则只需考虑链式赋值

Widget& Widget::operator=(const Widget& rhs) // copy operator=
{
*pBitmap = *rhs.pBitmap; // "." 的优先级高于 "*"
return *this;
}

理论上应该可行,尚未在实际项目中验证 (留待后续测试...)

小结:

1) 重载类赋值操作符,首先考虑链式赋值 -- 函数返回 *this,其次考虑自赋值和异常安全 -- “拷贝-交换”

2) 考虑写一个不抛异常的 swap 函数 (consider support for a non-throwing swap)

3) 被重载的类赋值操作符 "op=" 必须定义为成员函数,其它的复合赋值操作符 (如 "+=", "-=" 等) 应该被定义为成员函数

4) 类中使用智能指针,可大大简化重载赋值操作符 “op=” 的实现

参考资料:

<Effective C++_3rd> item 10, 11, 25

<剑指 offer> 2.2.1

<Effective Modern C++> item 22

上一篇:thinkcmf 相关


下一篇:eclipse不能进入debug