Overloading Postfix / Prefix ( ++ , –) Increment and Decrements Operators in C++

In this article we will discuss how to overload postfix and prefix increment and decrement operators in c++.

Both increment and Decrement operators are of two types i.e. Prefix & Post.

Prefix-Increment (++x) and Prefix Decrement (–x) Operator

In case of prefix increment or decrement operators symbol ++ or — comes before the operand i.e. ++x and –x.

Prefix operators first performs the operation (either increment or decrement) first and then returns the updated value i.e

```int x = 8;
//Prefix increment operator
Int a = ++x;
// a is 9
```

It first increments the value of x and then returns the updated value of x, which get assigned to a.

```x = 8;
//Prefix decrement operator
Int b = --x;
// b is 7```

It first decrements the value of x and then returns the updated value of x, which get assigned to a.

Postfix-Increment (x++) and Postfix Decrement (x–) Operator

In case of postfix increment or decrement operators symbol ++ or — comes after the operand i.e.x++ and x–.

Postfix operators first makes a temporary copy of current value and then performs the operation (increment or decrement) on object. After that they return the temporary value.

```int x = 8;
// Postfix Increment operator
Int a = x++;
// a is 8 and x = 9
```

Postfix increment stored the current value of x in a temp and then increments the value of x. In the end it returned the value stored in temp i.e. last value of x. Which got assigned into a.

```x = 8;
// Postfix Decrement operator
Int b = x--;
// b is 8 and x = 7

```

Postfix decrement stored the current value of x in a temp and then decrements the value of x. In the end it returned the value stored in temp i.e. last value of x. Which got assigned into b.

As, these postfix / prefix ++ and — are already overloaded for primitive data types. Letâ€™s see how to overload them for a user defined class.

Suppose we have a class ComplexNumber i.e.

```/*
* A class representing complex number
* It has both real and imaginary part
*/
class ComplexNumber
{
int real;
int imaginary;
public:
ComplexNumber() :
real(0), imaginary(0)
{}
ComplexNumber(int r, int i) :
real(r), imaginary(i)
{}
friend std::ostream& operator<<(std::ostream& os, const ComplexNumber& obj);
};
```

Now letâ€™s overload postfix & prefix increment and decrement operators for this class,

As symbol for both postfix and prefix increment operator is same i.e. ++ and both expects single operand. So, to differentiate between these two operator functions definitions we need to pass an extra int argument in case of posfix increment operator i.e.

Prefix Increment Operator Function

```/*
*  Prefix Increment Operator
*  It first increments the Current Object and then returns its copy.
*/
ComplexNumber ComplexNumber::operator++()
{
++real;
++imaginary;
return *this;
}
```

Postfix increment Operator Function

```/*
*  Postfix Increment Operator
*  It first creates a temp copy of current object. Then increments
*  the current object. In the end returns the temp copy created initially.
*/
ComplexNumber ComplexNumber::operator++(int)
{
// Temp copy of the current object
ComplexNumber tempObj(this->real, this->imaginary);
real++;
imaginary++;

// Return the temp copy that stores the data before updation
return tempObj;
}```

As symbol for both postfix and prefix decrement operator is same i.e. –. So, to differentiate between these two operator functions we need to pass an extra int argument in case of postfix decrement operator i.e.

Prefix Decrement Operator Function

```/*
*  Prefix Decrement Operator
*  It first decrements the Current Object and then returns its copy.
*/
ComplexNumber ComplexNumber::operator--()
{
--real;
--imaginary;
return *this;
}```

Postfix Decrement Operator Function

```/*
*  Postfix Decrement Operator
*  It first creates a temp copy of current object. Then decrements
*  the current object. In the end returns the temp copy created initially.
*/
ComplexNumber ComplexNumber::operator--(int)
{
// Temp copy of the current object
ComplexNumber tempObj(this->real, this->imaginary);
real--;
imaginary--;

// Return the temp copy that stores the data before updation
return tempObj;
}```

Complete example is as follows,

```#include#include/**Aclassrepresentingcomplexnumber*Ithasbothrealandimaginarypart*/classComplexNumber{intreal;intimaginary;public:ComplexNumber():real(0),imaginary(0){}ComplexNumber(intr,inti):real(r),imaginary(i){}friendstd::ostream&operator<<(std::ostream&os,constComplexNumber&obj);//PrefixIncrementOperatorComplexNumberoperator++();//PostfixIncrementOperatorComplexNumberoperator++(int);//PrefixDecrementOperatorComplexNumberoperator--();//PostfixDecrementOperatorComplexNumberoperator--(int);};std::ostream&operator<<(std::ostream&os,constComplexNumber&obj){intimg=obj.imaginary<0?-obj.imaginary:obj.imaginary;os<<obj.real<<(obj.imaginary<0?"-":"+")<<"i"<<img<<std::endl;returnos;}/**PrefixIncrementOperator*ItfirstincrementstheCurrentObjectandthenreturnsitscopy.*/ComplexNumberComplexNumber::operator++(){++real;++imaginary;return*this;}/**PostfixIncrementOperator*Itfirstcreatesatempcopyofcurrentobject.Thenincrements*thecurrentobject.Intheendreturnsthetempcopycreatedinitially.*/ComplexNumberComplexNumber::operator++(int){//TempcopyofthecurrentobjectComplexNumbertempObj(this->real,this->imaginary);real++;imaginary++;//ReturnthetempcopythatstoresthedatabeforeupdationreturntempObj;}/**PrefixDecrementOperator*ItfirstdecrementstheCurrentObjectandthenreturnsitscopy.*/ComplexNumberComplexNumber::operator--(){--real;--imaginary;return*this;}/**PostfixDecrementOperator*Itfirstcreatesatempcopyofcurrentobject.Thendecrements*thecurrentobject.Intheendreturnsthetempcopycreatedinitially.*/ComplexNumberComplexNumber::operator--(int){//TempcopyofthecurrentobjectComplexNumbertempObj(this->real,this->imaginary);real--;imaginary--;//ReturnthetempcopythatstoresthedatabeforeupdationreturntempObj;}intmain(){//Createacomplexnumber2+i3ComplexNumberc1(2,3);std::cout<<"c1="<<c1;std::cout<<"TestingPostfixIncrement"<<std::endl;ComplexNumberc2=c1++;//PostfixIncrementstd::cout<<"c2="<<c2;std::cout<<"c1="<<c1;std::cout<<"TestingPrefixIncrement"<<std::endl;ComplexNumberc3=++c1;//PrefixIncrementstd::cout<<"c3="<<c3;std::cout<<"c1="<<c1;std::cout<<"TestingPostfixDecrement"<<std::endl;ComplexNumberc4=c1--;//PostfixDecrementstd::cout<<"c4="<<c3;std::cout<<"c1="<<c1;std::cout<<"TestingPrefixDecrement"<<std::endl;ComplexNumberc5=--c1;//PrefixDecrementstd::cout<<"c5="<<c3;std::cout<<"c1="<<c1;return0;} decode:true " >#include <iostream>
#include <string>
#include <assert.h>

/*
* A class representing complex number
* It has both real and imaginary part
*/
class ComplexNumber
{
int real;
int imaginary;
public:
ComplexNumber() :
real(0), imaginary(0)
{}
ComplexNumber(int r, int i) :
real(r), imaginary(i)
{}
friend std::ostream& operator<<(std::ostream& os, const ComplexNumber& obj);

//Prefix Increment Operator
ComplexNumber operator++();

// Postfix Increment Operator
ComplexNumber operator++(int);

// Prefix Decrement Operator
ComplexNumber operator--();

//Postfix Decrement Operator
ComplexNumber operator--(int);

};

std::ostream& operator<<(std::ostream& os, const ComplexNumber& obj)
{
int img = obj.imaginary < 0 ? -obj.imaginary : obj.imaginary;
os << obj.real << (obj.imaginary < 0 ? " - " : " + ") << "i" << img
<< std::endl;
return os;
}

/*
*  Prefix Increment Operator
*  It first increments the Current Object and then returns its copy.
*/
ComplexNumber ComplexNumber::operator++()
{
++real;
++imaginary;
return *this;
}

/*
*  Postfix Increment Operator
*  It first creates a temp copy of current object. Then increments
*  the current object. In the end returns the temp copy created initially.
*/
ComplexNumber ComplexNumber::operator++(int)
{
// Temp copy of the current object
ComplexNumber tempObj(this->real, this->imaginary);
real++;
imaginary++;

// Return the temp copy that stores the data before updation
return tempObj;
}

/*
*  Prefix Decrement Operator
*  It first decrements the Current Object and then returns its copy.
*/
ComplexNumber ComplexNumber::operator--()
{
--real;
--imaginary;
return *this;
}

/*
*  Postfix Decrement Operator
*  It first creates a temp copy of current object. Then decrements
*  the current object. In the end returns the temp copy created initially.
*/
ComplexNumber ComplexNumber::operator--(int)
{
// Temp copy of the current object
ComplexNumber tempObj(this->real, this->imaginary);
real--;
imaginary--;

// Return the temp copy that stores the data before updation
return tempObj;
}

int main()
{
// Create a complex number 2 + i3
ComplexNumber c1(2, 3);

std::cout << "c1 = "<< c1;

std::cout << "Testing Postfix Increment"<<std::endl;
ComplexNumber c2 = c1++; // Postfix Increment

std::cout << "c2 = "<< 	c2;
std::cout << "c1 = "<< c1;

std::cout << "Testing Prefix Increment"<<std::endl;
ComplexNumber c3 = ++c1; // Prefix Increment

std::cout << "c3 = "<< 	c3;
std::cout << "c1 = "<< c1;

std::cout << "Testing Postfix Decrement"<<std::endl;

ComplexNumber c4 = c1--; // Postfix Decrement

std::cout << "c4 = "<< 	c3;
std::cout << "c1 = "<< c1;

std::cout << "Testing Prefix Decrement"<<std::endl;

ComplexNumber c5 = --c1; // Prefix Decrement
std::cout << "c5 = "<< 	c3;
std::cout << "c1 = "<< c1;

return 0;
}

```

Output

```c1 = 2 + i3
Testing Postfix Increment
c2 = 2 + i3
c1 = 3 + i4
Testing Prefix Increment
c3 = 4 + i5
c1 = 4 + i5
Testing Postfix Decrement
c4 = 4 + i5
c1 = 3 + i4
Testing Prefix Decrement
c5 = 4 + i5
c1 = 2 + i3
```

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Scroll to Top