CODEWITHSUNDEEP
c++operatorsoperator-overloadingoperator-keyword
Azher Iqbal
Azher Iqbal

Reputation: 547

Operator Overloading in C++ as int + obj

I have following class:-

class myclass
{
    size_t st;

    myclass(size_t pst)
    {
        st=pst;
    }

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

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

};

this works fine as long as I use it like this:-

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

but I am unable to do this:-

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

Any idea, how can I achieve this??

Upvotes: 19

Views: 39314

Answers (4)

Richard Corden
Richard Corden

Reputation: 21721

The other answers here will solve the problem, but the following is the pattern I use when I'm doing this:

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

One of the key benefits of this approach is that your functions can be implemented in terms of each other reducing the amount of overall code you need.

UPDATE:

To keep performance concerns at bay, I would probably define the non member operator+ as an inline function something like:

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

The member operations are also inline (as they're declared in the class body) and so in all the code should be very close to the cost of adding two raw int objects.

Finally, as pointed out by jalf, the consequences of allowing implicit conversions in general needs to be considered. The above example assumes that it's sensible to convert from an integral type to a 'Num'.

Upvotes: 5

Jeff L
Jeff L

Reputation: 6198

You have to implement the operator as a non-member function to allow a primitive int on the left hand side.

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

Upvotes: 13

Peter Kovacs
Peter Kovacs

Reputation: 2725

You need a global function operator+( int, myclass ) to do this:

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

Upvotes: 2

Brian R. Bondy
Brian R. Bondy

Reputation: 347406

Implement the operator overloading outside of the class:

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

    int i;
};

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

Upvotes: 27

Related Questions