Перегрузка оператора в С++ как int + obj

У меня есть следующий класс: -

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

Любая идея, как я могу достичь этого?

Ответы

Ответ 1

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

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

    int i;
};

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

Ответ 2

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

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

Ответ 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;
}

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

UPDATE:

Чтобы сохранить проблемы с производительностью, я бы, вероятно, определил оператор non member + как встроенную функцию:

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

Операции с членами также являются встроенными (поскольку они объявлены в классе), и поэтому во всем коде должно быть очень близко к стоимости добавления двух исходных объектов int.

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

Ответ 4

Для этого вам нужен глобальный оператор функции + (int, myclass):

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