在 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 );

如果需要访问，您可能需要将其设为该类的 friend Number 的内部结构。

如果您必须将其作为成员函数，那么您需要将函数本身设置为 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 有一个运算符 §。 它可以写成非成员函数：

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. 每个操作数都需要是常量，因为 < code>a = b + c 不得更改 b，也不得更改 c。
2. 您可以累积 +，例如 a = b + c + d + e，因此临时变量必须存在。

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

对于+=：

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

所以你应该使用：

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

一如既往，过早的优化是万恶之源

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

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 会产生有趣（且错误）的结果。

^_^

最后但并非最不重要的一点是，

我在 此页面。 该页面仍在建设中，但其主要用途（易于复制/粘贴工作原型）可能非常有用......