Overloading unary operators

Hi

Please take a look at the following example.

Code:

#include <iostream>

class test{
public:
	int integer;
	void operator-();
};

void test::operator-() {
	(*this).integer++;

}

int main() {
	test temp;
	temp.integer = 1;
        +temp;
	cout << temp.integer << endl;
		
	getch();
	return 0;
}

When talking about binary operators (overloaded by member functions), the left argument is passed by reference to the *this-pointer. But in the case with unary operators, it is the right argument that is passed to the *this-pointer?

Originally Posted by Niels_M

When talking about binary operators (overloaded by member functions), the left argument is passed by reference to the *this-pointer.

Sounds like the opposite to me, i.e., *this is passed as the "left argument".

Originally Posted by Niels_M

But in the case with unary operators, it is the right argument that is passed to the *this-pointer?

Yes. I mean, if the operator does not have a left operand, then it just does not have a left operand, so it is a no brainer to deduce what the argument must be.

Originally Posted by laserlight

Sounds like the opposite to me, i.e., *this is passed as the "left argument".


Yes. I mean, if the operator does not have a left operand, then it just does not have a left operand, so it is a no brainer to deduce what the argument must be.

You would think that, but if I place the "+" to the right, I get an error.

Originally Posted by Niels_M

You would think that, but if I place the "+" to the right, I get an error.

So, what do you deduce from that?

Or put it another way: what is the syntax for the unary operator+? Use some variant of BNF to describe it, if you will.

What I deduce from that is that when overloading unary operators, then the right operand is passed by reference to the *this-pointer. Regarding what is being passed, I feel confident in my statement, even though you said it was the other way (Overloading operators).

Am I correct?

Originally Posted by Niels_M

What I deduce from that is that when overloading unary operators, then the right operand is passed by reference to the *this-pointer.

Yes, but note that some unary operators have left operands, e.g., postfix operator++. My point is: unary operator+ only has a right operand. There is nothing to talk about a left operand, so I cannot understand why you are worrying about this.

Originally Posted by Niels_M

Regarding what is being passed, I feel confident in my statement, even though you said it was the other way

You feel confident in stating that for binary operators, "the left argument is passed by reference to the *this-pointer"? I think we are just looking at it from different points of view. Your view is correct, but expressed as such, it sounds nonsensical to me because arguments are not passed to variables. Rather, the left argument is passed by reference to the function, and is used to initialise the first parameter. If the function is a member function, the first parameter is effectively *this.

Originally Posted by laserlight

Yes, but note that some unary operators have left operands, e.g., postfix operator++. My point is: unary operator+ only has a right operand. There is nothing to talk about a left operand, so I cannot understand why you are worrying about this.

So there is no way for me to overload an operator in C++ such that I can write e.g. +temp (temp is an object)?

Originally Posted by laserlight

You feel confident in stating that for binary operators, "the left argument is passed by reference to the *this-pointer"? I think we are just looking at it from different points of view. Your view is correct, but expressed as such, it sounds nonsensical to me because arguments are not passed to variables. Rather, the left argument is passed by reference to the function, and is used to initialise the first parameter. If the function is a member function, the first parameter is effectively *this.

I agree with you; your view is probably better. I will use that.

Originally Posted by Niels_M

So there is no way for me to overload an operator in C++ such that I can write e.g. +temp (temp is an object)?

Err... but you can do that. It is impossible to overload such that you can write temp+ where temp is an object and + is the unary operator+.

Originally Posted by laserlight

Err... but you can do that. It is impossible to overload such that you can write temp+ where temp is an object and + is the unary operator+.

Right, I meant to ask if there was a way to overload a unary operator in order to write temp+, but you answered that question. Thanks for clarifying.