However, the use of == and
!= is likely to cause grief!
The representation of a floating point number in binary is
usually an approximation.
Thus:
double x, y;
x = ... ; y = ....; /* Some code setting values for x and y */
if( x == y ) {
.... /* This will rarely be executed! */
}
else {
.... /* Mostly, this will be executed! */
}
You should write:
#define EPSILON 1e-10
some_function f( .... ) {
double x, y;
x = ...;
y = ...;
if ( fabs(x-y) < EPSILON ) {
.... /* Now this will be executed
when x and y differ by less than EPSILON */
}
else {
.... /* x and y differ by more than EPSILON */
}
fabs is defined in
<math.h> : it returns the absolute value of a
double.
Even better, might be not to check for an absolute difference,
but to look for a relative difference:
if ( fabs( (x-y)/x ) < EPSILON ) { ...
Now EPSILON represents a relative tolerance, not an absolute one.
Mixed mode arithmetic
When expressions contain both floating point and integer
variables or constants,
C promotes the integers to floating point values before
evaluation.
The detailed rules are quite complex and you should refer to a
text when in doubt.
However, in general, promotion will take place only when necessary.
For example:
int j = 3, k = 4;
double x;
x = j/k;
will result in the value 0 in x.
j/k
is evaluated as an integral expression (both components
are integers) and then converted to a double.
However,
int j = 3, k = 4;
double x;
x = j;
x = x/k;
will produce 0.75 as the value of
x, because
x = j
results in 3.0 in
x and when
x/k is evaluated,
k is converted to 4.0
before being used to evaluate the expression.
Generally, if you combine an integer and a floating point value in
a term (two values and an operator), then the integer will be
promoted to match the type of the floating point value (
float
or double).
You can use parentheses to determine exactly what happens: eg
don't write:
int j, k;
double x, y;
...
y = x/j*k;
use parentheses to make the intent of your code clear:
int j, k;
double x, y;
...
y = (x/j)*k;
has two benefits:
- it forces j
to a double before evaluating x/j
and
- it ensures that you evaluate (x/j)*k
rather than x/(j*k).
The C standard defines precisely what a compiler should do when there
is ambiguity.
However there is no need to remember these arcane rules.
Using parentheses will always produce the intended result!
|
The precedence tables may be found in any C textbook.
The only time you should need to use them is when you have
to interpret someone else's code!
And when you've worked out what the original author (hopefully)
intended,
it's a good idea to insert the appropriate parentheses,
so that anyone following you is spared the need to reach for
the textbook and study some detailed and uninteresting rules!
Integer overflow
Be careful of integer expressions which are likely to produce
large numeric results.
int j, k, m;
j = 100000;
k = 300000;
m = j*k;
printf("m = %d\n", m);
produces
m = -64771072
because the product of j and k is 3x1010,
or more than the value of the largest 32-bit
int (~2x109).
C provides a long int type,
which may or may not use more bits (eg 64 rather than 32).
However, the standard is ambiguous on this and
allows a compiler implementer some choice.
Thus you must check the actual range for each implementation.
More on printf
We have seen that printf outputs characters from its
format string until it encounters % directives.
If the character following the % is a legal one,
then the next argument is formatted according to
some rules associated with that character and output to
standard output (or the appropriate stream for fprintf).
Here are some more formatting directives:
| Directive | Interpretation |
Space used
(characters) | Example |
|---|
| %d | Decimal integer | as many as needed | %d | 123456 |
| %nd | Decimal integer | At least n | %6d | 123456 |
| %no | Octal integer | At least n | %6o | 123456 |
| %nx | Hexadecimal integer | At least n | %6x | 12a4fc |
| %ld | Decimal integer
long int | as many as needed | %ld | 123456 |
| %lo, %lx | Octal, hexadecimal integer
long int | as many as needed | %lx | 1ac6bf32 |
| %c | Character | 1 | %c | A |
| %f | Float | as needed | %f | 1.23456 |
| %w.df | Float
Field width w spaces
d digits after
decimal point | At least w | %6.4 | -1.2345 |
| %e | Float
(exponential form) | as needed |
%f | 1.223456e+00 |
| %w.de | Float
(exponential form)
Field width w spaces
d digits after
decimal point | At least w | %10.4e | -1.2345e-01 |
| %w.dg | Float
(choose best form)
Field width w spaces
d digits after
decimal point | At least w | %10.4e | -0.12345 |
| %.ds | String
occupying d spaces | At least d |
%.10s | ABC123~~~~
(~ indicates a space) |
Note the at least entries, printf will use more space
than specified if the value won't fit in the allocated space!
The final example which shows how to print out a string so that it
uses exactly d character positions (so that you can line up
strings in tables) is unusual
- note the position of the point -
and needs to be remembered!
