As mentioned above, libraries have header files that define
information to be used in conjunction with the libraries, such as
functions and data types. When you include a header file, the compiler
adds the functions, data types, and other information in the header file
to the list of reserved words and commands in the language. After that,
you cannot use the names of functions or macros in the header file to
mean anything other than what the library specifies, in any source
code file that includes the header file.
The most commonly used header file is for the standard input/output
routines in glibc and is called stdio.h. This and other
header files are included with the #include command at the top of
a source code file. For example,
#include "name.h"
includes a header file from the current directory (the directory in
which your C source code file appears), and
#include <name.h>
includes a file from a system directory -- a standard GNU
directory like /usr/include. (The #include command is
actually a preprocessor directive, or instruction to a program
used by the C compiler to simplify C code. (See Preprocessor directives, for more information.)
Here is an example that uses the #include directive to include
the standard stdio.h header in order to print a greeting on the
screen with the printf command. (The characters \n cause
printf to move the cursor to the next line.)
#include <stdio.h>
int main ()
{
printf ("C standard I/O file is included.\n");
printf ("Hello world!\n");
return 0;
}
If you save this code in a file called hello.c, you
can compile this program with the following command:
gcc -o hello hello.c
As mentioned earlier, you can use some library functions without having
to link library files explicitly, since every program is always linked
with the standard C library. This is called libc on older
operating systems such as Unix, but glibc ("GNU libc") on
GNU systems. The glibc file includes standard functions for
input/output, date and time calculation, string manipulation, memory
allocation, mathematics, and other language features.
Most of the standard glibc functions can be incorporated into
your program just by using the #include directive to include the
proper header files. For example, since glibc includes the
standard input/output routines, all you need to do to be able to call
printf is put the line #include <stdio.h> at the beginning
of your program, as in the example that follows.
Note that stdio.h is just one of the many header files you will
eventually use to access glibc. The GNU C library is
automatically linked with every C program, but you will eventually need
a variety of header files to access it. These header files are not
included in your code automatically -- you must include them yourself!
#include <stdio.h>
#include <math.h>
int main ()
{
double x, y;
y = sin (x);
printf ("Math library ready\n");
return 0;
}
However, programs that use a special function outside of glibc
-- including mathematical functions that are nominally part of
glibc, such as function sin in the example above! -- must
use the -l option to gcc in order to link the
appropriate libraries. If you saved this code above in a file called
math.c, you could compile it with the following command:
gcc -o math math.c -lm
The option -lm links in the library libm.so, which is
where the mathematics routines are actually located on a GNU system.
To learn which header files you must include in your program in order to
use the features of glibc that interest you, consult Table of Contents. This document
lists all the functions, data types, and so on contained in
glibc, arranged by topic and header file. (See Common library functions, for a partial list of these header files.)
Note: Strictly speaking, you need not always use a system
header file to access the functions in a library. It is possible to
write your own declarations that mimic the ones in the standard header
files. You might want to do this if the standard header files are too
large, for example. In practice, however, this rarely happens, and this
technique is better left to advanced C programmers; using the header
files that came with your GNU system is a more reliable way to access
libraries.
