Оператор, Перегружающийся в C++ как интервал + obj

Реализуйте перегрузку операторов вне класса:

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

    int i;
};

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

Вы должны реализовать оператор как функцию, не являющуюся членом , чтобы разрешить примитивный int на левая сторона.

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

Для этого вам понадобится глобальная функция operator + (int, myclass):

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

Другие ответы здесь решат проблему, но я использую следующий шаблон, когда это делаю:

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 объектов должна быть очень близка.

Наконец, как указано by jalf, необходимо учитывать последствия разрешения неявных преобразований в целом. В приведенном выше примере предполагается, что целесообразно преобразовать целочисленный тип в «Num».