Thread: += Operator

I have a main file rational.cxx and a header file rational.h.
Everything seems to be working except i can't get the +=, *=, -=, and /= operators to work in the rational.cxx file.
I have a function in rational.h so I can use it which is below.

Code:

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

For example when I get to the point in the program where += is located in the rational.cxx file I get a Segmentation Fault. I can't find why it's doing this I'm hoping it's just a silly mistake I made. I forgot to say I'm using a class in the header file which is why I need to do this. So any help would be appreciated.

Silly me, thanks for that I realized one of my problems. I have to take the numerator of lhs and rhs and add the two. Now I just have to figure out how to do that. Any ideas? lol

Originally Posted by StarOrbs

Silly me, thanks for that I realized one of my problems. I have to take the numerator of lhs and rhs and add the two. Now I just have to figure out how to do that. Any ideas? lol

[edit]

Code:

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

You don't list both objects as parameters. The lhs object is the one calling the operator+= method, so it should not be listed. You can access the lhs object's members directly by just using their names.

[/edit]

Presumably your objects lhs and rhs are defined something like this:

Code:

class myObject
{
     int x;
     int y;

[edit]don't need get/set methods-->methods of a class,
 like operator+=, can access private members directly[/edit]
....
}

So, you would do something like this inside operator+=:

[edit]
x += rhs.x;
[/edit]

and as Thantos pointed out, you want to return a reference to an object, which in this case I think should be the lhs object. That is so you can chain operations together like this:

myObject1 += myObject2 += myObject3;

Otherwise, I don't think you would need to return anything: your lhs object would already have the appropriate changes made inside the operator+= method. Also, you should be able to see that returning an int probably isn't correct. If you do this:

myObject1 += myObject2;

the return value is not assigned to a variable so it's discarded. If you wanted to assign the return value to a variable, you would need to do this:

int result = (myObject1 += myObject2);

Is that something you want to be doing? If not, the only time the return value would be important is in a chain:

myObject1 += (myObject2 += myObject3);

If the operator+= returns an int, then you are left with:

myObject += someInt;

and you probably don't even have an operator+= defined for an int type on the rhs. What you want to be left with is:

myObject += Object2;

Maybe this example will help you out:

Code:

#include <iostream>
using namespace std;

class Apple
{
	int size;

public:

	Apple(int s)
	{
		size = s;
	}
	Apple()
	{
		size = 0;
	}

	int getsize(){return size;}

	Apple& operator+=(const Apple& rhs)
	{
		size += rhs.size;
		return *this;  
                //'this' is a pointer to the object that is calling this function, i.e.
                //the object on the lhs, and dereferencing it gives you the object
	}

	Apple& operator*=(const Apple& rhs)
	{
		size *= rhs.size;
		return *this;
	}

};

int main()
{
	Apple A(5);
	Apple B(2);

	A += B;
	cout<<A.getsize()<<endl;

	A *= B;
	cout<<A.getsize()<<endl;

	return 0;
}

For rational numbers, multiplication is usually easier than addition, so it doesn't really make sense to implement the latter in terms of the former.

For multiplication you just multiply the two numerators and the two denominators.
For addition, you have to multiply the two denominators with each other, the first numerator with the second denominator and vice versa, and then add the numerators.

In both cases you finish by reducing the fraction.