[C++]关于重载运算符的一些建议

Posted 2020-07-10 stary_yan

运算符

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)