操作者在C ++重载为INT + OBJ(Operator Overloading in C++ a

我有以下类： -

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;
}

其中一个这种方法的主要好处是，你的函数可以在降低总体代码你所需要的量上彼此的角度来实现的。

更新：

为了保持性能的关注在海湾，我可能会定义非成员operator +为内联函数是这样的：

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

会员操作也内嵌（因为他们在类体内正在申报）等在所有的代码应该是非常接近增加了两个原料成本int对象。

最后，如jalf指出，允许一般需要隐式转换的后果加以考虑。 上面的例子假定它是明智的，从整型转换为“民”。

Answer 4:

你需要一个全局函数operator +（INT，MyClass的），要做到这一点：

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

文章来源: Operator Overloading in C++ as int + obj