operator overloading in c++

Question

suppose i have 2 objects of a class and it has one int data member. i want to add those integer data to other object and store the output in the first obj's data member.I can overload the + operator and use the statement like below

X+Y  //where X and Y are objects of one class.

if i have to add like below

X+10// here i want to add 10 to the data member of X.

for above also i can overload the operator +.

but if i have 10+X and i want to add 10 to the data member of X how could i do it?

You need a global function `operator+` with two arguments. – sharptooth Mar 14 '11 at 10:43 — sharptooth, Mar 14 '11 at 10:43

score 3 · Accepted Answer · edited Mar 14 '11 at 12:17

The same way:

MyClass operator+(MyClass const& lhs, MyClass const& rhs);
MyClass operator+(MyClass const& lhs, int rhs);
MyClass operator+(int lhs, MyClass const& rhs);

(operator+ should not normally be a member.)

If you overload operator+, you'll also want to overload +=. One frequent idiom involved implementing + in terms of +=. This can be more or less automated (if you have a lot of classes supporting operators) by defining something like:

template<typename DerivedType>
class ArithmeticOperators
{
  public:
    friend DerivedType operator+(
        DerivedType const&  lhs,
        DerivedType const&  rhs)
    {
        DerivedType         result(lhs);
        result += rhs;
        return result;
    }
    //  And so on for the other operators...
protected:
    ~ArithmeticOperators() {}
};

template<typename DerivedType, typename OtherType>
class MixedArithmeticOperators
{
  public:
    friend DerivedType operator+(
        DerivedType const&  lhs,
        OtherType const&    rhs)
    {
        DerivedType         result(lhs);
        result += rhs;
        return result;
    }
    friend DerivedType operator+(
        OtherType const&    lhs,
        DerivedType const&  rhs)
    {
        DerivedType         result(rhs);
        result += lsh;
        return result;
    }
    //  And so on: non-commutative operators only have the
    //  first.
protected:
    ~MixedArithmeticOperators() {}
};

, then deriving from whatever is needed: in your case:

class MyClass : public ArithmeticOperators<MyClass>,
                MixedArithmeticOperators<MyClass, int>

score 2 · Answer 2 · edited May 23 '17 at 12:26

You have to create an overloaded operator as a free function with the correct parameter order:

// This will match "int + YourClass" additions
YourClass operator+(int Left, const YourClass & Right)
{
    // If your addition operation is commutative, you can just call the other
    // version swapping the arguments, otherwise put here your addition logic
    return Right + Left;
}

If the operator needs to fiddle with the internals of your class you can make it friend.

As others pointed out, there are some best/common practices that you should follow if you implement operator+, I suggest you to have a look to the great C++-FAQ on operator overloading for more info about them.

score 1 · Answer 3 · answered Mar 14 '11 at 10:44

1

Don't overload the operator + as a member function of the class. You can either define a global function operator + with two parameters or make operator + a friend of your class (In that case you should be having a parameterized constructor to convert 10 to an object of your class-type).

answered Mar 14 '11 at 10:44

Prasoon Saurav

91,295
49
239
345

could you please explain why? – Vijay Mar 14 '11 at 10:46
1

@zombie : Read this C++-FAQ on operator overloading : http://stackoverflow.com/questions/4421706/operator-overloading – Prasoon Saurav Mar 14 '11 at 10:47
Cause operator overloads as member functions always expect the left class to be your class (e.g. class + 10). While some operations might allow you to swap parameters if you calculate it by hand (addition, multiplikation) the compiler won't be able to do so. – Mario Mar 14 '11 at 10:49

score 0 · Answer 4 · answered Mar 14 '11 at 10:45

0

Define a non-member stand-alone free function as:

sample operator+(int leftOperand, const sample & rightOperand)
{
   //...
}

answered Mar 14 '11 at 10:45

Nawaz

353,942
115
666
851

score 0 · Answer 5 · edited Mar 14 '11 at 10:57

0

You should define a non-member friend function

YourClass operator+(const YourClass &a, const YourClass&b) {

    // do the math here

}

it should be friend to get to the private members of YourClass. Also you should create constructor for YourClass that takes int.

In this way you've got one operator+ and for every other then int you just create another constructor.

edited Mar 14 '11 at 10:57

Matteo Italia

123,740
17
206
299

answered Mar 14 '11 at 10:48

Łukasz Klich

45
4

score 0 · Answer 6 · answered Mar 14 '11 at 10:48

0

Although you can do that using a global operator+, I would advise not to do it.

Only use operator overloading for data types for which the operators are immediately clear, e.g.:

complex numbers
strings (+,- ok, but * probably doesn't make much sense here)

The risk with overloaded operators is that the compiler may perform unwanted conversions, especially if you didn't make the single-argument constructor explicit.

answered Mar 14 '11 at 10:48

Patrick

23,217
12
67
130

1

What does global have to do with anything? A freestanding operator-function needn't be global – Armen Tsirunyan Mar 14 '11 at 10:53
It is not any more global than a class method. – CashCow Mar 14 '11 at 12:18
My suggestion was not to use operator overloading at all, unless for 'logical' cases (complex numbers, ...). – Patrick Mar 14 '11 at 23:58

operator overloading in c++

6 Answers6