Question

我一直试图理解运算符重载，并且在下面的程序中没有将返回类型用作类类型：当我用“ int”切换“ overload”返回类型时，它工作正常。

#include <iostream>
using namespace std; 

class overload { 
private: 
    int count; 

public: 
    overload(int i) 
        : count(i) 
    { 
    } 

    overload operator++(int) //why return type is class type when i can use int
    { 
        return (count++); 
    } 
    overload operator++() //why return type is class type when i can use int
    { 
            count = count + 1; 
            return count;        
    } 
    void Display() 
    { 
        cout << "Count: " << count<<endl; 
    } 
}; 
// Driver code 
int main() 
{ 
    overload i(5); 
    overload post(5); 
    overload pre(5); 

    // this calls "function overload operator ++()" function 
    pre = ++i; 
    post = i++; 
    i.Display(); 
    return 0; 
}

Answer 1

对重载运算符的返回类型没有限制。这里也可以是int。如果overload类的构造函数被标记为explicit，则显示的代码会将类类型作为返回类型，以方便代码中的其他语句，如下所示：

例如：

explicit overload(int i) 
        : count(i) 
{ 
}

和

int operator++(int) //return type is  int
{ 
    return (count++); 
} 
int operator++() //return type is int
{ 
     count = count + 1; 
     return count;        
}

以下内容将无法编译：

pre = ++i; //will not work
post = i++; //will not work

这是因为隐式副本分配运算符将不再可行，无法从int转换为const overload。

请参见Demo

请注意，前缀和后缀递增/递减运算符的Canonical implementations分别返回overload&和overload。

尽管递增/递减的规范形式会返回引用，就像任何运算符重载一样， 返回类型是用户定义的 ；例如，这些运算符对std :: atomic按值返回的重载

Answer 2

前置/后置增量运算符之间的区别是：一个直接在对象上工作（前置增量：++ foo），而一个需要获取对象的副本并将其返回（后置增量：foo ++）。更为冗长的书写方式是：

// return a new object that represents the old value
overload operator++(int)
{ 
    overload oldValue(count); // take copy
    count++;                  // increment this object
    return oldValue; 
} 

// increment the count, and return a reference to this object
overload& operator++()
{ 
    ++count;
    return *this;        
}

尽管您可以返回int （不要这样做！），但这只会导致混乱。实际上，这将导致一些代码问题，例如：

overload foo = ++someOtherFoo;

如果要从++返回int，则最终会有效地调用构造函数（而不是复制构造函数）来构造新对象。即

overload foo = overload(++someOtherFoo);

该构造函数可能不可用，因此代码将失败。

如果您希望对象自动将其自身转换为整数，则正确的方法是重载强制转换运算符，例如

operator int () const
{ 
  return count; 
}

为什么在下面的代码返回类型中将类类型用于运算符重载？

2 个答案: