[C++]关于重载运算符的一些建议
运算符
1. 谨慎定义类型转换函数
有两种函数允许编译器进行这些的转换:单参数构造函数(single-argument constructors)和隐式类型转换运算符。单参数构造函数是指只用一个参数即可以调用的构 造函数。该函数可以是只定义了一个参数,也可以是虽定义了多个参数但第一个参数以后的 所有参数都有缺省值。
第一个例子：
class Name {
public:
Name(const string& s);
... };
class Rational {
public:
Rational(int numerator = 0,
int denominator = 1);
...
// for names of things
// 转换 string 到
// Name
// 有理数类
// 转换 int 到
// 有理数类
};第二个例子：隐式类型转换运算符只是一个样子奇怪的成员函数:operator 关键字,其后跟一个类
型符号。
class Rational {
public: ...
operator double() const;
};
// 在下面这种情况下,这个函数会被自动调用: Rational r(1, 2);
double d = 0.5 * r;
// 转换 Rational 类成
// double 类型
// r 的值是 1/2
// 转换 r 到double,
// 然后做乘法 隐式类型转换可能出现的问题：
#include <iostream>
using namespace std;
class rational {
public:
rational(double a, double b) {
val = a / b;
}
operator double() {
return val;
}
private:
double val;
};
int main() {
rational test(3, 4);
cout << test << endl;
return 0;
}我们本以为没有定义operator <<，所以编译器会报错，但实际上编译器会把test隐式类型转换为double类型。这看起来很不错，实际上回出现很多不可预计的问题。它表明了隐式类型转换的缺点: ==它们的存在将导致错误的发生==。
解决方法是用不使用语法关键字的等同的函数来替代转换运算符。例如为了把 Rational 对象转换为 double,用 asDouble 函数代替 operator double 函数:
class Rational {
public:
...
double asDouble() const;
};
// 这个成员函数能被显式调用: Rational r(1, 2);
cout << r;
cout << r.asDouble();
//转变 Rational // 成 double
// 错误! Rationa 对象没有 // operator<<
// 正确, 用 double 类型 //打印 r 在多数情况下,这种显式转换函数的使用虽然不方便,但是函数被悄悄调用的情况不再 会发生,这点损失是值得的。就好像在编写库时，string没有给出隐式类型转换为char*的操作符，而是给出了c_str()来转换就是这个道理。
以下讨论单参数构造函数进行隐式类型转换的问题。
template<class T>
class Array {
public:
Array(int lowBound, int highBound);
Array(int size);
T& operator[](int index);
...
};第一个构造函数允许调用者确定数组索引的范围,例如从 10 到 20。它是一个两参数构造函数,所以不能做为类型转换函数。第二个构造函数让调用者仅仅定义数组元素的个数(使 用方法与内置数组的使用相似),不过不同的是它能做为类型转换函数使用,能导致无穷的痛苦。
例如比较 Array对象,部分代码如下:
bool operator==( const Array<int>& lhs,
Array<int> a(10);
const Array<int>& rhs);
Array<int> b(10);
...
for (int i = 0; i < 10; ++i)
if (a == b[i]) {
do something for when
a[i] and b[i] are equal;
} else {
// 哎呦! "a" 应该是 "a[i]"
do something for when they're not;
}我们想用 a 的每个元素与 b 的每个元素相比较,但是当录入 a 时,我们偶然忘记了数组 下标。当然我们希望编译器能报出各种各样的警告信息,但是它根本没有。因为它把这个调 用看成用 Array参数(对于 a)和 int(对于 b[i])参数调用 operator==函数,然而没有 operator==函数是这样的参数类型,我们的编译器注意到它能通过调用 Array构造函 数能转换 int 类型到 Array类型,这个构造函数只有一个 int 类型的参数。然后编译器如此去编译,生成的代码就像这样:
for (int i = 0; i < 10; ++i)
if (a == static_cast< Array<int> >(b[i])) ...每一次循环都把 a 的内容与一个大小为 b[i]的临时数组(内容是未定义的)比较。这 不仅不可能以正确的方法运行,而且还是效率低下的。因为每一次循环我们都必须建立和释 放 Array对象。
解决的方法是利用一个最新编译器的特性,explicit 关键字。为了解决隐式类型转换 而特别引入的这个特性,它的使用方法很好理解。构造函数用 explicit 声明,如果这样做, 编译器会拒绝为了隐式类型转换而调用构造函数。显式类型转换依然合法:
template<class T>
class Array {
public:
...
explicit Array(int size); // 注意使用"explicit"
... };
Array<int> a(10);
Array<int> b(10);
if (a == b[i]) ...
if (a == Array<int>(b[i])) ...
// 正确, explicit 构造函数 // 在建立对象时能正常使用
// 也正确
// 错误! 没有办法
// 隐式转换
// int 到 Array<int>
// 正确,显式从 int 到 // Array<int>转换
// (但是代码的逻辑
// 不合理)
if (a == static_cast< Array<int> >(b[i])) ...
// 同样正确,同样
// 不合理
if (a == (Array<int>)b[i]) ... //C 风格的转换也正确,
// 但是逻辑
// 依旧不合理关于explicit：（不允许参数隐式类型转换！）
class Test1
{
public:
Test1(int n)
{
num=n;
}//普通构造函数
private:
int num;
};
class Test2
{
public:
explicit Test2(int n)
{
num=n;
}//explicit(显式)构造函数
private:
int num;
};
int main()
{
Test1 t1=12;//隐式调用其构造函数,成功
Test2 t2=12;//编译错误,不能隐式调用其构造函数
Test2 t2(12);//显式调用成功
return 0;
}2. 自增和自减
重载函数间的区别决定于它们的参数类型上的差异,但是不 论是 increment 或 decrement 的前缀还是后缀都只有一个参数。为了解决这个语言问题,C++ 规定后缀形式有一个int类型参数,当函数被调用时,编译器传递一个0做为int参数的值 给该函数:
class UPInt {
public:
UPInt& operator++();
const UPInt operator++(int);
UPInt& operator--();
const UPInt operator--(int);
UPInt& operator+=(int);
... };
UPInt i;
++i;
i++;
--i;
i--;值得注意的是，==前缀返回的是引用，后缀返回的是const对象==。（很容易通过前缀自增和后缀自增的区别来判读合理性。）
UPInt& UPInt::operator++() {
*this += 1;
return *this;
}
const UPInt UPInt::operator++(int) {
UPInt oldValue = *this;
++(*this); // 增加 return oldValue;
} 如果后缀的increment不是const对象，那么以下代码就是正确的：
UPInt i;
i++++; // 两次 increment 后缀 这组代码与下面的代码相同:
i.operator++(0).operator++(0);3. 不要重载&&， ||或 “，”
C++使用==布尔表达式短路求值法==(short-circuit evaluation)。这表示一旦 确定了布尔表达式的真假值,即使还有部分表达式没有被测试,布尔表达式也停止运算。
char *p;
...
if ((p != 0) && (strlen(p) > 10)) ...
// 这里不用担心当 p 为空时 strlen 无法正确运行,因为如果 p 不等于 0 的测试失败,strlen 不会被调用。同样:
int rangeCheck(int index)
{
if ((index < lowerBound) || (index > upperBound)) ...
...
}C++允许根据用户定义的类型,来定制&&和||操作符。方法是重载函数 operator&& 和 operator||,你能在全局重载或每个类里重载。但是你就失去了短路求值的特性。
if (expression1 && expression2) ...
// 对于编译器来说,等同于下面代码之一:
if (expression1.operator&&(expression2)) ...
// when operator&& is a
// member function
if (operator&&(expression1, expression2)) ...
// when operator&& is a
// global function 这好像没有什么不同,但是函数调用法与短路求值法是绝对不同的。首先当函数被调用时,需要运算其所有参数,所以调用函数 functions operator&& 和 operator||时,两个 参数都需要计算,换言之,没有采用短路计算法。第二是 C++语言规范没有定义函数参数的 计算顺序,所以没有办法知道表达式1与表达式2哪一个先计算。完全可能与具有从左参数 到右参数计算顺序的短路计算法相反。
不能重载的部分：
. .* :: ?:
new delete sizeof typeid
static_cast dynamic_cast const_cast reinterpret_cast 能重载的部分：
operator new operator delete
operator new[] operator delete[] +-*/%^&|~
! =<>+=-=*=/=%= ^=&=|=<<>> >>=<<=== != <=>=&&||++ -- , ->*-> () [] 操作符重载的目的是使程序更容易阅读,书 写和理解,而不是用你的知识去迷惑其他人。如果你没有一个好理由重载操作符,就不要重 载。在遇到&&, ||, 和 ,时,找到一个好理由是困难的,因为无论你怎么努力,也不能让它 们的行为特性与所期望的一样。
4. 理解各种不同含义的new和delete
string *ps = new string(“Memory Management”);
你使用的 new 是 new 操作符。这个操作符就象 sizeof 一样是语言内置的,你不能改变它的 含义,它的功能总是一样的。它要完成的功能分成两部分。第一部分是分配足够的内存以便 容纳所需类型的对象。第二部分是它调用构造函数初始化内存中的对象。new 操作符总是做 这两件事情,你不能以任何方式改变它的行为。
new operator
你所能改变的是如何为对象分配内存。new 操作符调用一个函数来完成必需的内存分 配,你能够重写或重载这个函数来改变它的行为。new 操作符为分配内存所调用函数的名字 是 operator new。
函数 operator new 通常这样声明:
void * operator new(size_t size);
void *rawMemory = operator new(sizeof(string));
操作符 operator new 将返回一个指针,指向一块足够容纳一个 string 类型对象的内存。
就象 malloc 一样,operator new 的职责只是分配内存。它对构造函数一无所知。 operator new 所了解的是内存分配。把 operator new 返回的未经处理的指针传递给一个对 象是 new 操作符的工作。
placement new
但是有时你有一些已经被分配但是尚未处理的(raw)内存,你需要在这些内存中构造一个对象。你可以 使用一个特殊的 operator new ,它被称为 placement new。
void * operator new(size_t, void *location)
{
return location;
}operator new 的目的是为对象分配内存然后返回指向该内存的指针。在使用 placement new 的情况下,调 用者已经获得了指向内存的指针,因为调用者知道对象应该放在哪里。placement new 必须 做的就是返回转递给它的指针。(没有用的(但是强制的)参数 size_t 没有名字,以防止编 译器发出警告说它没有被使用。）
delete memory deallocation
Operator delete 用来释放内存,它被这样声明:
void operator delete(void *memoryToBeDeallocated); 因此,
delete ps;
导致编译器生成类似于这样的代码:
ps->~string(); // call the object's dtor operator
delete(ps); // deallocate the memory // the object occupied 这有一个隐含的意思是如果你只想处理未被初始化的内存,你应该绕过 new 和 delete
操作符,而调用 operator new 获得内存和 operator delete 释放内存给系统:
void *buffer =
operator new(50*sizeof(char));
// 分配足够的
// 内存以容纳 50 个 char
...
operator delete(buffer);
//没有调用构造函数
// 释放内存 // 没有调用析构函数 如果你用 placement new 在内存中建立对象,你应该避免在该内存中用 delete 操作符。
因为 delete 操作符调用 operator delete 来释放内存,但是包含对象的内存最初不是被 operator new 分配的,placement new 只是返回转递给它的指针。谁知道这个指针来自何方? 而你应该显式调用对象的析构函数来解除构造函数的影响:
// 在共享内存中分配和释放内存的函数
void * mallocShared(size_t size);
void freeShared(void *memory);
void *sharedMemory = mallocShared(sizeof(Widget));
Widget *pw = // 如上所示,
constructWidgetInBuffer(sharedMemory, 10); // 使用
...
delete pw;
pw->~Widget();
freeShared(pw);
// 结果不确定! 共享内存来自
// mallocShared, 而不是 operator new
// 正确。 析构 pw 指向的 Widget,
// 但是没有释放
//包含 Widget 的内存
// 正确。 释放 pw 指向的共享内存
// 但是没有调用析构函数 new 和 delete 操作符是内置的,其行为不受你的控制,凡是它们调用的内存分配和释放函数则可以控制。当你想定制 new 和 delete 操作符的行为时,请记住你不能真的做到这 一点。你只能改变它们为完成它们的功能所采取的方法,而它们所完成的功能则被语言固定 下来,不能改变。(You can modify how they do what they do, but what they do is fixed by the language)