On Dec 6, 5:21 pm, Abhishek Padmanabh <abhishek.padman...@gmail.com>
wrote:
[...]
Off-topic, but I recently bumped into std::accumulate which the C++98
and probably C++03 mention as to not have any side-effects but this
version had more explicit explaination that it would not change the
objects pointed to by the iterators, invalidate them etc. And not
knowing that we just got confused (got revealed later, though).
Not off-topic for the group. std::accumulate is one of those
wierd functions in the STL designed to do things the hard (or
slow) way. In this case, by using "accu = accu + *iter" or
"accu = binop( accu, *iter )", rather than "accu += *iter" or
"binop( accu, *iter )". For my digest hashing classes (MD5,
SHA1, etc.), I've created a special binary operator which does
the equivalent of a +=, and returns a special type for which the
accumulator has a no-op assignment operator. This avoids
copying the accu (which in the case of such digests, has
non-trivial state), and results in a speed up of about 8 times
faster.
It's also officially illegal, although I can't imagine an
implementation where it would fail. (It doesn't trigger the
concept checks in the more recent versions of g++, and it passes
all of the usual tests with VC++, g++ and Sun CC---the latter
with both the Rogue Wave library and the STL port.) But a
factor of 8! I offer it in the interface of the classes,
documenting that it depends on undefined behavior doing what one
would expect, and leave the rest to the conscience (or the
application requiremens) of the user.
1. How do you possibly capture the return of binary_op without copying
2. What makes it illegal?