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

最新推荐文章于 2024-10-09 15:36:52 发布

原创最新推荐文章于 2024-10-09 15:36:52 发布 · 5.1k 阅读

1 ·

CC 4.0 BY-SA版权

C++编程专栏收录该内容

110 篇文章

订阅专栏

本文探讨了C++中的运算符重载实践，包括如何谨慎定义类型转换函数以避免意外转换，解释了自增和自减运算符的不同用法，并讨论了避免重载逻辑运算符的原因。此外，还介绍了如何理解和使用new和delete的不同形式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

运算符

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)