# Programming Examples

## 1. Introduction

We know that a binary operator takes two operands in which it performs the operation. Say, for example, the addition operator adds two numbers. We call these two numbers as operands and the ‘+’ as a binary operator. Now let us deal with the number ‘-12’. Here the minus sign states the negation of the number. The negation operator operates on only one operand. So we can say the ‘-‘ as an Unary Operator. In this example, we will see how to overload the ++ Unary Operator in both prefix and postfix forms.

The class

TheNumber

shown below has two private integer members. The constructor with two integer parameter sets default values to the class private members. Print method of this class prints the private member values in the console output.

## 3. Overload Prefix increment Operator ++

We can code the prefix operator the same way as we did for the binary + operator. Note that the implementation does not take any argument and the calling object itself serves the data for the first operand. Have a look at the below implementation:

In this implementation, we raise both the private members by adding one to it. After this, we return the current object to the caller. Remember that the current object is the only possible operand which called this function. With this overloaded operator, now it is possible to use the prefix notation of increment on an object. For example, if the instance is K, then we can use ++K, to increment both of its private members.

Now have a look at the usage code shown below:

In the above case, we created two objects. They are

num1

and

num2

. The

usage02

code snippet applies the prefix operator on both the objects

num1

and

num2

before adding them together using operator +.

### 3.3 Calling Sequence

The calling sequence of Prefix Overload goes like this:

1. First, C++ calls the prefix increment for num1
2. Secondly, the prefix increment operator for the num2 object is called.
3. Thirdly, the binary operator + is called on both the objects num1 and num2

At step 1, the private members for the

num1

object are incremented, and the object is returned. At step 2, the private members for the

num2

object are incremented and

num2

is returned. In the third step, we add the incremented objects using overloaded binary operator plus. So, we will see the result as shown below: Prefix Operator Program Output

The below picture explains the above process: In C++, we should overload the postfix operator somewhat differently. This is to help the run-time to avoid ambiguity. First, the operator function takes a dummy integer argument to differentiate this from the prefix overloaded operator. Next, in the implementation we clone the object. Then do increment on the calling object i.e. at the operand one. Lastly, return the cloned object. This way, we see the increment taking place after the statement execution. Have a look at the below implementation:

Note that we do the clone first. Then we do the increment on the local object. Finally, we return the cloned copy to the caller. So in caller perspective, the expression which contains the operator, gets only the cloned copy. After the ‘expression statement’ is done, we see the increment taking part in the operand. The parameter dummy is not doing anything here, right? This parameter is useful for the compiler to distinguish between prefix and postfix overload.

Look at the below code that uses the postfix operator:

Here, postfix operator for

num1

is called first. Then postfix operator for the

num2

is called. But the postfix operator on both the cases returned a cloned copy. These copies are then added together to get a result in the object

num4

.

The overloaded operator returns the cloned copy. The binary plus operator acts on these clones. But, in the actual memory of

Num1

and

Num2

, our operator function raised the internal members by 1. So, when we move to the next statement, we see the changed internal members. Postfix Operator Output

### 4.3 Calling Sequence

For more explanation, have a look at the below picture. In the postfix operator, we make the changes on the real objects. But, we return the cloned copy which was taken before the change was applied. The binary plus operator actually operates on the cloned copies and hence we get the members with a value of two in the result object

num4

. 