Re: From bool to int: 1 or 0
Frederick Gotham wrote:
In response to both Noah and mlimber,
I am not at all bothered with whether one form is easier to understand
than the other -- I am solely concerned with performance.
Different compilers (and optimizers!) will produce different code, and
some CPU architectures and memory/cache configurations may do some
things more efficiently than others. So there's really no way to
determine which is faster in general. You could use a profiler on your
particular system to see which is faster on that system, but I strongly
suspect you're barking up the old "premature optimization" tree (see,
e.g., "Beware Premature Optimization" in
http://www.gotw.ca/publications/mill09.htm).
If I wanted to simplify it, I could write a macro or a template function.
I suppose I could rephrase my question as follows:
Which of the following two macros would be preferable (performance-wise)
for use in portable code?:
#define IncrementIfTrue(amount,true_or_false)\
{ amount += static_cast<bool>( true_or_false ); }
#define IncrementIfTrue(amount,true_or_false)\
{ if ( true_or_false ) ++amount; }
To be used as follows:
#include <cstddef>
unsigned AmountSixes( const int *p, std::size_t const len )
{
unsigned amount = 0;
const T* const p_over = array + len;
do
{
IncrementIfTrue( amount, *p++ == 6 );
}
while ( p != p_over );
return amount;
}
First of all, macros should be avoided when possible because of all
their "issues" (see
http://www.parashift.com/c++-faq-lite/inline-functions.html#faq-9.5).
Second, using a macro or inline function or your clever code here just
obfuscates your meaning again. Write code for humans, not the CPU (let
the compiler/optimizer worry about that!), until you have measured (not
intuited!) that hand optimizing would be of significant benefit.
Cheers! --M