What is the declaration of overloaded pre-increment operator implemented as member function?

Answer 1

The pre-increment operator accepts no parameters and returns the same object (by reference) after incrementing.

The post-increment operator accepts an unused (dummy) integer parameter and returns a copy of the object (by value) that is made immediately prior to incrementing the object.

Note that it is good practice to always use the pre-increment operator even if a post-increment operator exists. The only time you should ever use a post-increment is when you actually store the return value. If you don't store the return value then you will end up making an unnecessary copy, which is highly inefficient. With primitive data types that are less than or equal in length to a pointer this isn't a major issue, but it's good practice nonetheless. If you do it for primitives then you're far more likely to remember to do it for class instances as well.

The following example emulates an integer type with pre-increment and post-increment operators implemented:

class Simple

{

public: // Construction:

Simple(int data = 0):m_data(data){}

Simple(const Simple& simple):m_data(simple.m_data){}

public:

// Assignment:

Simple& operator= (const Simple& simple) {

m_data = simple.m_data;

return( *this ); }

// pre-increment:

Simple& operator++ () { // no parameters!

++m_data; // increment this object

return( *this ); } // return a reference to this object

// post-increment:

Simple operator++(int) { // int parameter (not used)!

Simple copy( *this ); // call the copy constructor

++m_data; // increment this object

return( copy ); } // return the copy (by value)

private:

int m_data;

};