Professional Documents
Culture Documents
EEE11 Lec08
EEE11 Lec08
3
¡ Header
files
contain
C
type
descriptions,
function
prototypes,
macros
and
special
variable
declarations.
¡ These
files
contain
valid
C
source
code
but
typically
does
not
produce
an
executable
program
on
its
own.
¡ Conventionally
named
*.h
¡ Used
with
#include
command
4
¡ a
set
of
libraries
that
are
available
in
any
standards-‐compliant
C
compiler
5
<assert.h>
Diagnostics
<stddef.h>
Common
definitions
<ctype.h>
Character
handling
<stdio.h>
Input
and
output
<errno.h>
Errors
<stdlib.h>
General
Utilities
<float.h>
Floating
point
charac.
<string.h>
Memory
and
String
handling
<limits.h>
Sizes
of
Integer
types
<tgmath.h>
Type-‐generic
math
<locale.h>
Localization
<time.h>
Date
and
Time
<math.h>
Mathematics
<wchar.h>
Extended
multibyte
<setjmp.h>
Non-‐local
jumps
and
wide
character
utilities
<signal.h>
Signal
handling
<wctype.h>
Wide
character
classification
<stdarg.h>
Variable
arguments
and
mapping
utilities
<stdbool.h>
Boolean
type
and
values
6
¡ Portability
refers
to
the
ability
of
the
code
to
be
used
in
different
environments
(e.g.
different
OS,
computer
architecture
J
)
¡ With
standard
libraries:
§ No
need
to
be
concerned
with
system-‐dependent
implementation
of
the
standard
library
functions
§ Porting
to
different
systems
is
typically
as
easy
as
recompiling
the
program
source
7
¡ Defines
the
assert()
macro
which
outputs
the
file,
line
number,
function
and
assertion
expression
when
the
assertion
fails.
§ void
assert(int
expr);
Example
void
foo(int
n){
assert(n
>
0);
/*
do
important
stuff
here
*/
}
¡ When
assertion
fails,
the
program
stops
with
the
message:
§ prog:
prog.c:12:
foo:
Assertion
`n
>
0'
failed
8
¡ Defines
macros
used
to
test
a
char
argument
and
two
functions
that
map
a
char
argument
(to
upper/lower
case)
9
¡ Using
the
macros
in
ctype
works
regardless
of
the
character
set
used
by
the
machine
(not
all
machines
use
ASCII).
¡ Using
the
macros
is
straightforward:
char
mychar='c';
if
(isupper(mychar)){
printf("the
character
%c
is
upper
case",
mychar);
}
if
(islower(letter)){
printf("the
character
%c
is
lower
case",
mychar);
}
10
¡ Floating
point
characteristics
(particular
to
the
implementation
on
each
machine)
and
limits
(minimum,
maximum,
resolution)
¡ Examples
§ DBL_MAX
-‐
maximum
value
of
a
double
§ DBL_EPSILON
–
the
minimum
magnitude
representable
§ FLT_DIG
–
number
of
decimal
digits
that
can
reliably
be
represented
given
the
limitations
in
floating
point
representation
11
¡ limits.h
contains
macros
defining
various
integer
type
characteristics
¡ Examples:
§ CHAR_BIT
/*
number
of
bits
in
a
byte
*/
§ WORD_BIT
/*
number
of
bits
in
an
int
*/
§ INT_MIN
/*
minimum
value
of
an
int
*/
§ for
more
info,
refer
to
the
manpage
entry
for
limits.h
¡ Useful
if
your
program
needs
to
work
on
multiple
different
systems
and
it
relies
on
knowing
machine
dependent
integer
type
characteristics.
12
¡ sin(),
cos(),
tan(),
acos(),
asin(),
atan()
▪ Uses
RADIANS
¡ cosh(),
sinh(),
tanh()
–
hyperbolic
functions
¡ exp(),
log(),
log10()
–
exponentiation
(base
is
the
natural
number
e),
logarithms
(log
returns
the
base
e
logarithm
of
the
argument).
¡ ceil(),
floor()
–
ceiling
and
floor
functions
¡ fabs()
-‐
floating
point
absolute
value
¡ fmod()
–
floating
point
modulo
division
¡ pow()
-‐
power
function
¡ sqrt()
-‐
square
root
function
13
¡ printf,
scanf
and
related
functions
¡ basic
C
file
I/O,
character
I/O
¡ File
I/O
funtions
and
definitions
(to
be
discussed)
14
¡ Contains
assorted
functions
and
definitions
for
general
use
¡ Contains
functions
for
§ Dynamic
memory
allocation
:
calloc(),
malloc(),
realloc(),
free()
§ Searching
and
sorting
:
bsearch(),
qsort()
§ Pseudo
random
number
generation
:
rand(),
srand()
§ Communicating
with
the
environment
:
getenv(),
system()
§ Integer
arithmetic
:
abs(),
labs(),
div(),
ldiv()
§ String
conversion
:
ato..(),
strto...()
§ Multibyte
character
functions
and
string
functions
§ Program
termination
:
abort(),
atexit(),
exit()
15
16
¡ Property
of
a
system
to
be
decomposed
into
smaller,
self-‐contained
parts.
§ A
system
built
using
a
divide-‐and-‐conquer
strategy
will
exhibit
a
degree
of
modularity.
¡ Each
self-‐contained
part
is
called
a
module.
§ Contents
of
each
module
are
ideally
related
(associated
with
the
a
common
object/task)
§ The
system's
functionalities
can
be
traced
to
specific
modules.
17
¡ System
complexity
becomes
harder
to
manage
as
it
gets
bigger.
(imagine
maintaining
1,000+
lines
of
code).
¡ Smaller,
more
focused
problems
are:
§ easier
to
solve
§ easier
to
understand
§ easier
to
test
against
a
solution
¡ Software
systems
have
an
uncanny
tendency
to
grow
larger
than
originally
planned.
18
¡ Modules
in
C
can
be
a:
§ library
§ source
file
§ function
¡ The
guideline
is
to
keep
those
things
that
support
a
particular
functionality
close
together.
19
¡ Workspace
refers
to
the
group
of
source
code,
header
files
and
libraries
used
to
build
the
output
§ Sometimes
referred
to
as
project
¡ Separate
source
files
are
created,
each
having
its
own
header
file
¡ Only
one
source
file
in
the
workspace
will
contain
the
main(
)
function
§ This
calls
functions
from
other
source
files
in
the
workspace
§ Usually,
this
source
file
contains
ONLY
the
main
function
20
¡ myprogram.c
¡ util.c
#include <stdio.h>
int get_factorial(int val)
#include “util.h”
{
int main(void)
if (val == 0 || val == 1)
{
return 1;
int num;
else if (val > 1)
scanf(“%d”, &num);
return val*get_factorial(val-1);
if (num < 0 || num > 12)
else
return 1;
return -1;
num = get_factorial(num);
}
printf(“%d\n”, num);
return 0;
¡ util.h
}
int get_factorial(int val);
21
build
command:
$gcc
myprogram.c
util.c
22
¡ When
myprogram.c
is
compiled,
it
assumes
get_factorial()
is
implemented
elsewhere
§ Definition/usage
of
get_factorial()
is
detected
by
preprocessor
in
util.h
23
24