I want to be able to write an expression like: a+b-c + and - will be overloaded

Here;s my class:

class go{
	
public:
	int i;
	const go operator++(int){
		go before;
		before.i = this->i;
		i++;
		return before;
	}

	const go operator+(go& m){
		go x;
		x.i= this->i + m.i;
		return x;

	}

	const go operator-(go& m){
		go x;
		x.i = i - m.i;
		return x;
	}

	void print(ostream& e){
		e << this->i << endl;

	}
};

If I create 3 objects of type go,initialize all of them,and do the above expression,a+b-c,on - it will show an error like:

no operator - matches these operands.

What is wrong?

Solved: define the operator overloaded functions as global,but make them a friend to the class.That way,you can get your hands on both operands!

go operator + (const go& m) const
{
   // whatever
}

You are returning "const go" from each of your operators. The operators themself take non-const reference, so this won't work. Returning by const value is useless anyway, just return "go". Also you should/need to define the input paramter to be "const go&".

EDIT: Damn, to slow ;)

EDIT2: Out of interest, did you really understand what you've been told that last thread you asked about the "temporary const return value"-thingy? Because this is pretty much related to this question...

EDIT3:

Solved: define the operator overloaded functions as global,but make them a friend to the class.That way,you can get your hands on both operands!

Thats utterly ugly. You shouldn't do that, declare the functions properly like described by me BitMaster, don't relate to such "hack-arounds" for simple things as operator overloading.

Solved: define the operator overloaded functions as global,but make them a friend to the class.That way,you can get your hands on both operands!

Solved: define the operator overloaded functions as global,but make them a friend to the class.That way,you can get your hands on both operands!