C++ 中的运算符重载 作为 int + 对象

Question

我有以下课程：-

class myclass
{
    size_t st;

    myclass(size_t pst)
    {
        st=pst;
    }

    operator int()
    {
        return (int)st;
    }

    int operator+(int intojb)
    {
        return int(st) + intobj; 
    }

};

只要我像这样使用它，它就可以正常工作：-

char* src="This is test string";
int i= myclass(strlen(src)) + 100;

但我无法做到这一点：-

int i= 100+ myclass(strlen(src));

任何想法，我怎样才能实现这一点？

Answer 1

在类外部实现运算符重载：

class Num
{
public:
    Num(int i)
    {
        this->i = i;
    }

    int i;
};

int operator+(int i, const Num& n)
{
    return i + n.i;
}

Answer 2

您必须将运算符实现为非成员函数，以允许左侧使用原始 int。

int operator+( int lhs, const myclass& rhs ) {
    return lhs + (int)rhs;
}

Answer 3

这里的其他答案将解决该问题，但以下是我在执行此操作时使用的模式：

class Num
{
public:
  Num(int i)       // Not explicit, allows implicit conversion to Num
  : i_ (i)
  {
  }

  Num (Num const & rhs)
  : i_ (rhs.i_)
  {
  }

  Num & operator+= (Num const & rhs)  // Implement +=
  {
    i_ += rhs.i_;
    return *this;
  }

private:
    int i_;
};

//
// Because of Num(int), any number on the LHS or RHS will implicitly
// convert to Num - so no need to have lots of overloads
Num operator+(Num const & lhs, Num const & rhs)
{
  //
  // Implement '+' using '+='
  Num tmp (lhs);
  tmp+=rhs;
  return tmp;
}

这种方法的主要好处之一是您的函数可以相互实现，从而减少总体代码量你需要。

更新：

为了避免性能问题，我可能会将非成员运算符+定义为内联函数，如下所示：

inline Num operator+(Num lhs, Num const & rhs)
{
  lhs+=rhs;
  return lhs;
}

成员操作也是内联的（因为它们在类主体中声明），所以所有代码应该非常接近添加两个原始 int 对象的成本。

最后，正如 jalf 所指出的，一般需要考虑允许隐式转换的后果。 上面的示例假设从整型类型转换为“Num”是明智的。

Answer 4

您需要一个全局函数 operator+( int, myclass ) 来执行此操作：

int operator+( int intobj, myclass myobj )
{ return intobj + int(myobj); }