Overview of C Language.

The C Programming Language

Objective-C is based on a programming language called, quite simply, C. The origins of the C programming language can be traced back nearly 40 years to two engineers named Dennis Ritchie and Ken Thompson working at what is now known as AT&T Bell Labs. At the time, the two were working on developing the UNIX operating system on PDP-7 and PDP-11 systems. After attempts to write this operating system using assembly language (essentially using sequences of instruction codes understood by the processor), it was decided that a higher level, more programmer friendly programming language was required to handle the complexity of an operating system such as UNIX. The first attempt was a language called B. The B language, which was based on a language called BCPL, was found to be lacking. Taking the next initial from the BCPLname, the C language was created and subsequently used to write much of the UNIX operating system kernel and infrastructure. As far as we can tell, C was so successful that new languages named P and L never needed to be created.

a tutorial for the computer programming language C. Unlike BASIC or

Pascal, C was not written as a teaching aid, but as a professional tool. Programmers love

C! Moreover, C is a standard, widely-used language, and a single C program can often be

made to run on many dierent kinds of computer. 

1 Introduction

What is a high-level language? Why is C unusual?

Any suciently complex object has levels of detail; the amount of detail we see depends

on how closely we scrutinize the object. A computer has many levels of detail.

The terms low level and high level are often used to describe these layers of complexity

in computers. The low level is buried in the computer's microchips and microcircuits. The

low level is the level at which the computer seems most primitive and mechanical, whereas

the high level describes the computer in less detail, and makes it easier to use.

You can see high levels and low levels in the workings of a car. In a car, the nuts, bolts,

and pistons of the low level can be grouped together conceptually to form the higher-level

engine. Without knowing anything about the nuts and bolts, you can treat the engine as a

black box: a simple unit that behaves in predictable ways. At an even higher level (the one

most people use when driving), you can see a car as a group of these black boxes, including

the engine, the steering, the brakes, and so on. At a high level, a computer also becomes a

group of black boxes.

C is a high-level language. The aim of any high-level computer language is to provide

an easy, natural way to give a list of instructions (a computer program) to a computer.

The native language of the computer is a stream of numbers called machine language. As

you might expect, the action resulting from a single machine language instruction is very

primitive, and many thousands of them can be required to do something substantial. A

high-level language provides a set of instructions you can recombine creatively and give

to the imaginary black boxes of the computer. The high-level language software will then

translate these high-level instructions into low-level machine language instructions.

1.1 The advantages of C

C is one of a large number of high-level languages designed for general-purpose program-

ming, in other words, for writing anything from small programs for personal amusement to

complex industrial applications.

C has many advantages:

 Before C, machine-language programmers criticized high-level languages because, with

their black box approach, they shielded the user from the working details of the com-

puter and all its facilities. C, however, was designed to give access to any level of the

computer down to raw machine language, and because of this, it is perhaps the most

exible high-level language.

 C has features that allow the programmer to organize programs in a clear, easy, logical

way. For example, C allows meaningful names for variables without any loss of eciency, yet it gives a complete freedom of programming style, including  exible ways of making decisions, and a set of exible commands for performing tasks repetitively

 1: Introduction

 C is succinct. It permits the creation of tidy, compact programs. This feature can

be a mixed blessing, however, and the C programmer must balance simplicity and

readability.

 C allows commands that are invalid in other languages. This is no defect, but a powerful

freedom which, when used with caution, makes many things possible. It does mean

that there are concealed di

culties in C, but if you write carefully and thoughtfully,

you can create fast, e

cient programs.

 With C, you can use every resource your computer o

ers. C tries to link closely with

the local environment, providing facilities for gaining access to common peripherals

like disk drives and printers. When new peripherals are invented, the GNU community

quickly provides the ability to program them in C as well. In fact, most of the GNU

project is written in C (as are many other operating systems).

For the reasons outlined above, C is the preeminent high-level language. Clearly, no

language can guarantee good programs, but C can provide a framework in which it is easy

to program well.

1.2 Questions for Chapter 1

1. Explain the distinction between high levels and low levels.

2. What is a \black box"?

3. Name a few advantages to programming in the C language.The compiler 3

2 Using a compiler

How to use a compiler. What can go wrong.

The operating system is the layer of software that drives the hardware of a computer and

provides the user with a comfortable work environment. Operating systems vary, but most

have a shell, or text interface. You use the GNU shell every time you type in a command

that launches an email program or text editor under GNU.

In the following sections of this chapter, we will explore how to create a C program from

the GNU shell, and what might go wrong when you do.

2.1 Basic ideas about C

First a note about a programming language that is di

erent from the C programming

language, the GNU shell. When you enter commands in the GNU shell, they are executed

immediately. Moreover, the shell is a programming language, in that the commands you

type are a program, because you can also create a text 

le containing many shell commands.

When you run this 

le, the commands will be executed in sequence.

On the other hand, consider C. While a shell command 

le can be executed directly, a

C program must be created in two stages:

1. First, the program is written in the form of text 

les with a text editor such as GNU

Emacs. This form of the program is called the source code. A computer cannot execute

source code directly.

2. Second, the completed source code is processed with a compiler | a program that

generates a new 

le containing a machine-language translation of the source code.

This 

le is called an executable  le, or executable. The executable  le is said to have

been compiled from the source code.

To run the compiled program, you must usually type the name of the executable 

le

preceded by a period and a slash, as in this example:

./myprogram

The \dot-slash" pre

x tells the GNU shell to look in the current directory for the executable.

You usually do not need to type `./' in front of commands for programs that came with

your GNU system, such as emacs, because the computer already knows where to look for

the executables of those programs, which were placed in special directories when your GNU

system was installed.

A C program is made up of, among other components, variables and functions. A variable

is a way to hold some data which may vary, hence the name. For example, a variable might

hold the number 17, and later the number 41. Another variable might hold the word \Sue".

A function is a segment of text in the source code of a program that tells the computer

what to do. Programming consists, in large part, of writing functions.4 Chapter 2: Using a compiler

2.2 The compiler

When you compile a program, the compiler usually operates in an orderly sequence of

phases called passes. The sequence happens approximately like this:

1. First, the compiler reads the source code, perhaps generating an intermediate code

(such as pseudo-code) that simpli

es the source code for subsequent processing.

2. Next, the compiler converts the intermediate code (if there is any) or the original

source code into an object code 

le, which contains machine language but is not yet

executable. The compiler builds a separate object 

le for each source  le. These are

only temporary and are deleted by the compiler after compilation.

3. Finally, the compiler runs a linker. The linker merges the newly-created object code

with some standard, built-in object code to produce an executable 

le that can stand

alone.

GNU environments use a simple command to invoke the C compiler: gcc, which stands for

\GNU Compiler Collection". (It used to stand for \GNU C Compiler", but now GCC can

compile many more languages than just C.) Thus, to compile a small program, you will

usually type something like the following command:

gcc 

le name

On GNU systems, this results in the creation of an executable program with the default

name `a.out'. To tell the compiler you would like the executable program to be called

something else, use the `-o' option for setting the name of the object code:

gcc -o program name 

le name

For example, to create a program called `myprog' from a 

le called `myprog.c', write

gcc -o myprog myprog.c

To launch the resulting program `myprog' from the same directory, type

./myprog

2.3 File names

GCC uses the following 

le name conventions:

Source code 

le program name.c

Object 

le program name.o

Executable 

le program name (no ending)

Header 

le name.h

Library 

le libname.a or libname.so

The 

le name endings, or  le extensions, identify the contents of  les to the compiler. For

example, the `.c' su

x tells the compiler that the  le contains C source code, and the other

letters indicate other kinds of 

les in a similar way.Errors 5

2.4 Errors

Errors are mistakes that programmers make in their code. There are two main kinds of

errors.

 Compile-time errors are errors caught by the compiler. They can be syntax errors, such

as typing fro instead of for, or they can be errors caused by the incorrect construction

of your program. For example, you might tell the compiler that a certain variable is

an integer, then attempt to give it a non-integer value such as 5.23. (See Section 2.4.2

[Type errors], page 6.)

The compiler lists all compile-time errors at once, with the line number at which each

error occurred in the source code, and a message that explains what went wrong.

For example, suppose that, in your 

le `eg.c' you write

y = sin (x];

instead of

y = sin (x);

(By the way, this is an example of assignment. With the equals sign (`='), you are

assigning the variable y (causing the variable y to contain) the sine of the variable x.

This is somewhat di

erent from the way equals signs work in mathematics. In math,

an equals sign indicates that the numbers and variables on either side of it are already

equal; in C, an equals sign makes things equal. Sometimes it is useful to think of the

equals sign as an abbreviation for the phrase \becomes the value of ".)

Ignore the syntactic details of the statements above for now, except to note that clos-

ing the (x) with a square bracket instead of a parenthesis is an error in C. Upon

compilation, you will see something like this error message:

error

eg.c: In function `main':

eg.c:8: parse error before `]'

(If you compile the program within Emacs, you can jump directly to the error. We will

discuss this feature later. See Chapter 23 [Debugging], page 231, for more information.)

A program with compile-time errors will cause the compiler to halt, and will not produce

an executable. However, the compiler will check the syntax up to the last line of your

source code before stopping, and it is common for a single real error, even something

as simple as a missing parenthesis, to result in a huge and confusing list of nonexistent

\errors" from the compiler. This can be shocking and disheartening to novices, but

you'll get used to it with experience. (We will provide an example later in the book.

See Chapter 23 [Debugging], page 231.)

As a rule, the best way to approach this kind of problem is to look for the 

rst error,

x that, and then recompile. You will soon come to recognize when subsequent error

messages are due to independent problems and when they are due to a cascade.

 Run-time errors are errors that occur in a compiled and running program, sometimes

long after it has been compiled.

One kind of run-time error happens when you write a running program that does not

do what you intend. For example, you intend to send a letter to all drivers whose6 Chapter 2: Using a compiler

licenses will expire in June, but instead, you send a letter to all drivers whose licenses

will ever expire.

Another kind of run-time error can cause your program to crash, or quit abruptly. For

example, you may tell the computer to examine a part of its memory that doesn't exist,

or to divide some variable by zero. Fortunately, the GNU environment is extremely

stable, and very little will occur other than an error message in your terminal window

when you crash a program you are writing under GNU.

If the compilation of a program is successful, then a new executable 

le is created.

When a programmer wishes to make alterations and corrections to a C program, these

must be made in the source code, using a text editor; after making the changes, the pro-

grammer must recompile the program, or its salient parts.

2.4.1 Typographical errors

The compiler can sometimes fail for very simple reasons, such as typographical errors,

including the misuse of upper- and lower-case characters. The C language is case-sensitive.

Unlike languages such as Pascal and some versions of BASIC, C distinguishes between

upper- and lower-case letters, such as `A' and `a'. If a letter is typed in the wrong case in a

critical place in the source code, compilation will fail. This is a potential source of errors

that are di

cult to  nd.

2.4.2 Type errors

C supports a variety of variable types (di

erent kinds of variables for di erent kinds of

data), such as integer for integer numbers, and float for numbers with fractional parts.

You can even de

ne your own types, such as total for a sum, or surname for someone's

last name. You can also convert a variable of one type into other types. (This is called type

coercion.) Consequently, the type of a variable is of great importance to the compiler.

C requires us to list the names and types of all variables that will be used in a program,

and provide information about where they are going to be used. This is called declaring

variables. If you fail to declare a variable, or use it as if it were a di

erent type from the

type it is declared to be, for example, by assigning a non-integer value to an integer variable,

you will receive a compile-time error.

See Chapter 5 [Variables and declarations], page 19, for more information on variable

declarations. See Chapter 3 [The form of a C program], page 9, for some simple examples

of variable declarations.

2.5 Questions for Chapter 2

1. What is a compiler?

2. How does one run a C program?Questions for Chapter 2 7

3. How does one usually compile a C program?

4. Are upper and lower case equivalent in C?

5. What the two main kinds of error that can occur in a program?

6. If you had some C source code that you wished to call \accounts", under what name

would you save it?

7. What would be the name of the executable 

le for the program in the last question?

8. How would you run this program?8 Chapter 2: Using a compilerA word about style 9

3 The form of a C program

What goes into a C program? What does one look like?

The basic building block of a C program is the function. Every C program is a collection

of one or more functions. Functions are made of variable declarations and statements, or

complex commands, and are surrounded by curly brackets (`{' and `}').

One and only one of the functions in a program must have the name main. This function

is always the starting point of a C program, so the simplest C program is a single function

de

nition:

main ()

{

}

The parentheses `()' that follow the name of the function must be included. This is how C

distinguishes functions from ordinary variables.

The function main does not need to be at the top of a program, so a C program does not

necessarily start at line 1, but wherever the function called main is located. The function

main cannot be called, or started, by any other function in the program. Only the operating

system can call main; this is how a C program is started.

The next most simple C program is perhaps a program that starts, calls a function that

does nothing, and then ends.

/******************************************************/

/* */

/* Program : do nothing */

/* */

/******************************************************/

main() /* Main program */

{

do_nothing();

}

/******************************************************/

do_nothing() /* Function called */

{

}

(Any text sandwiched between `/*' and `*/' in C code is a comment for other humans to

read. See the section on comments below for more information.)

There are several things to notice about this program.

First, this program consists of two functions, one of which calls the other.

Second, the function do_nothing is called by simply typing the main part of its name

followed by `()' parentheses and a semicolon.

Third, the semicolon is vital; every simple statement in C ends with one. This is a signal

to the compiler that the end of a statement has been reached and that anything that follows

is part of another statement. This signal helps the compiler diagnose errors.10 Chapter 3: The form of a C program

Fourth, the curly bracket characters `{' and `}' outline a block of statements. When

this program meets the closing `}' of the second function's block, it transfers control back

to `main', where it meets another `}', and the program ends.

3.1 A word about style

The code examples above are simple, but they illustrate the control

ow of a C program,

or the order in which its statements are executed. You should note that these programs are

written in \old-fashioned" C, as the language existed before ANSI Standard C | the version

in which most C programs are now written. The above programs are also missing several

key elements that most C programs have, such as header 

les and function prototypes.

Finally, they do not show good style; if you wish to submit programs you write to the Free

Software Foundation, you should consult its advice on how best to use the C language.

You may wonder why we chose old-style C for these 

rst few examples, even though

people proverbially learn best what they learn 

rst. We did so because pre-ANSI C is con-

siderably simpler than the present form, and also because as you develop as a C programmer,

you will probably run across some old C code that you will want to read.

You may also wonder why a savvy programmer would want to follow the ANSI Standard,

which was drafted by committee, or even the GNU guidelines. Isn't programming free

software all about freedom? Yes, but following the ANSI Standard ensures that your code

can be easily compiled on many other computer platforms, and the GNU guidelines ensure

that your code can be read by other programmers. (We will introduce good C style in our

examples soon. Meanwhile, you can examine the GNU guidelines later in the book. See

Chapter 22 [Style], page 227.)

3.2 Comments

Annotating programs.

Comments are a way of inserting remarks and reminders into code without a

ecting its

behavior. Since comments are only read by other humans, you can put anything you wish

to in a comment, but it is better to be informative than humorous.

The compiler ignores comments, treating them as though they were whitespace (blank

characters, such as spaces, tabs, or carriage returns), and they are consequently ignored.

During compilation, comments are simply stripped out of the code, so programs can contain

any number of comments without losing speed.

Because a comment is treated as whitespace, it can be placed anywhere whitespace is

valid, even in the middle of a statement. (Such a practice can make your code di

cult to

read, however.)

Any text sandwiched between `/*' and `*/' in C code is a comment. Here is an example

of a C comment:Questions for Chapter 3 11

/* ...... comment ......*/

Comments do not necessarily terminate at the end of a line, only with the characters

`*/'. If you forget to close a comment with the characters `*/', the compiler will display an

`unterminated comment' error when you try to compile your code.

3.3 Example 1

#include <stdio.h> /* header file */

main () /* Trivial program */

{

/* This little line has no effect */

/* This little line has none */

/* This little line went all the way down

to the next line,

And so on...

And so on...

And so on... */

do_little();

printf ("Function 'main' completing.\n");

}

/**********************************************/

/* A bar like the one above can be used to */

/* separate functions visibly in a program */

do_little ()

{

/* This function does little. */

printf ("Function 'do_little' completing.\n");

}

Again, this example is old-fashioned C, and in mediocre style. To make it more compliant

with the ANSI Standard and GNU guidelines, we would declare the variable type each

function returns (int for main, which also requires an exit or return statement), and we

would create function prototypes at the beginning of the 

le. (See Chapter 4 [Functions],

page 13.)

3.4 Questions for Chapter 312 Chapter 3: The form of a C program

1. What is a block?

2. Does a C program start at the beginning? Where is the beginning?

3. What happens when a program comes to a `}' character? What does this character

signify?

4. What vital piece of punctuation goes at the end of every simple C statement?

5. What happens if a comment is not ended? That is if the programmer types `/*' .. to

start but forgets the ..`*/' to close?Function examples 13

4 Functions

Solving problems and getting results.

A function is a section of program code that performs a particular task. Making functions

is a way of isolating one section of code from other independent sections. Functions allow a

programmer to separate code by its purpose, and make a section of code reusable | that

is, make it so the section can be called in many di

erent contexts.

Functions should be written in the following form:

type function name (type parameter1 name, type parameter2 name, ...)

{

variable declarations

statements

...

...

...

}

You may notice when reading the examples in this chapter that this format is somewhat

di

erent from the one we have used so far. This format conforms to the ANSI Standard

and is better C. The other way is old-fashioned C, although GCC will still compile it.

Nevertheless, GCC is not guaranteed to do so in the future, and we will use ANSI Standard

C in this text from now on.

As shown above, a function can have a number of parameters, or pieces of information

from outside, and the function's body consists of a number of declarations and statements,

enclosed by curly brackets: `{...}'.

4.1 Function names

Every function has a name by which it is known to the rest of the program. The name

of a function in C can be anything from a single letter to a long word. The ANSI Standard,

however, only guarantees that C will be able to distinguish the 

rst 31 letters of identi ers, or

function and variable names. (Identi

ers are therefore said to have 31 signi cant characters.)

In some cases, identi

ers may have as few as six signi cant characters, to stay compatible

with older linkers, but this part of the ANSI Standard is becoming obsolete.

A function name must begin with an alphabetic letter or the underscore `_' character,

but the other characters in the name can be chosen from the following groups:

 Any lower-case letter from `a' to `z'

 Any upper-case letter from `A' to `Z'

 Any digit from `0' to `9'

 The underscore character `_'

Note that with GCC, you can also use dollar signs (`$') in identi

ers. This is one of

GCC's extensions to the C language, and is not part of the ANSI standard. It also may not

be supported under GCC on certain hardware platforms.14 Chapter 4: Functions

4.2 Function examples

Here is an example of a function that adds two integers and prints the sum with C's \print

formatted" function named printf, using the characters `%d' to specify integer output.

void add_two_numbers (int a, int b) /* Add a and b */

{

int c;

c = a + b;

printf ("%d\n", c);

}

The variables a and b are parameters passed in from outside the function. The code de

nes

a, b, and c to be of type int, or integer.

The function above is not much use standing alone. Here is a main function that calls

the add_two_numbers function:

int main()

{

int var1, var2;

var1 = 1;

var2 = 53;

add_two_numbers (var1, var2);

add_two_numbers (1, 2);

exit(0);

}

When these functions are incorporated into a C program, together they print the number

54, then they print the number 3, and then they stop.

4.3 Functions with values

In mathematics, a function takes one or more values and calculates, or returns, another

value. In C, some functions return values and others do not; whether a function you write

does or does not will depend on what you want the function to do. For example, a function

that calculates a value should probably return that value, while a function that merely

prints something out may not need to.

The add_two_numbers function above did not return a value. We will now examine a

function that does.

Here is an example of calling a function that returns a value:

bill = calculate_bill (data1, data2, data3);

When this statement is executed, control is passed to the function calculate_bill, that

function executes, and then it returns control and some value to the original statement.

The value returned is assigned to bill, and the program continues.Function prototyping 15

In C, returning a value from a function is a simple matter. Consider the function

calculate_bill as it might be written in a program that contains the statement above:

int calculate_bill (int a, int b, int c)

{

int total;

total = a + b + c;

return total;

}

As soon as the return statement is met, calculate_bill stops executing and returns the

value total.

A function that returns a value must have a return statement. Forgetting it can ruin a

program. For instance if calculate_bill had read as follows, then the variable bill would

have had no meaningful value assigned to it, and you might have received a warning from

the compiler as well. (The word void below indicates that the function does not return a

value. In ANSI C, you must place it before the name of any such function.)

void calculate_bill (int a, int b, int c)

{

int total;

total = a + b + c;

}

On the other hand, you do not need to actually use a value when a function returns

one. For example, the C input/output functions printf and scanf return values, but the

values are rarely used. See hunde

nedi [ les], page hunde nedi, for more information on

these functions.

If we use the 

rst version of the calculate_bill function (the one that contains the

line return total;), the value of the function can simply be discarded. (Of course, the

resulting program is not very useful, since it never displays a value to the user!)

int main()

{

calculate_bill (1, 2, 3);

exit (0);

}

4.4 Function prototyping

Functions do not have to return integer values, as in the above examples, but can return

almost any type of value, including

oating point and character values. (See Chapter 5

[Variables and declarations], page 19, for more information on variable types.)

A function must be declared to return a certain variable type (such as an integer),

just as variables must be. (See Chapter 5 [Variables and declarations], page 19, for more

information about variable types.) To write code in good C style, you should declare what

type of value a function returns (and what type of parameters it accepts) in two places:16 Chapter 4: Functions

1. At the beginning of the program, in global scope. (See Chapter 6 [Scope], page 27.)

2. In the de

nition of the function itself.

Function declarations at the beginning of a program are called prototypes. Here is an

example of a program in which prototypes are used:

#include <stdio.h>

void print_stuff (int foo, int bar);

int calc_value (int bas, int quux);

void print_stuff (int foo, int bar)

{

int var_to_print;

var_to_print = calc_value (foo, bar);

printf ("var_to_print = %d\n", var_to_print);

}

int calc_value (int bas, int quux)

{

return bas * quux;

}

int main()

{

print_stuff (23, 5);

exit (0);

}

The above program will print the text `var_to_print = 115' and then quit.

Prototypes may seem to be a nuisance, but they overcome a problem intrinsic to com-

pilers, which is that they compile functions as they come upon them. Without function

prototypes, you usually cannot write code that calls a function before the function itself is

de

ned in the program. If you place prototypes for your functions in a header  le, however,

you can call the functions from any source code 

le that includes the header. This is one

reason C is considered to be such a

exible programming language.

Some compilers avoid the use of prototypes by making a 

rst pass just to see what

functions are there, and a second pass to do the work, but this takes about twice as long.

Programmers already hate the time compilers take, and do not want to use compilers

that make unnecessary passes on their source code, making prototypes a necessity. Also,

prototypes enable the C compiler to do more rigorous error checking, and that saves an

enormous amount of time and grief.

4.5 The exit functionQuestions for Chapter 4 17

GNU coding standards specify that you should always use exit (or return) within your

main function. (See Chapter 22 [Style], page 227.)

You can use the exit function to terminate a program at any point, no matter how

many function calls have been made. Before it terminates the program, it calls a number

of other functions that perform tidy-up duties such as closing open 

les.

exit is called with a return code, like this:

exit(0);

In the example above, the return code is 0. Any program that calls your program can read

the return code from your program. The return code is like a return value from another

function that is not main; in fact, most of the time you can use the return command within

your main, instead of exit.

Conventionally, a return code of 0 speci

es that your program has ended normally and

all is well. (You can remember this as \zero errors", although for technical reasons, you

cannot use the number of errors your program found as the return code. See Chapter 22

[Style], page 227.) A return code other than 0 indicates that some sort of error has occurred.

If your code terminates when it encounters an error, use exit, and specify a non-zero return

code.

4.6 Questions for Chapter 4

1. Write a function that takes two values a and b, then returns the value of a * b (that

is, a times b.)

2. Is there anything wrong with a function that returns no value?

3. What happens if a function returns a value but you do not assign that value to anything?

4. What happens if a variable is assigned the result of a function, but the function does

not return a value?

5. How can you make a program terminate, anywhere in the program?18 Chapter 4: FunctionsInteger variables 19

5 Variables and declarations

Storing data. Discriminating types. Declaring data.

Variable names in C follow the same rules as function names, as far as what characters

they can contain. (See Section 4.1 [Function names], page 13.) Variables work di

erently

from functions, however. Every variable in C has a data type, or type, that conveys to the

the compiler what sort of data will be stored in it. Functions in C are sometimes said to

have types, but a function's type is actually the data type of the variable it returns.

In some older computer languages like BASIC, and even some newer ones like Perl, you

can tell what type a variable is because its name begins or ends with a special character.

For example, in many versions of BASIC, all integer variable names end with a percent sign

(`%') | for example, `YEAR%'. No such convention exists in C. Instead, we declare variables,

or tell the compiler that they are of a certain type, before they are used. This feature of C

has the following advantages (among others):

 It gives a compiler precise information about the amount of memory that will have to

be allotted to a variable when a program is run, and what sort of arithmetic will have

to be used with it (e.g. integer,

oating point, or none at all).

 It provides the compiler with a list of the variables so that it can catch errors in the

code, such as assigning a string to an integer variable.

There are a lot of variable types in C. In fact, you can de

ne your own, but there are

some basic types ready for use. We will discuss them in the following sections.

5.1 Integer variables

C has 

ve kinds of integer. An integer is a whole number (a number without a fractional

part). In C, there are a limited number of integers possible; how many depends on the type

of integer. In arithmetic, you can have as large a number as you like, but C integer types

always have a largest (and smallest) possible number.

 char: A single byte, usually one ASCII character. (See the section on the char type

below.)

 short: A short integer (16 bits long on most GNU systems). Also called short int.

Rarely used.

 int: A standard integer (32 bits long on most GNU systems).

 long: A long integer (32 bits long on most GNU systems, the same as int). Also called

long int.

 long long: A long long integer (64 bits long on most GNU systems). Also called long

long int.

64-bit operating systems are now appearing in which long integers are 64 bits long. With

GCC, long integers are normally 32 bits long and long long integers are 64 bits long, but

it varies with the computer hardware and implementation of GCC, so check your system's

documentation.20 Chapter 5: Variables and declarations

These integer types di

er in the size of the integer they can hold and the amount of

storage required for them. The sizes of these variables depend on the hardware and operating

system of the computer. On a typical 32-bit GNU system, the sizes of the integer types are

as follows.

Type Bits Possible Values

char 8 -127 to 127

unsigned char 8 0 to 255

short 16 -32,767 to 32,767

unsigned short 16 0 to 65,535

int 32 -2,147,483,647 to 2,147,483,647

unsigned int 32 0 to 4,294,967,295

long 32 -2,147,483,647 to 2,147,483,647

unsigned long 32 0 to 4,294,967,295

long long 64 -9,223,372,036,854,775,807 to 9,223,372,036,854,775,807

unsigned long long 64 0 to 18,446,744,073,709,551,615

On some computers, the lowest possible value may be 1 less than shown here; for example,

the smallest possible short may be -32,768 rather than -32,767.

The word unsigned, when placed in front of integer types, means that only positive or

zero values can be used in that variable (i.e. it cannot have a minus sign). The advantage

is that larger numbers can then be stored in the same variable. The ANSI standard also

allows the word signed to be placed before an integer, to indicate the opposite of unsigned.

5.1.1 The char type

char is a special integer type designed for storing single characters. The integer value of

a char corresponds to an ASCII character. For example, a value of 65 corresponds to the

letter `A', 66 corresponds to `B', 67 to `C', and so on.

As in the table above, unsigned char permits values from 0 to 255, and signed char

permits values from -127 (or -128) to 127. The char type is signed by default on some

computers, but unsigned on others. (See Appendix E [Character conversion table], page 259.

See Appendix D [Special characters], page 257.)

char is used only within arrays; variables meant to hold one character should be declared

int. (See Chapter 15 [Strings], page 105, for more information on character arrays. See

Section 5.4.1 [Cast operator demo], page 23, for an example of how to use an integer variable

to hold a character value.)

5.1.2 Floating point variablesDeclarations 21

Floating point numbers are numbers with a decimal point. There are di

erent sizes

of

oating point numbers in C. The float type can contain large

oating point numbers

with a small degree of precision, but the double-precision double type can hold even larger

numbers with a higher degree of precision. (Precision is simply the number of decimal

places to which a number can be computed with accuracy. If a number can be computed

to 

ve decimal places, it is said to have  ve signi cant digits.)

All

oating point mathematical functions built into C require double or long float

arguments (long float variables are generally the same as double variables on GNU sys-

tems), so it is common to use float only for storage of small

oating point numbers, and

to use double everywhere else.

Here are the

oating point variable types available in C:

 float: A single-precision

oating point number, with at least 6 signi

cant decimal

digits.

 double: A double-precision

oating point number. Usually the same as long float

on GNU systems. Has at least 10 signi

cant decimal digits.

 long double: Usually the same as double on GNU systems, but may be a 128-bit

number in some cases.

On a typical 32-bit GNU system, the sizes of the di

erent

oating point types are as

follows.

Type Bits Possible values (approx.)

float 32 1e-38 to 1e+38

double 64 2e-308 to 1e+308

long double 64 2e-308 to 1e+308

You may 

nd the  gures in the right-hand column confusing. They use a form of short-

hand for large numbers. For example, the number 5e2 means 5

---

 10^2, or 500. 5e-2 means

5

---

 10^  2 (5=100, or 1=20). You can see, therefore, that the float, double, and long

double types can contain some very large and very small numbers indeed. (When you work

with large and small numbers in C, you will use this notation in your code.)

5.2 Declarations

To declare a variable, write the type followed by a list of variables of that type:

type name variable name 1, ..., variable name n;

For example:

int last_year, cur_year;

long double earth_mass, mars_mass, venus_mass;

unsigned int num_pets;