CODEWITHSUNDEEP
c++operator-overloading
Vijay
Vijay

Reputation: 67291

operator overloading in c++

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?

Upvotes: 4

Views: 1195

Answers (6)

James Kanze
James Kanze

Reputation: 154027

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>

Upvotes: 3

Matteo Italia
Matteo Italia

Reputation: 126927

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.

Upvotes: 2

Łukasz Klich
Łukasz Klich

Reputation: 45

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.

Upvotes: 0

Patrick
Patrick

Reputation: 23629

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.

Upvotes: 0

Sarfaraz Nawaz
Sarfaraz Nawaz

Reputation: 361722

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

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

Upvotes: 0

Prasoon Saurav
Prasoon Saurav

Reputation: 92894

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

Upvotes: 1

Related Questions