Re: What the?

From:

"Doug Harrison [MVP]" <dsh@mvps.org>

Newsgroups:

microsoft.public.vc.mfc

Date:

Tue, 12 Feb 2008 22:32:53 -0600

Message-ID:

<dbs4r3t1c1klbsp5rsanhrfr6ertpadbbl@4ax.com>

On Tue, 12 Feb 2008 23:10:55 -0500, Joseph M. Newcomer
<newcomer@flounder.com> wrote:

Actually a++ and ++a generate the same code in this context. There is a common myth about
the relative efficiency of these operations; this mythology is largely based on the PDP-11
instruction set which had a pre-increment and post-decrement addressing mode built into
the instruction set. On the PDP-11, a++ and --a were the preferred forms because the
increment and decrement could be built into the instruction address bits (in fact, in the
early versions of the C compiler a++ existed but ++a was a syntax error, and a-- did not
exist and was a syntax error, but --a compiled. Eventually, the symmetry was introduced,
and the a++/++a controversy arose. In modern architectures that do not possess
auto-increment addressing modes, and in the presence of optimizing compilers, this rarely
matters, and when it does, remember that a 2.8GHz Pentium4 will execute a single extra
instruction in 175ps, not really a big deal (that's a 350ps clock dispatching two integer
instructions per clock cycle).

The modern C++ issue concerns postincrement returning a copy of the
original value. Since iterators can be arbitrary class types, this is
potentially more expensive than using preincrement, which returns the
incremented object by reference. Therefore, the standard advice is to use
preincrement when there's a choice. For reference, here are canonical
definitions of the operators:

// ++x;

T&
T::operator++()
{
   inc();
   return *this;
}

// x++;

T
T::operator++(int)
{
   T temp(*this);
   inc();
   return temp;
}

--
Doug Harrison
Visual C++ MVP