在C ++中使用const替换两个参数的运算符

Question

我正在尝试使用两个const参数创建一个重写的运算符函数，但我无法弄清楚如何执行它。这是一个简单的例子：

class Number
{
    Number()
    {
        value = 1;
    };

    inline Number operator + (const Number& n)
    {
        Number result;

        result.value = value + n.value;
        return result;
    }

    int value;
}

我在这里要做的是将两个参数传递给另外的函数，它们都是const并返回结果而不改变类中的任何内容：

const Number a = Number();
const Number b = Number();
Number c = a + b;

这可能吗？我将如何做到这一点？

谢谢，

丹

Answer 1

在类声明中理解

inline ，因此您无需指定它。

大多数惯用法，你会使 operator + 成为在类定义之外声明的非成员函数，如下所示：

Number operator+( const Number& left, const Number& right );

如果需要访问 Number 的内部，你可能需要让它成为该类的 friend 。

如果你必须将它作为一个成员函数，那么你需要使函数本身为const：

Number operator+( const Number& n ) const
{ // ...

对于像 Number 这样的类， operator + 通常用 operator + = 来实现，因为通常你希望所有常用的运算符按预期工作并且 operator + = 通常更容易实现，而 operator + 往往不会因为单独实现它而失去任何效率。

课堂内：

Number& operator+=( const Number& n );

课外：

Number operator+( const Number& left, const Number& right )
{
    return Number( left ) += right;
}

甚至：

Number operator+( Number left, const Number& right )
{
    return left += right;
}

Answer 2

class Number
{
    Number()
    {
        value = 1;
    };

    inline Number operator + (const Number& n) const
    {
        Number result;

        result = value + n.value;
        return result;
    }

    int value;
}

Answer 3

怎么样：

inline Number operator + (const Number& n) const

Answer 4

虽然我觉得以前的答案已经足够好了，但我相信还需要做一些澄清。

运营商（通常）有两种风格

第一个是非成员函数，第二个是成员函数，其参数是“右操作数”。操作，通常返回当前修改过的对象。

例如，假设有一个类 T 的运算符＆＃167; 。它可以写成非成员函数：

T operator § (const T & lhs, const T & rhs)
{
   T result ;
   // do the lhs § rhs operation, and puts the result into "result"
   return result ;
}

或作为成员函数：

T & T::operator § (const T & rhs)
{
   // do the "this § rhs" operation, and puts the result into "this"
   return *this ;
}

或甚至（非常不寻常）作为另一个成员函数：

T T::operator § (const T & rhs) const
{
   T result ;
   // do the "this § rhs" operation, and puts the result into "result"
   return result ;
}

通常，您应该更喜欢非成员函数，只是因为您不应该声明它是朋友。因此，使用非成员非友元函数可以增强对象的封装。

免责声明：还有其他风格，但我只限于算术运算符，如 + ， * ， / ，这里 - 等，以及“可信”等。运营商原型。

分析您对运营商的使用

对于 + ：

1. 每个操作数必须是常量，因为 a = b + c 不得更改 b ，也不能更改 c 。
2. 您可以累积 + ，就像 a = b + c + d + e 一样，因此临时工具必须存在。

T & T::operator += (const T & rhs)
{
   // do the "this § rhs" operation, and puts the result into "this"
   return *this ;
}

在 + = ：

的情况下
1. 您知道左操作数A（来自A + = B）将被修改。
2. 你知道左操作数A（来自A + = B）是它自己的结果。

所以你应该使用：

T & operator + (const T & lhs, const T & rhs)
{
   static T result ; // result is STATIC !!!!
   // do the lhs + rhs operation, and puts the result into "result"
   return result ;
}

与往常一样，过早优化是万恶之源

我在生产代码中看到过这种代码，所以确实发生了：

<*>

作者希望节约一个暂时的。使用这种代码，编写 a = b + c + d 会导致有趣（和错误）的结果。

^ _ ^

最后但并非最不重要

我确实在这个页面。该页面仍在构建中，但其主要用途（易于复制/粘贴工作原型）非常有用......