Why ++i is faster than i++

Are you ever heard meaning less discussions like "which is More Fast i++ or  ++ i"?  or ++j or j++ or ++k or k++ . hahahaha.  

IF you are serious I can say it will depends upon what is this i and j. If these variables are mere integers it doesn't matter. We can use both. Both of them are of same speed. Then Problem is with floating point? Or double?.. No noo.. :). Actually there is no problem for ++i or i++.

The problem comes when people do coding without concentration. Let us look the following example.

class COperator
{
            int i;
public:
            COperator(){i = 0;}
            COperator& operator ++()
            {
                        i++;
                        return *this;
            }
            COperator operator ++(int)
            {
                        COperator temp = *this;
                        i++;
                        return temp;
            }
};

In an expression as shown in below ,

COperator it; // now i =0
it++; // now i is 1
COperator pt = it++; //now pt.i = 1 & it.i = 2;

Here for preserving the behaviour of original posix operator(I++), there is a need for creating the temporary object in the stack((look operator ++(int) ) , and we return the temporary object.

So the point is this , some times in loops we often use i++ than ++i. It is a style. Ok , but is good with integers(etc). But in case of class the obj++ will create a extra object in stack and there is also a copy operation. Since in loops we need is a just an increment (or something like that). That’s why it is prefered to use ++it rather than I++. If you ever programmed with STL you can see that STL list uses iterators. They are class objects. So in that iterating loops use ++it rather than it++. This will save some computing time and memory.

C++ Templates can also be used to evaluate an expression. Here i am just putting an example ( got from internet , and is working).
This template class can be used to find the factorial of a number. Actually the compiler calculates the factorial at compile time , during the template parsing.

template class Factorial
{
public :
// Recursive definition
enum { GetValue = N * Factorial::GetValue };
};

// Specialization for base case
template <> class Factorial<1>
{
public :
enum { GetValue = 1 };

};

we can find the factorial using the class Factorial. For example Factorial<5>::GetValue will give the factorial of 5. Factorial of 1 is handled as a special way (Just to exit) . So the code may look like this

int fact = Factorial<5>GetValue;

If you try to find the factorial of 0 the visual studio will crash , Not the application :), because the factorial is computed by the compiler.Because if we put zero, there is no way to exit the compilation process (check with above codes). So you may need to handle 0 as a special case.

Note : Use of this feature will cause to slow down the compiling process.