Returning an object from a member function of the same class

Question

I came across the following program:

class Counter { 
 protected:         
  unsigned int count;  

 public:  
  Counter(): count(0) {}   
  Counter(int c): count(c) {}   
  unsigned int get_count() { return count; }  
  Counter operator++() { return Counter(++count); }  
};  

What does the last member function do (Counter(++count))?

Answer 1

I think you wanted to implement operator++ for your class, and that should be implemented as:

Counter & operator++()
{
   ++count;
   return *this;
}

Now the question is what does it do? It does pre-increment. Now you can write ++counter and that will invoke the above operator overload, and which internally will increment the variable count by 1.

Example :

Counter counter(1);
++counter;
std::cout << counter.get_count() << std::endl;
++(++counter);
std::cout << counter.get_count() << std::endl;

Output:

2
4

What your original code does?

If you try to run the above code using your original implementation of operator++, it will print the following :

2
3

That is because you're creating another temporary object which you're returning, which when you write ++(++counter) the outer pre-increment will increment the temporary. So the outer pre-increment will not change the value of counter.count.

Even if you write ++(++(++(++counter))), its equivalent to just ++counter.

Compare the output here:

• http://www.ideone.com/xRXVq (your original code)
• http://www.ideone.com/xciWC (my code)

Note ++(++counter) does NOT invoke undefined behavior.

Answer 2

The last function is an overloaded operator. Specifically in the prefix increment operator. It lets you use the prefix ++ operator on objects of that class. For example:

  Counter counter;
  ++counter;
  // note this is not implemented
  counter++;

This line

  Counter(++count)

constructs a new Counter object by first incrementing the current instances count then by using the constructor

   Counter(int c)

The result of the prefix increment, is therefore, a different instance (an incremented copy) then what prefix increment was called on.