faqcat38c2.html

this is a mirrored site c-faq. thought might need offline

because shifting is more efficient.
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
This is an excellent example of a potentially risky
and usually unnecessary optimization.
Any compiler worthy of the name can replace a
constant, power-of-two
multiplication with a left shift,
or a
similar
division of an unsigned quantity with a right shift.
(Ritchie's original PDP-11 compiler,
though it ran in less than 64K of memory
and omitted several features now considered mandatory,
performed both of these optimizations,
without even
turning on its optional optimization pass.)

Furthermore,
a compiler will make these optimizations only when they're correct;
many programmers overlook the fact
that shifting a negative value
to the
right
is <em>not</em> equivalent to division.
(Therefore,
when you need to make sure that these optimizations are performed,
you may have to declare relevant variables as <TT>unsigned</TT>.)
<hr><hr><hr>
<a name="unsshift">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../misc/unsshift.html"><!-- qtag -->Question 20.15b</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
People claim that optimizing compilers are good
and that we no longer have to write things in assembler for speed,
but
my compiler
can't even
replace <TT>i/=2</TT> with a shift.
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Was <TT>i</TT> signed or unsigned?
If it was signed,
a shift is not equivalent
(hint: think about the result if <TT>i</TT> is negative and odd),
so the compiler was correct not to use it.
<hr><hr><hr>
<a name="swapnotemp">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../misc/swapnotemp.html"><!-- qtag -->Question 20.15c</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I swap two values without using a temporary?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
The
standard hoary old assembly language programmer's
trick is:
<pre>
a ^= b;
b ^= a;
a ^= b;
</pre>
But this sort of code has little place in modern,
HLL programming.
Temporary variables are essentially free,
and the idiomatic code using three assignments,
namely
<pre>
	int t = a;
	a = b;
	b = t;
</pre>
is not only clearer to the human reader,
it is more likely to be recognized by the compiler
and turned into the most-efficient code
(e.g. perhaps even using an EXCH instruction).
The latter code is obviously also amenable
to use with pointers and floating-point values,
unlike the XOR trick.
See
also questions
<a href="faqcatee08.html?sec=expr#xorswapexpr">3.3b</a> and <a href="faqcat204f.html?sec=cpp#swapmacro">10.3</a>.
</p><p>Additional links:



<a href="../../misc/swap.homework.html">further reading</a>
<hr><hr><hr>
<a name="switchimpl">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../misc/switchimpl.html"><!-- qtag -->Question 20.16</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Which is more efficient,
a <TT>switch</TT> statement or an <TT>if</TT>/<TT>else</TT> chain?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
The differences,
if any,
are likely to be slight.

The <TT>switch</TT> statement was designed to be efficiently implementable,

though the compiler may
choose to
use the equivalent of an if/else chain
(as opposed to a
compact

jump table)
if the case labels are sparsely distributed.

</p><p>Do use <TT>switch</TT> when you can:
it's certainly cleaner,
and perhaps more efficient
(and certainly
should never be
any <em>less</em> efficient).
</p><p>See also questions <a href="faqcat38c2.html?sec=misc#strswitch">20.17</a>
and <a href="faqcat38c2.html?sec=misc#nonconstcase">20.18</a>.
<hr><hr><hr>
<a name="strswitch">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../misc/strswitch.html"><!-- qtag -->Question 20.17</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Is there a way to <TT>switch</TT> on strings?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Not directly.
Sometimes, it's appropriate
to use a separate function to map strings to integer codes,
and then switch on those:
<pre>
#define CODE_APPLE	1
#define CODE_ORANGE	2
#define CODE_NONE	0

switch(classifyfunc(string)) {
	case CODE_APPLE:
		...

	case CODE_ORANGE:
		...

	case CODE_NONE:
		...
}
</pre>
where <TT>classifyfunc</TT> looks something like
<pre>
static struct lookuptab {
	char *string;
	int code;
} tab[] = {
	{"apple",	CODE_APPLE},
	{"orange",	CODE_ORANGE},
};

classifyfunc(char *string)
{
	int i;
	for(i = 0; i &lt; sizeof(tab) / sizeof(tab[0]); i++)
		if(strcmp(tab[i].string, string) == 0)
			return tab[i].code;

	return CODE_NONE;
}
</pre>

</p><p>Otherwise, of course,
you can fall back on

a conventional <TT>if</TT>/<TT>else</TT> chain:
<pre>
	if(strcmp(string, "apple") == 0) {
		...
	} else if(strcmp(string, "orange") == 0) {
		...
	}
</pre>
(A macro like
<TT>Streq()</TT>
from question <a href="faqcataae2.html?sec=style#strcmp">17.3</a>
can make these comparisons a bit more convenient.)
</p><p>See also
questions <a href="faqcat204f.html?sec=cpp#ifstrcmp">10.12</a>, <a href="faqcat38c2.html?sec=misc#switchimpl">20.16</a>, <a href="faqcat38c2.html?sec=misc#nonconstcase">20.18</a>, and <a href="faqcat38c2.html?sec=misc#hash">20.29</a>.
</p>




<p>References:

K&amp;R1 Sec. 3.4 p. 55
<br>
K&amp;R2 Sec. 3.4 p. 58
<br>
ISO Sec. 6.6.4.2
<br>
H&amp;S Sec. 8.7 p. 248
<hr><hr><hr>
<a name="nonconstcase">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../misc/nonconstcase.html"><!-- qtag -->Question 20.18</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Is there a way to have non-constant <TT>case</TT> labels
(i.e. ranges or arbitrary expressions)?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
No.
The <TT>switch</TT> statement
was originally designed to be quite simple for the compiler to translate,
therefore case labels are limited to single, constant, integral expressions.
You <em>can</em> attach several case labels to the same statement,
which will let you cover a small range if you don't mind 
listing all cases explicitly.
</p><p>If you want to select on arbitrary ranges
or non-constant expressions,
you'll have to use an <TT>if</TT>/<TT>else</TT> chain.
</p><p>See also
questions <a href="faqcat38c2.html?sec=misc#switchimpl">20.16</a> and <a href="faqcat38c2.html?sec=misc#strswitch">20.17</a>.
</p>




<p>References:

K&amp;R1 Sec. 3.4 p. 55
<br>
K&amp;R2 Sec. 3.4 p. 58
<br>
ISO Sec. 6.6.4.2
<br>
Rationale Sec. 3.6.4.2
<br>
H&amp;S Sec. 8.7 p. 248
<hr><hr><hr>
<a name="returnparens">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../misc/returnparens.html"><!-- qtag -->Question 20.19</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Are the outer parentheses
in <TT>return</TT> statements
really optional?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Yes.
</p><p>Long ago,
in the early days of C,
they were required,
and just enough people learned C then,
and wrote code which is still in circulation,
that the
notion
that
they might still be required
is
widespread.
</p><p>(As it happens,
parentheses are optional with the
<TT>sizeof</TT>
operator, too,
under certain circumstances.)
</p>



<p>References:

K&amp;R1 Sec. A18.3 p. 218
<br>
ISO Sec. 6.3.3, Sec. 6.6.6
<br>
H&amp;S Sec. 8.9 p. 254
<hr><hr><hr>
<a name="nestcomment">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../misc/nestcomment.html"><!-- qtag -->Question 20.20</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Why don't C comments nest?
How am I supposed to comment out code containing comments?
Are
comments
legal inside quoted strings?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
C comments don't nest
mostly
because PL/I's comments,
which C's are borrowed from,
don't either.
Therefore,
it is usually better to ``comment out''
large sections of code, which might contain comments, with
<TT>#ifdef</TT> or <TT>#if 0</TT>
(but see question
<a href="faqcat7d4b.html?sec=ansi#ifdefsyntax">11.19</a>).
</p><p>The character sequences <TT>/*</TT> and <TT>*/</TT> are
not special within double-quoted
strings,
and do not therefore introduce comments,
because a program
(particularly one which is generating C code as output)
might want to print them.
(It is hard to imagine why anyone would want or need to place a
comment inside a quoted string.
It is easy to imagine a program needing to print "<TT>/*</TT>".)
</p><p>Note also that <TT>//</TT> comments
have only become legal in C as of C99.
</p>








<p>References:

K&amp;R1 Sec. A2.1 p. 179
<br>
K&amp;R2 Sec. A2.2 p. 192
<br>
ISO Sec. 6.1.9, Annex F
<br>
Rationale Sec. 3.1.9
<br>
H&amp;S Sec. 2.2 pp. 18-9
<br>
PCS Sec. 10 p. 130
<hr><hr><hr>
<a name="multibreak">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../misc/multibreak.html"><!-- qtag -->Question 20.20b</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
Why isn't there a numbered, multi-level <TT>break</TT> statement
to break out of several loops at once?
What am I supposed to use instead, a <TT>goto</TT>?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
First, remember why it is that <TT>break</TT> and <TT>continue</TT>
exist at all--they are,
in effect, ``structured <TT>goto</TT>s''
used in preference to <TT>goto</TT>
(and accepted as alternatives by most of those who shun <TT>goto</TT>)
because they are clean and structured and
pretty much
restricted to a common, idiomatic usages.
A hypothetical multi-level <TT>break</TT>, on the other hand,
would rapidly lose the inherent cleanliness of the single
<TT>break</TT>--programmers and readers of code
would have to carefully count nesting levels
to figure out what a given <TT>break</TT> did,
and the insertion of a new intermediately-nested loop
could, er, break things badly.
(By this analysis,
a numbered <TT>break</TT> statement can
be even more confusing and error-prone than a <TT>goto</TT>/label pair.)
</p><p>The right way to break out of several loops at once
(which C also does not have)
involves a syntax which allows the naming of loops,
so that a <TT>break</TT> statement can specify
the name of the loop to be broken out of.
</p><p>If you do have to break out of more than one loop at once
(or break out of a loop from inside a switch,
where <TT>break</TT> would merely end a <TT>case</TT> label)
yes, go ahead and use a <TT>goto</TT>.
(But when you find the need for a multi-level break,
it's often a sign that the loop should be broken out to its own function,
at which point you can achieve roughly the same effect
as that multi-level break
by using a premature return.)
<hr><hr><hr>
<a name="funkyasgnop">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../misc/funkyasgnop.html"><!-- qtag -->Question 20.21</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
There seem to be a few missing operators, like <TT>^^</TT>, 
<TT>&amp;&amp;=</TT>, and <TT>-&gt;=</TT>.
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
A logical
exclusive-or operator
(hypothetically ``<TT>^^</TT>'')
would be nice,
but it couldn't possibly have short-circuiting

behavior
analogous to <TT>&amp;&amp;</TT> and <TT>||</TT>
(see question <a href="faqcatee08.html?sec=expr#shortcircuit">3.6</a>).
Similarly,
it's not clear how short-circuiting would apply to
hypothetical assignment operators <TT>&amp;&amp;=</TT> and <TT>||=</TT>.
(It's also not clear
how often <TT>&amp;&amp;=</TT> and <TT>||=</TT>
would actually be needed.)
</p><p>Though <TT>p&nbsp;=&nbsp;p-&gt;next</TT> is an extremely common 
idiom for traversing a linked list,
<TT>-&gt;</TT> is not a binary arithmetic operator.
A
hypothetical
<TT>-&gt;=</TT> operator
therefore wouldn't really fit the pattern
of the other assignment operators.
</p><p>You can write an exclusive-or macro in several ways:
<pre>
	#define XOR(a, b) ((a) &amp;&amp; !(b) || !(a) &amp;&amp; (b))	/* 1 */
	#define XOR(a, b) (!!(a) ^ !!(b))		/* 2 */
	#define XOR(a, b) (!!(a) != !!(b))		/* 3 */
	#define XOR(a, b) (!(a) ^ !(b))			/* 4 */
	#define XOR(a, b) (!(a) != !(b))		/* 5 */
	#define XOR(a, b) ((a) ? !(b) : !!(b))		/* 6 */
</pre>

The first is straight from the definition,
but is poor because it may evaluate its arguments multiple times
(see question <a href="faqcat204f.html?sec=cpp#safemacros">10.1</a>).
The second and third
``normalize''
their operands
<a href="../../misc/norml.html" rel=subdocument>[footnote]</a>
to strict 0/1 by negating them twice--the
second then applies bitwise exclusive or
(to the single remaining bit);
the third one implements exclusive-or as <TT>!=</TT>.
The fourth and fifth are based on an elementary
identity in Boolean algebra,
namely that
<blockquote>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_&nbsp;&nbsp;&nbsp;_
<br>a&nbsp;(+)&nbsp;b&nbsp;=&nbsp;a&nbsp;(+)&nbsp;b
</blockquote>(where (+) is exclusive-or
and an overbar indicates negation).
Finally,
the sixth one,
suggested by Lawrence Kirby
and Dan Pop,
uses the <TT>?:</TT> operator
to guarantee a sequence point between the two operands,
as for <TT>&amp;&amp;</TT> and <TT>||</TT>.
(There is still no ``short circuiting'' behavior,
though,
nor can there be.)
</p><p>Additional links:
A




<a href="../../misc/xor.dmr.html">definitive answer</a>
from Dennis Ritchie about <TT>^^</TT>
<hr><hr><hr>
<a name="circshift">
<h1>
comp.lang.c FAQ list