Using QuickC PDF

#
Werner
Feibel
L
i
Using QuickC
®
Using QuickC
Werner Feibel
Osborne McGraw-Hill
Berkeley, California
Osborne McGraw-Hill
2600 Tenth Street
Berkeley, California 94710
U.S.A.
For information on translations and book distributors outside of the U.S.A., write to
Osborne McGraw-Hill at the above address.
A complete list of trademarks appears on page 595.
Using QuickC®
Copyright © 1988 by McGraw-Hill, Inc. All rights reserved. Printed in the United States of
America. Except as permitted under the Copyright Act of 1976, no part of this publication
may be reproduced or distributed in any form or by any means, or stored in a database or

retrieval system, without the prior written permission of the publisher, with the exception
that the program listings may be entered, stored, and executed in a computer system, but
they may not be reproduced for publication.
1234567890 DODO 8987

ISBN 0-07-881292-5
information has been obtained by Osborne McGr«w-Hill from sources believed to be reliable. However,
because of the possibility of human or mechanical error by our sources. Osborne McGraw-Hill, or others, Osborne
IVIcCraw-Hill does not guarantee the accuracy, adequacy, or completeness of any information and is not responsible
for any errors or omissions or the results obtained from use of such information.
For my parents, with love and thanks
for all they've done for me
J
Contents
Introduction xiii
Introducing C 1
C Features 2
An Example of C Programming 3
The Nature of C 5
Using C 7
Why QuickC U
A Quick Lool( at Quicl( C 13

Hands-on QuickC 14
Exploring Program Execution 28
QuickC Commands 3g
Summary 72
Simple Types and Operators 73

C Program Structure 74
Statements 80
Identifiers
g]
Variable Definition: Making Room 84
Simple Data Types 88
Variants on Simple Type 99
Constants lOi
Arithmetic Operators 107
printO Once More II3
Summary II4
Preprocessors and Programs 115

Program Structure 115
The C Preprocessor 119
)
Preprocessor Commands 122

Library Functions 135
Macros That Look Like Functions 141
Header and Other Inrlude Files 143
Summary 144
5 Reading and Writing in C 145

Reading Characters 146
More About printf( 153
Values and Variables: The Address Operator 158
Summary 165
6 Controlling C 167
Relational and Equality Operators 168
Logical Operators 170
The if-else Construct 172
The switch Statement 178
More Operators 182
Loops in C 186
Components of the while Loop 188
The do-while Loop 191
The for Loop 193
break and continue 201
Summary 204
7 Functioning in C 205
C Functions 206
Flow of Control 207
Function Returns 213
Formal and Actual Parameters 217
Summary 225
8 Function Prototypes 227

Influence of Prototypes on Syntax for Formal Parameters 231
Syntax: Old and New 237
Functions: Miscellaneous Points 237
Summary 238
9 Scope, Lifetime, and Storage Class 239

Scope and Visibility 239
Duration of Variables 249
Storage Class 251
Default Storage Classes and Storage Durations 259
Summary 261
)
10 Pointers 263
Objects, Lvalues, Values 264
Pointers 267
Pointers as Function Parameters 274
Pointer Arithmetic 280
Miscellaneous Points 284
Pointer Pitfalls 285
Summary 287
I 11 Arrays and Strings 289

Array Basics 290
Arrays and Pointers 293
Array Parameters 298
Strings 303
Multidimensional Arrays 315
Pointer Arrays 322
Summary 327
12 l\/lore on Functions and IVIore Functions 329

Functions Returning Pointers 330
Error Handling and stderr 338
Adding to Your Function Collection 344
Recursion 359
Summary 368
13 Command Line Arguments 369

main( ) as Program and as Function 370
What Are Command Line Arguments? 371
Command Line Arguments in DOS 372
Arguments to main( 376
A Program to Exercise Command Line Arguments 382
Summary 390
14 Fiies and l\/lemory 391

Files 392
Dynamic Memory Allocation 403
Summary 420
15 Bit and Other Operators 421

Bitwise Operators 421
The Conditional Operator 451
Summary 455
16 Structures, Unions, and Other Types 457
Structures 458
Bit-Fields 492
Unions 497
Enumeration Types 500
Summary 502
17 QuickC Library Functions 505

stdio.h 506
stdlib.h 515
string.h 525
ctype.h 536
dos.h 541
io.h 548
math.h 551
Other Files 555
Summary 556
A ASCII Codes 557
B Building Libraries in Quicl(C 559

Building Quick Libraries 560
Building Stand-Alone Libraries 564
Summary 569
C QuickC Command Summary 571

Commands for Calling QuickC 572
Useful Commands in the QuickC Environment 573
Editing Commands 573
Menu Commands 576
Compiling and Linking Outside of QuickC 584
Controlling the Linker 586
D Features of QuickC and IVIicrosoft C 5.0 589

Environment and Performance 589
Memory Models and Libraries 590
Debugging 592
Miscellaneous 593
Similarities 593
Index 597
Acknowledgments
Many people deserve thanks for making this book possible. The following
people were particularly helpful and encouraging throughout the project.
Kris Jamsa deserves thanks for his technical review and very helpful
suggestions. Many of the book's good features are there because of his
suggestions and corrections; the book's defects are there because I didn't listen
to Kris's objections.
I also wish to thank the people at Osborne/ McGraw-Hill who are always
helpful, friendly, and accommodating; it has been a pleasure to work with
them. Jeff Pepper deserves special thanks for getting this project started and
for keeping it on the smoothest course and Lyn Cordell
possible. Liz Fisher
helped keep me on course, and dealt gracefully and efficiently with ambiguous
materials and last minute changes, for which I thank them. Thanks also to the
unsung heroes in the art and production departments at Osborne/ McGraw-
Hill. They had to work extra hard (on a tight schedule made even tighter by
changes required late in the production process) to turn the manuscript into a
real book.
owe my friends many thanks for putting up with me and keeping
Finally, I
me going during the past few months. In particular, I want to thank Luanne
Panarotti, Scott Barnes, Alexa Beiser, Dan Kiely, and little Dylan Reiser
Kiely, whose favorite part of the project was the printer cable.
This book may have gotten done without these people, but it would have
been a lot less fun.
Introduction
Welcome to C and QuickC environment! You can use this book to

to the learn
about both the C language and the QuickC implementation.
C is a small but extremely powerful language that becoming the
is
language of choice for all sorts of software development Programs

projects.
written in C range from simple utilities through data base management
systems to compilers (including C compilers!) and operating systems. QuickC
is an interactive, easy-to-use, programming environment that provides all the
necessary components to create, compile, test, and run C programs.

QuickC is an ideal environment for learning C because it enables your
editor, compiler, and debugger to support each other. This makes the program
development process much faster and more convenient. For example, the
QuickC compiler can keep a record of the errors it finds while compiling your
program and put you back in the editor at the location of the first error when
the compiling is done. The QuickC editor lets you jump from one compiler
error to the next, and make all your corrections in one session. Then, with a
single keystroke, you can compile and run your program again. If you're
familiar with other compilers that require you to make corrections one at a
time (leaving the compiler and starting the editor as a separate program each
time), you will appreciate this feature. If you haven't worked with compilers
before, you'll learnfrom the start how convenient programming in C can be.
This book introduces you to the C programming language and shows you
how to use Quick C to write programs quickly and effectively. My purpose has
been to explain the advantages of C and the features of the QuickC program-
xlll
xiv Using QuickC
ming environment. In later chapters, youll find sections that illustrate how to
use various QuickC features as part of the discussion of particular C con-
structs. I've also included advice on some pitfalls you may encounter when
writing C programs and on how to avoid them.

The book focuses on the version of C implemented in QuickC and in the
Microsoft C version 5.0 compiler. This version of C conforms to the official
language definition currently being drafted, so you can also use this book to
learn C with other compilers.
The text contains lots of examples, since these usually illustrate a point
better than several paragraphs of description. Youll also find suggested modi-
ficationsand variations to try. The programs are designed to let you experi-
ment easily, and many of them will report on their own actions.
The best way to learn a programming language is to use it. Whether your
main interest is in C or QuickC, you'll get a lot more out of this book and —
enjoy it much more — if you enter the programs and examples and try them
out yourself Once you've done that, experiment with the examples; change
some of the functions or the input. One of the best ways to deepen your
understanding of a language is to experiment with it. Then, once you feel
comfortable with the material covered here, work on projects that interest you.
You'll find it is helpful, though not essential, to have some familiarity with
programming — perhaps with a language such as Pascal or BASIC. If you
have used either or both of these languages, you'll find that C differs in
important, and sometimes in very subtle, ways. If you have no programming
experience, don't worry. You'll still be able to use this book, but you may need
to put in some extra effort to be sure you understand some of the terms and
concepts.
Program Source Files
This book contains dozens of programs that illustrate C concepts. Many of

these programs are designed and exploration, and some
for experimentation
are quite entertaining to use, such as the trivial-fact generating programs in
Chapter 2. Throughout the book, I encourage you to play with the
programs —
to enter, compile, and run them —
and to observe the effects when
you modify them.
Introduction
The complete source code for all the programs is included here, so you can
simply type them in from the book. However, if you want to save yourself the
demands of that task, the source code for all the programs in this book (as well
as some additional programs and functions) can be purchased on two 360K
diskettes, for $22 ($20 plus $2 for postage and handling). The diskettes contain
about 450K of source files. In addition to the programs from the book, these
files include a quick and dirty program for testing functions during develop-
ment, a simple daily reminder program that you can tailor to your needs, and
several others.
To order the diskette, use the form that follows this introduction.
To order the source code diskettes for Using QuickC, please provide the
following information and a check or money order for the appropriate
amount:
$25 per copy ($20 + $5 shipping and handling) for foreign orders
$23 per copy ($20 + $2 shipping and handling + $ sales tax) for Massachu-
1
setts residents
$22 per copy ($20 + $2 shipping and handling) for other orders
Number of copies: Amount enclosed:
Name
Company (if applicable).
Street Address
City State ZIP Code.
Please send this information, along with your check or money order to:
Werner Feibel
P.O. Box 2499
Cambridge, MA 02238
Osborne/ McGraw-Hill assumes no responsibility for this offer. This is solely
the offer of Werner Feibel, and not of Osborne/ McGraw-Hill.
I
A
1
Introducing C
C is an elegantly simple language; it is also a challenge to programmers. At

times, you will love C; at other times, you'll hate it.
There is much to like about C: it is small, powerful, and when used

properly, C is fast, efficient and portable, meaning that it's moved easily from
one computer or operating system to another.
C lets you do marvelous things, such as building compilers, operating
systems, and editors. C can also turn nasty — overwriting compilers, operating
systems, editors, or whatever else you may have stored in your system's
memory.
C you the power and potential portability of high-level languages
gives
such as Pascal or Modula-2 along with the flexibility and destructive potential
of low-level languages, such as assembly language. C lets you build complex
data structures found in other high-level languages and enables you to manipu-
late individual bits of that data structure in ways normally possible only with
assembly language.
However, C will not protect your programs from themselves, and will let
them destroy your data if you are not careful.

Using QuickC
On balance, you'll be able to do all sorts of things with C, without getting

yourself into any more trouble than with another programming language — as
long as you don't get too fancy or too sloppy.
Every language — whether English or C — has a set of rules that defines
the language. For example, in English, a period ends a sentence. Such a set of
rules known as a syntax for the language. Learning the syntax is the easy part
is
of C; learning how to use the language to its fullest is your real challenge. Your
rewards, which include programming power and a better understanding of
your computer, are definitely worth the effort.
Microsoft Corporation's QuickC makes C
and accessible by
available
providing a complete, easy-to-use language implementation. QuickC is an
enhanced compiler (it converts programs into object code), a linker (it pro-
duces executable files), a shell (it serves as a command interpreter), and a rich
programming environment. With the help of this book, you'll be able to take
advantage of QuickC's special features, and make C work for you.
C Features
Several features make C a very attractive programming language for projects

large and small. These include performance features, such as speed and
efficiency of your executable program, and also features relating to the trans-
portability and modularity of programs. Modularity lets you break a large
program into small, manageable pieces, which you may be able to reuse in
other programs. Of course, the extent to which a particular program takes
advantage of these features of C depends on how well the program is written.
The examples in this text provide a solid foundation for you to develop good C
programs.
Performance Features
C is smaller than Pascal, Modula-2, or even BASIC. C has only about 30
keywords or reserved words. Because many of C's actions are close to
assembly-level activity, using C can increase the speed of your program and
make it easier to create concise, "optimized" expressions.
Introducing C
C gives you a complete set of tools. It's your job to maximize its potential.
Because C lets you get very close to the actual memory cells and registers in
your computer, you can do just about anything in a C program. This capability
makes C very powerful — ideal for complex projects, or programs that need to
take full advantage of the system on which they are running.
Portability
C can be very portable. One reason for C's portability is the preprocessor,
which makes it possible to substitute information specific to a particular
machine when compiling or running a program. As you'll see in later chapters,
you can use the preprocessor to help make your programs run faster.
IVIodularity
One feature that helps make C portable is its capacity to build programs out of
small functions and library modules that have already been compiled. The
library modules can contain C functions specific to a particular machine.
Because you can build and compile independent function libraries. C allows
you to write programs in a modular fashion. You can break large programs
into smaller units, which contain functions that can be used together in other
applications. Because individual modules are built and modified separately,

you can use a strategy that makes it easier to move programs to other
machines.
An Example of C Programming
The following listing shows one way of incorporating information from other
files into a program, and illustrates one way of increasing program portability.
/• Progreun showing the use of an Include file containing program specific

messages. Each program can have Its own system or program
specific include file.
•/
:
Using QuickC
#include "proginfo.h" /* a file containing various definitions. */
main C) /* the main C program */

<
/* write value of PROG_MESSAGE to screen */
printl ( "•/.s\n", PROG.MESSAGE)
}
The main program, the C function niain( ), simply writes something to

the screen: the value of something named PROG_MESSAGE.
The writing is done by the function printf( ), which is predefined for you in
QuickC and other C implementations. The function printf( ) writes whatever
you tell it to. In this case, the program tells it to write the value of
PROG_MESSAGE.
When it encounters the\n, printf( ) writes a carriage return and a line
feed, which puts the cursor at the leftmost column of the next line.
The % begins a placeholder for a particular type of information, whose
value is substituted when printf( ) writes the material; the s indicates that a
string is to be written. In our example, %s is the placeholder for PROG
MESSAGE, which contains a string. In C, a string is a sequence of characters
terminated by a special character, which we'll discuss later.
The escape code \n compact way of moving the cursor in a particular

is a
way. Later, we'll study the syntax for printf( ) in more detail, including how to
write other types of information (such as integers and real numbers), and there
will be more about escape codes, such as \n.
The structure of function main( ) illustrates the format of functions in C.

A function starts with a name (in this case, main), followed by parentheses
(which may have something between them). The main body of a function is
enclosed in braces.
Within the body of the function, individual statements end with a semi-
colon. Comments may appear anywhere in a program, and are enclosed
between /* and */.
Note that PROG MESSAGE is not defined anywhere in the program
file. Rather, this value is specified in the header file, proginfo.h, which the
compiler reads when processing the file containing the main program. Such
header files are common
Each system or program may have its own
in C.
header files. These files contain program or operating system specific values
and definitions. For example, when running under QuickC, the program's
Introducing C
message would read "QuickC Version 1.0"; running under Microsoft C Ver-
sion 5.0, the message might be "Microsoft C Version 5.0. "These messages are
stored in a file such as proginfo.h.
Most C compilers provide a file called stdio.h. which contains system-and
implementation-specific information, and which associates specific values,
such as "QuickC Version 1.0" with names, such as PROG MESSAGE.
Search your QuickC directories for files with the extension .h. These are the
header files provided with your compiler.
The Nature of C
C can be described as a middle-level language, having characteristics and
capabilities of both high- and low-level languages. This is one reason for its
apparently contradictory properties. C lets you create complex data struc-

tures, as do other high-level languages. However, unlike such languages, C
does minimal range and type checking when you use such variables. At the
other extreme, C lets you look at the contents of specific address locations in
memory; C even lets you do arithmetic with addresses. Such capabilities are
available in assembly languages, but rarely in high-level languages.
There are several reasons for C's contrasting features. It was designed to
be and portable. Dennis Ritchie, who developed C,
flexible, permissive, fast,
and Brian Kernighan, who was involved in much of the early work with C,
intended C to be useful for writing systems (such as operating systems) as well
as application programs (such as editors). Therefore, the developers gave C the
speed and flexibility of assembly language, but the data structures and control
constructs (such as if-then, for, while) of high-level languages.
Table 1-1 lists some properties of high- and low-level languages, and
indicates where C stands with respect to these properties. Note that C has
almost every property listed.
A Small Language
C has a very small vocabulary — only about 30 keywords. Although the words
are few, you can say a great deal with them. A small vocabulary does not mean
Using QuickC
Table 1-1. C Measured Against the Properties of High- and Low-level

Languages
High-level Languages C Low-level Languages
Structured yes yes Fast

Easy to use yes yes Compact
Safeguards yes/no yes (Can be) efficient
Complex data structures yes yes Address and bit manipulation
a weak language: some linguists claim that fewer than 900 words are needed
to communicate effectively in English.
On the other hand, C has lots of operators or symbols that cause specific
actions. In fact, C has more operators than keywords! This combination of a
small vocabulary and many operators lets you use C as a "construction set."
You can easily create individual statements or functions to do just the right
amount of work. As you'll see, C programs are usually built of small functions
that perform specific tasks. These functions are collected in modules and used
as needed.
The Power of C
Despite its smallC is being used for a huge range of programs. Large parts
size,
of the powerful UNIX and DOS operating systems are written in C. Similarly,
C has been used to write compilers (including C compilers), editors, typeset-
tingprograms (such as troff and TeX), and such programs as dBaselll and
Microsoft Windows.
At the other end of the spectrum, you will find many C programs that
perform specific tasks, such as display a calendar for any month or year, count
thenumber of words in a file, list the contents of a directory, find a particular
word or other expression in specified files, compute the interest payments on a
loan under various conditions, and so on. Source code for many of these
Introducing C
programs on electronic bulletin boards, from user groups, or in

is available
inexpensive utility packages. You may want to look at (or use) some of these
programs, to study and play with the code. In later chapters we'll look at a few
programs of this sort.
Standard Versions
There is as yet no official standard for C. Although C is used everywhere, it is
only now being officially defined. There has been a de facto standard version
of the language, summarized in The C Programming Language by Brian
Kernighan and Dennis Ritchie (Englewood Cliffs, New Jersey:
Prentice-Hall, 1978). This version of C is known as "K&R C," with compilers
often claiming that they implement "full K&R C," or "K&R C, with exten-
sions."
After several years, however, a standards committee is about to complete
its work on an official definition of the language. The working name for this
version is "Draft Proposed ANSI Standard C." Eventually, C's official name
will be "ANSI Standard C." (ANSI stands for American National Standards
Institute.)
The committee's task is to resolve ambiguities and to make it easier to

port C programs. Also, without sacrificing any of C's power, the committee
has added some of the high-level language features that help protect pro-
grammers from the consequences of their errors. The version of C emerging
from the deliberations of this committee will be more powerful than ever.
This book, QuickC itself, and most new C compilers will conform to the
draft version of the ANSI standard.
Using C
Getting a C program from idea to completion takes several steps, with each
step modifying or extending your program. In the next chapter you'll learn
how to write C
programs and get them to run using QuickC. This section
summarizes the main components of a C program and the major tasks
involved in getting from your text file to a running program. We'll see that
QuickC puts the tools for accomplishing various tasks under one program
Using QuickC
"shell." This makes it easy to move from one phase of the program creation
process to another.
When you create a C program, various types of files are created and used.
These include: source and header files created with a text editor; library and
other object files, linked with the compiled version of your main program file;
and an executable file that runs the program.
The first step is to create the program in text form — this is the source file.
The following listing is an example of a source file for a C program:
/* Sample C source file.

This program adds two numbers and writes the sum to the screen.
•/
#include "proginlo.h" /* file containing program specific information */
main () /* main program function */
int result: /* definition of an integer variable, named result */

printf ( "'/.s\n", PROG.MESSAGE) ;
il = 7 + 9; /* add 7+9. assign sum to result */

printf { "sum = '/,d\n" , result); /* write result to screen */
}
The output from this program is
The file contains the main program, niain( ), which calls printf( ), as did
our first example. There is also an instruction (#include "proginfo.h") to read
the contents of a header file, proginfo.h.
There are several new features. Notice that this program also writes
numerical information, the value of variable il. The %d (for decimal) place-
holder indicates this fact. In the second call to printf( ), the value to be
substituted is the value of il, which is 16 after the addition is carried out.
The second argument, information passed to printf(), is substituted for
the placeholder in the function's first argument. This simple replacement
strategy extends to handle additional arguments, as you'll soon see.
The program also illustrates how to define a variable in C, that is, how to
associate a data type with a variable name. (If you're not used to working with
data types, and are not sure what they are, don't worry. Data types are
explained in Chapter 3.) The variable il is defined to be of type int, for integer.
Introducing C
Finally, the statement,
assigns the result of adding 7 and 9 to the variable il. You'll learn about
variable definition and assignments in Chapter 3.
Compiling and Linking

The source file containing the listing is processed by the QuickC compiler,
which creates another version of the file by translating your program into
another form. During compilation, QuickC reads the header file proginfo.h
and makes the requested substitutions and definitions.
Source files include definitions for the functions you need in your pro-
gram, and may include definitions of variables used by multiple functions in
your program. There may also be instructions to read additional header or
other files. Your program will have one main source file, and may have
additional include files.
Header files are ordinary text files either written by you or provided with
the compiler. These files generally contain information needed for specific
tasks on a particular machine or with a particular compiler. Associated with
this information are mnemonic names, which are easier to remember than
obscure numerical values. When you use these names, the compiler substitutes
the values it finds for each name in the header files. For example, the header
file, proginfo.h, may contain the following:
/• Partial contents of file, proginfo.h. */
#define PROG.NAME "QuickC version 1.0" /* C version name */

•define MAX.INT 32767 /* largest integer value in system */
#define FALSE /* value to substitute when test is false */
The second statement provides a name for the largest integer represented
on the system. This name is much more meaningful than the actual number,
which may vary from machine to machine. When the compiler sees MAX
INT in the source file, it substitutes the value 32767. In the third instance, the
compiler substitutes the numerical value when you use false in your program.
(Later, you will see how C represents true and false.)
Such substitutions work out well for you and your program. You can use
.
10 Using QuickC
meaningful and easy-to-remember names. The compiler substitutes actual

values, so it need not look up the value associated with the name you used, as
would be necessary with variables. This makes your program run faster.
The compiler produces an object file that contains your program (as well
as other information) in a form more readily understood by the machine on
which the program runs. Your program may use functions that have already
been defined for you, or that you have defined elsewhere, compiled, and saved
in a separate file. A linker program combines the recently compiled object file
with function library files and other precompiled (object) files. The outcome of
this linking process is the program itself often known as an executable file.
Library Files
It is common among C programmers to build and use precompiled library files

containing commonly used functions. These functions are linked with a
program only if they are needed. This approach has several advantages. When
writing the program, you need not write the functions because they are already
written and available. When compiling, you need not compile the functions
each time because they are already compiled. This saves time, since the
compiled source file being composed is shorter.
Function libraries or modules make programs
it easier to build portable
because system-dependent functions can be collected in modules isolated from
system-independent functions. To move to a new system, only the modules
containing system-dependent functions need to be rewritten or replaced. The
new version can then be linked into your program after it has been recompiled
for the new system. Later, we will discuss library files and look at some of the
most commonly supplied functions. To summarize, a C program consists of
the following basic components:
1 Source files created with an editor and processed by the compiler. One
of these files contains the main program function, main( ). Every C
program must have at least one source file.
2. Optional header files, which may contain various values and defini-
tions for the program or the environment.
3. Library files and other object files, which are linked with your com-
Introducing C 11
piled program files at the appropriate point in the program develop-

ment process.
4. An executable file.
^REMEMBER
• There must be at least one source file — otherwise you have nothing to
compile or run.
• There must also be a function called inain( ) somewhere in the source

files.
• The program starts executing at main( ).
All files other than source files — headers, libraries, and so forth — are
optional.Whether you need such files, and how you add them, depends on the
C compiler you are using and the tasks you are trying to accomplish in your
program.
If all goes well, and the compilation and linking processes take place
without error, your program will be ready to run. Of course, that's often when
the real fun begins, when you discover the surprising things you've uninten-
tionally instructed your program to do.
^REMEMBER There are three steps in creating a C program:
1. Creating source file(s)
2. Compiling the source file(s)
3. Linking the resulting object file with whatever libraries and additional
modules are needed
Why QuickC?
QuickC makes it easy to carry out the steps required for C programming in a
flexible manner, within a tightly integrated and powerful environment. The
QuickC system provides a shell within which you can easily move from one
12 Using QuickC
Step to another when creating and testing your program.

You can edit, compile, link, debug (watch your program as it runs,
looking for errors, or bugs), and execute your program, all within QuickC.
Moreover, QuickC lets you specify options for any of these phases. This is very
easy to do with QuickC. For example, it takes just a single keystroke to tell
QuickC to optimize the program for speed (at program size); or you
the cost of
can ask it to warn you about any questionable programming practices, such as
constructs that violate the official language definition.
If you are used to writing programs, you know the tedium involved in
fixing small errors as the compiler encounters them. You must stop the
compilation, call up your editor, change your file, save it, call up the compiler,
find the next error, and so on.

In QuickC, all of this can be done within one program. After you have
created your source QuickC
you compile, link, and run it in just a few
file, lets
keystrokes. If there are any problems with the program, QuickC puts you back
You can edit the file, then tell QuickC
in the source file at the appropriate place.
to continue. The system then recompiles, relinks, and reruns the revised
program.
QuickC's integrated environment is also convenient for debugging. You
can trace the program's execution using the debugging facility. If a change is
needed, simply make QuickC to continue. Again, a few keystrokes

it, then tell
will get the system to reprocess your program and run it again, but this time in
debugging mode.
QuickC comes "preloaded" with many functions defined in separate
libraries by other C implementations. This gives you access to a more powerful
C without forcing you to link in separate libraries to get this power.
QuickC does its work quickly. In the next chapter, we will look
Best of all,
at the QuickC environment and explore it with a few sample programs.
Throughout the book, you will learn ways of taking particular advantage of
QuickC's environment.
A Quick Look
at QuickC
Microsoft's QuickC is a very powerful integrated program development

environment, which includes an editor (for creating your program files), a
compiler (for translating your programs into a form understandable to the
computer), and a debugger (for tracing the execution of your program to
identify errors in it). These components are all accessible within the QuickC
shell, so you can switch between them quickly. A linker is also available for use
by QuickC and as a separate program. There are many additional features,
such as on-line help, that make QuickC even nicer to use.
This chapter provides two kinds of information. The first half presents an
informal introduction to some of QuickC's features. You'll learn how to use
QuickC to create, compile, watch, and run your programs. This section is
designed to give you a chance to explore the most commonly used features of
13
14 Using QuickC
QuickC. It is by no means an exiiaustive discussion. Its purpose is to give you a

feel for C programs with QuickC. You may want to
what's involved in building
use the QuickC command summary in Appendix C as a supplement to this
introduction.
The second half of the chapter is a more systematic summary of the most
common QuickC commands for the editor, compiler, and debugger.
Hands-on QuickC
Although QuickC includes dozens of options and commands in its collection,
the chances are very good that a large proportion of the things you'll need to do
in most applications will involve only a dozen or so commands. In this part of
the chapter, we'll focus on some of these.

By becoming familiar with these commands, you can acquire enough
experience to use QuickC comfortably. This experience will provide a base to
which you can add other commands as you need them.
Since you haven't learned much about C yet, you'll have to do some
typing, trusting that the programs work without being told how they work.
The only way to learn something is to do it. So, you are strongly encouraged to
type in the programs and try the suggested activities.
To make this process somewhat more enjoyable, we'll build programs that
you can modify easily. This will enable you to play with the programs a bit to
add to your knowledge of QuickC and should also provide a bit of entertain-
ment. The programs will be as short as possible, while still producing an
interesting result. To keep them short, we've skipped many of the niceties and
checks that a sound program should have. If you find any of the programs
interesting, you may want to return to them later and make them more to your
liking.
So, let's get started. We'll assume you have QuickC installed on your hard
disk or on floppy disks and that you are currently in a directory or on a disk
from which you can access the qc.exe program. We'll also assume that you are
familiar with your keyboard, and that you know where keys such as the
RETURN, ALT, CTRL, DEL, INS, HOME, SHIFT, TAB, and BACKSPACE are
located.
A Quick Look at QuickC 15
A Quick Introduction
As you try things, you'll get a better feel for the command structure of QuickC.
You'll notice that commands generally tend to be either single keystrokes or a
combination of the ALT, CTRL, or SHIFT key with a letter key.
Also, as you spend more time in the QuickC environment, you'll notice
that it includes several menus, which provide you with access to QuickC's
components. To menu, you will need to press the ALT key together with
select a
a letter key (the first letter of the menu's name). Once in a menu, you can select
an option by pressing a letter key or highlighting the option and then pressing
RETURN. The default option is always highlighted when you get into a menu.
You can also call many commands directly —
that is, without going through a
menu. In the first half of this chapter we will give commands directly and with
a menu, depending on the command. In the second half of the chapter, you'll
learn the alternative ways of giving commands.
Selection of an option inside a menu generally brings you to a dialog box,
in which QuickC shows you the values it has for the options, and gives you a
chance to change some of these values. For these options, the default values
will generally be highlighted, and will be in effect if you just press RETURN.
Finally, if you ever find yourself in a position where you don't know the
command to accomplish something, just press the Fl function key, to call up
the on-line Help facility.
To get you started with QuickC, let's create a small C program. This will
give you an opportunity to use the editor and the compiler. The sequence of
steps described below will get you started. As you follow these steps, keep in
mind that you sometimes need to press RETURN (also called ENTER ) after
completing a command or a line. We'll mention this explicitly at first, but will
eventually stop reminding you. At other times, however, you should not press
RETURN.
To get QuickC to a point where you can start entering a program, type qc,
then press RETU rn. Once QuickC has started up, your screen should appear as
shown in Figure 2-1 You are now ready to start writing a program. Type in the
.
following program:
#define DIST 93000000.0
malnO
16 Using QuickC
printi ( "The sun is '/.li miles from the earth. \n". DIST) ;
To do this, just start typing. When you get to the end of the first line, press
RETU RN twice in succession to end the first line and to add a blank second line.
Type things exactly the way you find them in the listing; make sure to observe
the case of the characters. If you make a mistake, use the BACKSPACE key to
delete the error. Pressing backspace deletes the last character you typed.
File Edit Uieu Search Run Debug Calls
Progran List: <fione> Context: <Progran not conpiled>
Figure 2-1. The initial Quick C screen

A Quick Look at QuickC
To get the indentation in the fifth line (the one beginning with printf),
press the TAB key before starting to type the hne. When you press RETURN at
the end of this hne, you'll find the cursor directly under thep in printf -that is,
indented. Type the right curly brace. Then, to move it back to the leftmost
column, press the SHIFT and TAB keys simultaneously to get a "reverse tab."
When you've finished typing in the program, it's time to compile and run
it. To do so:
1. Press ALT-R (press the ALT and R keys simultaneously).
2. Press RETURN.
QuickC will quickly compile and run your program. You should get the
following output from the program:
The Bun Is 93000000.000000 miles from the earth.
This will be followed by a QuickC message telling you to press any key.
Congratulations, you've just finished running a QuickC program! To save
the program to disk,
1. Press any key, as instructed by QuickC.
2. Press ALT-F, but do not press RETURN.
3. Then press X (for Exit) or S (for Save), but do not press RETURN.
After verifying that you want to save the changes, QuickC will ask you for
a file name. Press the BACKSPACE key until you've erased the default name,
untitled.c. Type in the name under which you want to save the program. For
this discussion we'll use first.c. (Actually, all you need to type here is first.
QuickC adds the extension .c by default.) If you pressALT-F X, QuickC will

save your program under the name you specify and will return you to the DOS
prompt; if you press ALT-F S, QuickC will return you to the file after saving it.
To quit, press ALT-F X.
5 , ; ;
18 Using QuickC
Modifying tlie Program

Now, let's modify the file to make it do something more interesting. You can
start QuickC with your program file preloaded by including the file name on
the DOS command line when you call QuickC as shown here:
qc first
Notice that we did not include the QuickC file extension .c when telling
about the Unless you tell it otherwise, QuickC assumes you want to work
file.
with a file ending in .c. You can, of course, include the .c extension when you
type your file name on the preceding command line.
You're going to add several new lines to the program, and also delete one
line. Once you're in the QuickC environment, and have the first.c file open,
move the cursor to the line immediately below the #define line.
Start entering the additional #define statements in the following version
of the program. Make sure all the uppercase names are entered exactly as in
the listing, and make sure the #define is always in lowercase.
#def ine DIST 93000000.0

#def ine PTA "svin"
#def ine PTB "earth"
#def ine DIST.MESS "Distance between"
#def ine DIST.UNIT "miles"
#def ine SPEED 3 .
#def ine SPEED_MESS "Average human walking speed:

#def ine SPEED.UHIT "mph"
"
TIME.MESS "Time required to cover
TIME.UNIT "years"
»deline MAGIC.NR 8766 /* hours per year */
#def ine FORMULA DIST / SPEED / MAGIC.NR
mainO
printf ( "y.s y,s and Xs: '/.ll '/.B\n"
DIST MESS. PTA, PTB, DIST, DIST.UNIT)
printf ( "%s '/.If '/.sVn", SPEED.MESS, SPEED, SPEED.UNIT)
printf ( "'/.s '/.If y.8 = '/.If '/.s\n",
TIME_MESS. DIST. DIST.UNIT, FORMULA. TIME.UNIT):
Once you've added all the new #define lines, move the cursor down to the
line beginning with printf. When you're on that line, press CTRL-Y, to delete
the entire line. Enter the replacement lines from the preceding program.
—
Then and RETURN to run the new version of the program.

press ALT-R
You may get a message asking whether to rebuild your program. If you get this
message, pressRETURN to respond "yes."
The program now produces the following output:
Distance between sun and earth: 93000000.000000 miles

Average human walking speed: 3.500000 mph
Time required to cover 93000000.000000 miles ••3031.191895 years
To see what happens when you get a compiler error, let's go back into the
file and change something. Press the PGDN key to move near the end of the file.
Then use the arrow keys to move to the line, beginning with printf, that
contains references to SPEED_MESS, SPEED, and SPEED_UNIT in
each of these three names, delete one of the £'s, to give SPED — MESS,
SPED, and SPED_UN1T. To do this, use the CTRL-RIGHT arrow keys to
move the cursor to SPEED MESS. Then move to one of the £"s in this
word, using the RIGHT arrow key. Press DEL to delete this E. Then move to
SPEED and do the same thing. Finally, delete an £from SPEED_UNIT To
recompile and try to run, press ALT-R RETURN again. This time the compiler
gives you an error message, as shown in Figure 2-2.
The compiler tells you that SPED MESS is undefined, and that the
error is the first of three. Use the arrow keys to move to the E in SPED
MESS. Once there, simply type £ again.
Then press SH1FT-F3, that and the function key F3
is, the SHIFT key
simultaneously. QuickC will leave you on the same line, and will give you the
same error message, but will tell you that this is error two of three. Make the
correction to SPED, and press SHIFT-F3 again. You will see the third error
message. Correct this, then press ALT-R RETU RN to recompile. This time things
should work as they did earlier.
What the compiler did was process your entire file, cataloging the errors.
Since none was fatal, do so successfully. When the compilation
it was able to
process was finished, the compiler put you back into the editing mode, at the
approximate location of the first error. The SHIFT-F3 command lets you move
from one error to the next in your file, making it easy to correct compiler
errors.
This program provides some moderately interesting trivia. Let's change
20 Using QuickC
File Edit Uleu Search Run Debiiq Calls

C^vSHVfirst.c
nainO
<
printf ( "xs /.s and /.s- /..Zli zsVn"j
DISTJ1ESS, PTA, PIB, DIST, DISTJUNII);
printf ( "/.s x.Zlf xsVn", SPEDJ1ESS, SPED, SPEBJUHIT):
printf ( "zs x.Zlf xs = x.Zlf xsVn",

TinEJIESS, DIST, DISTJUtllT, F0M1ULA, TiriEJIlIT);
d
error CZB65: (1 of 3)
'SPEDJIESS' undefined
:
Proqran List: <Mone> Context: <Proaran not conpiled>
Figure 2-2. Work file after compiler errors have been detected
the program once again to clean up the output somewhat. You'll format the
output, so that the numbers are displayed only to two decimal places, using
QuickC's Search facility.
Once you've got the first.c file open, press ALT-S, immediately followed by
C. Do not press RETURN.
You will get the dialog box shown in Figure 2-3:
In the top box, labeled Find What, type %lf. Then type ALT-T to move the
cursor to the Cliange To box. In this box, type %.21f. Then press RETURN.
Because the default setting is to ask you to verify each change, QuickC
will highlight each occurrence of %lf in your file. Press RETURN to accept the
default; that is, to verify that each occurrence is to be changed.
File Edit Uieu- Search Run Pebug Calls

C^NSHNfirst.c
Idef ine DiST saeeeeee.e
tdefine PTft "sun"
Idef ine PTB
•define DIST
Idef ine DIST
Idef ine SPEE

tdefine SPEE
tdef ine SPEE
Idef ine TIHE

Idef ine TinE
Idef ine tIAGI
Idef ine Fom
nainO
{
22 Using QuickC
statements (see Chapter 4), you are providing information for the compiler to
substitute when it creates your program.
Thus, when the compiler sees DIST in your program, it substitutes
93000000.0; when it sees DIST_UN1T, the compiler substitutes "miles" and
so forth. The second line beginning with printf actually displays the following:
SPEED.HESS SPEED SPEED.UNIT
This becomes "Average human walking speed: 3.50 mph" when the substitu-
tions are made. So, all you've done is provided canned phrases for the program
to display.
Two definitions are worth looking at more closely. The MAGIC NR in
this case represents the number of hours in a yean The material between /* and
*/ iscomment that indicates this fact to a reader of the source code.
a
The FORMULA is the expression used to compute the amount of time it
would take a human to walk to the sun. Dividing DIST by SPEED
(93000000.0 / 3.5) gives you the number of hours this walk would take.
Dividing this result by MAGIC NR (8766) tells you how many years these
hours represent. The compiler substitutes exactly what you have specified
when it encounters FORMULA in your program, then substitutes the values
and messages for DIST, SPEED, and MAGIC_NR. What is finally displayed
is the result of 93000000.0 / 3.5 / 8766.
Separating Program Components

To make this program display a different set of distance and speed facts, you
can change the details of the terms you've defined. For example, to specify how
long it would take a giant tortoise to walk from Earth to Mars, you need to
make these changes:
• 93000000.0 to 35000000.0
• "sun" to "mars"
. 3.5 to. 124
• "Average human walking speed:" to "Average giant tortoise walking

speed:"
.
If you make the changes directly in your program file, you'll lose your
original example about walking to the sun. Instead of writing it directly into
first. c, write this information to a separate file. In this way, you'll be able to
change the program to enable you to create as many distance files as you wish.
To accomplish this, use the following strategy:
1 Copy the definition lines from first.c to another file, mars.h, which will
contain the new set of information. This is the file you will modify.
2. Copy these same lines to a file, sun.h, which will contain the informa-
tion from the original example.
3. Delete these lines from first.c.
4. Modify the beginning of first.c.
To do this, start QuickC with first.c as your work file. If you aren't already
working on this file, type
qc first
and press RETURN.

Inside first.c, move the cursor to the top of the file if it's not there already.
Press CTRL-HOME or CTRL-Q R (CTRL and Q keys, followed by the R key) to
accomplish this.
To move something from one place to another, you first need to mark the
text you want to move. To do so, keep pressing SHlFT-DOWN ARROW until all
the definition lines have been highlighted. When all these lines have been
marked, press ALT-E (no RETURN ) to get to the Edit menu. During the
following session, whenever you are asked whether to save a file before moving
on, press RETURN to indicate "yes."
1. Press C to copy the marked text.
2. Press ALT-F N to create a new file.
3. Name this file mars.h in the text box.
4. Once inside mars.h, press ALT-E P to paste the marked lines into
this file.
5. Press ALT-F N to create another new file.

.
24 Using QuickC
6. Name this file sun.h in the text box.
7. Once inside sun.h, press ALT-E P to paste the marked Hnes into this file
as well.
8. Press ALT-F O to open an existing file.
9. Specify first as the file you want to open.
10. Use the SHIFT-DOWN ARROW keys to mark the definition lines again.
1 1 When these are all marked, press ALT-E T to cut these lines from first.c.
After doing all this, you'll have three files instead of your original one:
first.c, mars.h, and sun.h.
Before leaving first.c again, add the following line at the top of the file.
Make sure to include the quotes this time:
tlnclude "mars.h"
Now go back to the mars.h file to make the required changes in that file. To do
this, press ALT-F O and enter mars.h in the resulting text box.
To change 93000000.0 to 35000000.0, press CTRL-RIGHT ARROW twice.
The cursor should then be on the 9 in 93000000.0. Press the DEL key twice, to
delete the 93. Then type 35 to insert these two digits.
To change "sun" to "mars" use the Search menu again. Type CTRL-S C to
change text. Type sun (no quotes) as the Find What text. Then press ALT-T to
move to the Change To box. Type mars (again, no quotes) here, then press
RETURN. You can use the same method to change 3.5 to 124 and "human" to .
"giant tortoise" (once again, no quotes) in the file.
Then press ALT-F F to reopen the last file, which was first.c. Once back in
this file, press ALT-R R to Restart the compiler. This time the program will
produce the following output:
Distance between mars and earth: 35000000.00 miles

Average giant tortoise walking speed: 0.12 mph
Tine required to cover 35000000.00 miles = 32199.19 years
To have the program display information about walking to the sun again,
just change the file name on the first line of first.c to sun.h from mars.h. (The .h
extension stands for header file. Chapter 4 includes more information about
header files.)
; ; ;;; ;
Here's one more sample file you can one provides the informa-
use. This
tion needed to determine how long it would take sound to travel from New
York City to Peking, China. Use the commands you've learned so far to create
this file.
#deline DIST 11000.0

#define PTA "New York"
define PTB "Peking"
#define DIST_MESS "Distance between"
#deline DIST.UHIT "miles"
#deline SPEED 760.0

define SPEED MESS "Average sound speed:
define SPEED.UNIT "mph"
TIME.MESS "Time required to cover

TIME.UNIT "hours"
define MAGIC.NR 1 /» hours per hour */
define FORMULA DIST / SPEED / MAGIC.NR
If you find program amusing, you can use the following listing to
this
build more files. The next program (called buiider.c) will create a file with the
name you specify, and will write the values you enter to this file. Once builder
has written your file, you can make first use this file by substituting the new
file's name for sun.h at the beginning of first. ( Leave the quotes in this case.) To
compile and run first after making these changes, just press ALT-R RETURN.
/* Program to generate files for trivial facts program, */
include <8tdio.h>
include <string.h>
include <stdlib.h>
define MAX.STR 80
void str_info ( char *message. FILE *fptr)

<
char str [ MAX.STR]
printf ( "%s? " message) .
gets ( str)
fprintf ( fptr, "define Xs \"y.s\"\n" , message, str);
>
void val_info ( char ^message, FILE *fptr)

{
char str t MAX.STR]
double vt^lue
printf ( "Xs? ", message):

gets ( str) ;
value " atof ( str)
^
26 Using QuickC
4. Type X to select the Exe output option.
5. Then press RETURN to compile and link the program to an executable

file, named builder.exe.
6. Exit from QuickC by typing ALT-F X.
You should now have a file called builder.exe on your disk. To run this
program, just type builder at the DOS prompt, and answer the questions the
program asks you. Be forewarned that the program does not check whether
you already have a file with the name you specify. If you give the name of an
existing file, the program will create a new file with that name and your
original file will be lost. So be careful.
Review
Let's summarize the things you've done so far, and the commands to accom-
plish these things.
• Creating a program source To create a file, you start QuickC, using

file:
the qc command, and start file. To save the

typing the contents of your
file, select the Save option on the File menu (ALT-F S). QuickC will ask
you for a name under which to save the file.
• Editing an existing source file: Once you've created a file, you can work
with it in QuickC. To specify the file, you can either type the file name
on the command line when you call QuickC (for example, qc first), or
you can start QuickC, then select Open on the File menu (ALT-F O), and
type the name of the file you want to open in the resulting dialog box.
• Compiling and running a program within QuickC: Once you've got

the program file in the shape you want, you can select the Start option
on the Run menu by typing ALT-R S or ALT-R RETURN. This will run
the program.
• Compiling a program and creating an executable (self-standing) pro-

gram file: Select the Compile option on the Run menu (ALT-R C), then
select X for an Exe output file, then press RETURN to accept the default
action of building the program (that is, compiling and linking it, in
this case).
28 Using QuickC
• Moving around from file to file: Usethe ALT-Ftogetthe Filemenuand

select the Open, New, or Last File options (O, N, and F keys, respec-
tively).
• Marking text to be copied or cut: Use the SHIFT-DOWN ARROW keys.
• Copying text into a clipboard: Use the Copy option in the Edit menu
(ALT-E C).
• Cutting text from a file: Use the Cut option in the Edit menu (ALT-ET).
• Pasting the contents of the clipboard in another file or at another
location in the same file: Use the Paste option in the Edit menu
(ALT-E P).
Exploring Program Execution
Often, you'll want to know what's happening while your program is executing.
This information can be very useful if your program isn't doing what it's
supposed to be doing. The information can also help you better understand the
behavior of an algorithm (which is a well-defined solution process) in your
program.
Debuggers are programs that let you execute a program step by step, and
at various points in the program. By deter-
check the values of key variables
mining where your program "went wrong," you should be able to find a way of
fixing it. in this section, you'll learn how to use QuickC's built-in debugger to
look inside your program while it's executing.
We won't try to fix program bugs, however. Rather, we'll use the debugger
to see how a particular algorithm works as it tries to reach a certain value. The
program applies the algorithm over and over, until a satisfactory solution is
found. You can watch how values change as the algorithm converges on the
"correct" answer.
The algorithm we'll use is a simple one, involving only whole numbers.
Ironically, it turns out to be an unanswered question whether the algorithm
will eventually stop for any starting value. The algorithm is often known as the
; ; ; ; ; ;
3A + 1 algorithm, and works as follows:
1. Start with an arbitrary whole number, A.
2. If A= 1, stop.
3. If A is even, replace A with A / 2 and go back to step 2.
4. If A is odd, replace A with 3A + 1 and go back to step 2.
The question is whether the algorithm will always end at I for any starting
value. (It's known that the algorithm stops for all values less than 536870912,
or 2".)
The following program implements this algorithm, and also computes
and displays some information about the solution process. In particular, the
program keeps track of the number of times val, the current number, is odd
and even.
#include <stdio.h>
#include <stdlib.h>
#dcline MAX.STR 80
main ()
{
long val, count = 0, even = 0,
char str [ MAX.STR]
printl ( "Starting value? ")

gets ( str) ;
val • atol ( str)
count++;
if ( val " 1)
odd++
else il ( !(val X 2)) /* il val is even */
<
even++
val /- 2;
>
else /* if val is odd. but not 1 */
<
odd++;
val -3 * val + 1
printf ( "val Xld; odd - » Xld; even - '/,ld\n" .val odd, even)
, ;
if ( ! (count X 23))
<
printf ( "Press a key to go on.");
getch ():
printf ( "\n");
;
30 Using QuickC
}
}
while ( val !» 1)
printf ( "Alter Xld iterations, result - l.\n". count);
printf ( "# even values - Xld; # odd values = XldAn", even, odd);
The program, which we'll call algor.c, does not show you the intermediate
values created while applying the algorithm. You could get this information by
adding the appropriate instructions to the program. Or you can use the
debugger to peek at the values of specific variables as the program is running.
We'll use the debugger to watch the program execute.
Setting Up for Debugging

When using the QuickC debugger, you can specify the variables whose values
you want to watch and the program lines at which you would like to see these
values. The debugger will then stop whenever it reaches one of these lines,
called breakpoints, and will let you see the most recent values of the variables
you asked to watch.
To use the debugger with a program, you must first compile the program
in a way that will enable the debugger to get the information it needs. Assume
algor.c is your current work file and you are ready to compile.
1. Type ALT-R C to select the Compile option on the Run menu.
2. In the dialog box you get, make sure the Debug option is marked with
anX. If it is, just press RETURN. If the Debug option does not have an
X, type D to set this option. Then press RETURN.
The compiler will compile your program to memory, with the "hooks" needed
for the debugger to tell you what you want to know. After this is done, you'll be
back in your program file.
To set things for the debugger, you'll want to do two things: specify the
variables you want to watch, and set the breakpoints at which you want to see
the values of these variables.
In this case, let's set three watch variables, val, even, and odd. To look at
these variables, we'll set a breakpoint at the following line in the algor
program:
printf ( "val - Xld; odd - Xld; even - %ld\n", val, odd, even);
To set the watch variables,
1. Type ALT-D C to clear all current breakpoints (just to be on the

safe side).
2. Type ALT-D L to clear all current watch variables (again, as a

precaution).
3. Type ALT-D RETURN to get the Add Watch variable dialog box.
4. Type val; even; odd; in the box to specify that you want three watch
variables. The semicolons are necessary. After you type this, but
before you press RETURN, the dialog box should look like Figure 2-4.
5. Move your cursor to the printf() statement at which you want to set
your breakpoint.
6. Type ALT-D B to set a breakpoint at this line.
7. Type ALT-R RETURN to Start executing the program.
The program's source code will be displayed as the program executes.

When the program reaches the breakpoint, execution will stop temporarily,
and you can look at the values of the watch variables (shown at the top of the
screen). Figure 2-5 shows the first time the program stops at the breakpoint
when executing with a starting value of 21. When you're ready to let the
program move on, press the function key, F5.
The program will execute in this mode until it reaches its normal end —
that is, until val becomes To avoid starting values requiring a large number
1 .
of trials before val reaches you may want to try one or more of the following
1 ,
starting values: 5,8, 10, 16, 20, or 21. (If you get caught in a run that is taking
too long for you, you can use the file menu to get out. Type ALT-F X.)
One More Example

Let's look at another example, which will show you how to use run-time
program options, and will also help increase your familiarity with the QuickC
commands you've learned so far.
The following program displays unusual facts, just as an earlier program

program generates the information to present at
did. This time, however, the
random, from a predefined list of facts. You provide the program with a seed
value, which the program uses to select an object or entity at random from a
32 Using QuickC
File Edit Uieu Searcli Run Debim

C^NSHNdlgor.c
include <stdioih>
tinclude <stdlib.h>
define IMX^TR 88
nain
Ion
cha
; ; ;
File Edit Uieu Searcli Run Debug Calls

val- bl
euen=
odd: 1
CASHValgor.c
else if ( !(ual / 2)) /» if ual is euen »/
<
euen++;
oal /= 2;
>
else /» if ual is oddi but not 1 */

{
odd++;
ual = 3 * ual i;
}
printf ( "ual - /-W odd = xld: euen = xldVi uali oddi euen)
if ( '(count /.
23))
<
printf ( "Press a key to go on,");

getch ():
printf ( "vn");
}
Progran List: <Moiie> Context: algor,c:nain
Figure 2-5. Program execution stopped at a breakpoint
double data [ MAX ENTRY] - { 7.99e-26. 6e-9. 3.15, 67.3. 1.38e5, 3.51e5,
7.6e22, 1.9e27, 2.2e41. leBl, 1900. 0>;
int my.rand ( int *seed)

<
*seed - (29 • (»seed) + 1) X 1024;
retiirn ( *seed) ;
>
main ( int argc , char *argv [ ])

{
int ch, indexl index2, my.rand ( int •)
, . seed;
char str [ MAX.STR]
double '
datal data2, nr;
,
void nice_print { double, char *. char »)
it ( argc -- 2)
seed • atoi ( argv [ 1] )
else
{
; ; ; ;
; ; ; . ;; ; ; ;
34 Using QuickC
printl ( "Seed? ") ;
gets ( str)
seed = atoi ( str)
>
seed •/,= CYCLE;
do
indexl = my_rand( Sseed) '/. MAX.ENTRY;

do
{
index2 = my.rand ( ftseed) % MAX.ENTRY
while ( indexl =» index2)
datal = data [ indexl]

data2 = data [ index2]
if ( datal > data2)
nr = datal / data2:
else
nr = data2 / datal
if ( datal > data2)
nice.print ( nr. obj [ index2] obj , [ indexl]);
else
nice.print ( nr. obj [ indexl], obj [ index2] )
printf ( "\nA '/.s is .21g */.s\n", '/.
obj [ indexl] data [ indexl] UNIT) , .
printf ( "A y,s is •/..21g '/,s\n"

obj [ index2] data [ index2] UNIT) , ,
printf ( "\n\n Press to stop. "); !
ch » getche ;
}
while ( ch != '
!
')
void nice.print ( double num. char *strl , char *str2)

<
#deline CUTOFF lel2
if ( num <= CUTOFF)

printl ( "It would take '/,.21f '/.ss to make 1 '/.sAn". num, strl , str2) ;
else
printf ( "It would take '/.
.21g '/.ss to make 1 '/,s.\n", num, strl, str2)
Enter the program, and give it a name. We'll call it game.c here. When you
compile the program within QuickC — that is, when you use the ALT-R
RETURN program prompts you for a seed. After you provide this,
option, the
the program generates random facts, based on the information available to it.
The program keeps generating facts as long as you press any key other than the
exclamation point ( !), which ends the program.
The following listing was produced using a seed of 235:
It would take 6.3e+016 water molecules to make 1 wasp.
A wasp is 6e-00S kg
A water molecule is 8e-026 kg
Press ! to stop.
It would take 13460000000.00 wasps to make 1 person.

A wasp Is 6e-000 kg
A person is 67 kg
Press ! to stop.
It would take 4.4e+049 wasps to make 1 Milky Way.
A Milky Way is 2.2e+041 kg

A wasp is 5e-009 kg
Press ! to stop.
It would take 43809.62 chickens to make 1 blue whale
A blue whale is 1.4e+005 kg

A chicken is 3.2 kg
Press I to stop. I
This program is actually different from the previous ones you've built. To
see the difference most clearly, compile the program to an executable file. To
do this,
1. Type ALT-R C to get the Compile options in the Run menu.
2. Use the arrow keys to set Warning Levels to 1 , if it's not already at that
value.
3. Type X to compile to an Exe output file, if this isn't already the default
output file.
4. Then press RETURN.
Once you have an executable version of the program, you can simply type
game at the DOS command line, and the program will start executing. Try
this. You'll program asks you for a seed, just
find that the as it did earlier.
Now, run the program again but this time type:
game 271
On this run, the program does not ask you for a seed, because the program
takes the 271 as the seed. The effect is the same as if you had typed 271 in
response to the program's earlier prompt.

Typing 271 when you start game is similar to what you do when you call
QuickC with the name of the file you want to edit. The ability to specify certain
information when calling a program can be very useful, as you'll see later.
You can accomplish the same thing even if you just compile the program
to memory. A Run-Time option in the Run menu lets you specify the informa-
::
; ); ; ; ;; ;; ;; ;; ; : ;
36 Using QuickC
tion you would type in addition to the program name.

To see how this works, select the Run-Time option in the Run menu, by
typing ALT-R O (for Options).
You will get a text box with the label. Command
Line. Type 271 in this box, then press RETURN. Then type ALT-R RETURN to
compile and run game in memory. This time, the program will not ask for a
seed, and will behave just as it did in the executable version.
To close this part of the chapter, here's a program to generate fact
collections for use with the game.c program.
/• Program to generate files for trivial facts program. */
#include <8tdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX.STR 80
#define MAX.ENTRY 100
mainC int argc , char *argv []

{
char str [ MAX.STR]
void val.info ( char *. FILE *) str.info , ( char *. FILE *);
void nice_print ( int, char *, FILE *)
void nice val ( int, double, FILE *)
FILE *fp;
double data [ MAX.ENTRY]
int count, nr_in;
if ( argc == 2)
fp = f open ( argv [ 1] , "w")
else
<
printf ( "Complete file name? ")
gets ( str)
fp « fopen ( str, "w");
}
if ( fp != NULL)
•t
printf ( "How many entries? ")

gets ( str)
nr in = atoi ( str)
fprintf (fp, "#define MAX.ENTRY '/.d\n" nr.in) , ;
printf ( "UNIT? ")

gets ( str)
fprintf (fp, "#define UNIT \"V.s\"\n", str);
fprintf ( fp, "\n\nchar *obj [ MAX.ENTRY] = \n{ ")

for ( count = 0; count < nr in; count++)
<
printf ( "Object? ")
gets ( str)
if ( count < (nr.in - 1))
nice. print ( count, str, f p)
else
fprintf ( fp, "\"'/.s\"};\n", str);
printf ( "Value? ");
gets ( str)
data [ count] = atof ( str)
}
fprintf ( fp, "\n\ndouble data [ MAX.ENTRY] \n{ ");

for ( count 0; count < nr.in; count++)
; ;
if ( count < ( nr.in - 1))

nice_val ( count, data [ count], fp)
else
fprinti ( Ip. "Xll};\n". data [ count]);
fclose ( fp)
}
else
printf { "File not opened. \n");
void nice print ( int nr, char *str. FILE *fptr)

<
if ( (nr X 4) !- 3)
fprintf ( fptr. " \"'/,s\", ", str) ;
else
fprintf ( fptr. " \"%s\". \n ". str);
}
void nlce_val ( int nr. double val. FILE *fptr)

<
if ( (nr X 6) !» B)
fprintf ( fptr. " Xlg. ". val);
else
fprintf ( fptr. " y,lg. \n ". val);
}
Again, you should compile program to an executable file to make it as

this
useful as possible. Recall that to do this, you just need to select the Exe Output
option in the Compile options under the Run menu. Let's use makefact.c and
makefact.exe for this program's source and executable files, respectively.
With this program, you can specify a file name when you invoke the
program. For example, if you typed
makefact myfacts.h
and entered object names and values, the program would write this informa-
tion to a file named myfacts.h. To use this collection of facts, you would need
to cut the top part of the game.c file as you did earlier with first.c. That is, you
would need to cut everything beginning with the line
»define UNIT "kg"
through the end of the values entered for data[ MAX_ ENTRY]. You would
also need to add the following line near the beginning of game, probably right
after the definition line for CYCLE:
Vlnclude "mjrf acts h"

38 Using QuickC
This program wrote the following listing into a file called area.h.
#deline MAX.ENTRY 13
#deline UNIT "square km"
char *obj [ MAX.ENTRY] =

•C "New York City". "Earth", "Jupiter", "Asia",
"Pacific Ocean". "Sun", "Vatican City", "USSR",
"USA". "Austria". "Pentagon". "Great Pyramid at Cheops",
"Florence"};
double data [ MAX. ENTRY] =

{ 830, 5.1e+008, 6.4e+010, 4.425e+007, 1.65e+008. 6e+012.
0.44. 2.24e+007, 9500000. 84000. 0.12. 0.053.
102.000000};
These data can be used by the game program if you include the following
line between the definition line for CYCLE and the first line of the my_rand( )
function:
înclude "area.h"
As you become more familiar with C, you can come back and modify
these programs if you wish. If you have become more comfortable moving
around in the QuickC environment as a result of working with these pro-
grams, then they have served their purpose. If you also found them interesting
to play with or if you picked up some information you didn't know before, all
the better.
QuickC Commands
In the remainder of this chapter, we'll lookmore closely at the QuickC features
and commands you're most likely to use in ordinary applications. The QuickC
Programmer's Guide provides additional information about many of these
commands and also describes features and commands not discussed here. This
discussion will be largely a catalog of commands and features. Our main intent
is to gather in one place brief summaries of the most common QuickC features
and commands, although we will suggest things for you to try and you are
strongly encouraged to experiment. This section lays.the foundation for your
use of QuickC throughout this book. To get the most from this chapter and
from QuickC, try the things suggested and, by all means, experiment.
On-Line Help
The first command to learn is for the on-line help available in the QuickC
environment, if you're ever uncertain of the command to do something, press
function key Fi. This gives you a dialog box, the first of several help screens,
that contains summaries of the major commands. The box also contains
several choices for action. The default is to display the next screen of help
information, which is a summary of C operator precedence. Press P to see the
previous help screen, and also to make backwards paging the default action.
If you want a summary of C keywords or of QuickC library functions,
press K while in the Help dialog box. Use the arrow keys to select the label that
best describes the general topic about which you want information. Press
RETURN to get a complete list of keywords for which help is available in that
topic.
^REMEMBER To get on-line help, press function key Fl.
Creating and Editing Files
When you start QuickC, the program immediately loads a work file. This will
be either a file you have specified on the command line, as you saw earlier in
this chapter, or a named untitled.c.
file
As soon as QuickC has loaded your file into memory, you can start
inserting text into the file. Thus, to create a file, just start typing. To do other
things, such as move around in the text or switch to an overwrite mode from
the default insert mode, you need to use the QuickC commands described in
this section.
In the following discussion, notice that many of the commands are

available in two different contexts: as a command sequence while you're
editing or as options on a menu. Ultimately, you'll probably find it more
convenient to use the command sequences, so you won't have to leave the
editor. Initially, however, you may find it easier to let the menus serve as your
memory.
Editing Modes QuickC's editor operates in one of two modes: insert
mode (the default) and overtype mode. In insert mode, text is inserted at the
current cursor position. Any text at or to the right of the cursor is moved to the
right. Thus, if the cursor is sitting on top of a character (let's say, a in the
40 Using QuickC
following listing), when you insert a different character (let's say z), the original
character (a) will not be lost. Rather, it and all subsequent characters on the
line will be moved to the right.
The following listing shows the result of inserting z into the word maybe
on the first line when the cursor is on the a in that word. The second line in the
listing shows the result.
maybe not
mzaybe not
In overtype mode, on the other hand, any character at the current cursor
position is overwritten when you type a new character. Surrounding charac-
ters are not affected. Essentially, typing in overtype mode amounts to crossing
out text and substituting new text. The cursor changes from a small blinking
line to a large block when you go into overtype mode.
The following two lines show the result of typing a z when the cursor is on
the a in the string.
maybe not
mzybe not
When you first start QuickC, the editor is in insert mode. To switch to
overtype mode, press the INS key or press c TRL-V. The editor toggles between
these two modes, so to return to insert mode, just press ins again. Remember,
the cursor is larger when you are in overtype mode, so you can always tell what
mode you Ye in.
Moving in Your File To move around in your file, you need to decide how
far to move, and also the direction in which to move. The QuickC editor has a
rich set of movement commands, so it may take a while to become familiar
with all of them. Many of the commands are the same as those in WordStar, so
if you've used that program you'll find the task somewhat easier.
When moving in your file, you can either move the cursor through the file
or you can scroll the file past the cursor. We'll look at the cursor movement
commands first.
The smallest vertical movement you can make is up or down one line, and
the smallest horizontal movement is left or right one character. The QuickC
editor has two ways of accomplishing each of these four moves. The most
intuitive way is with the arrow keys. The UP ARROW key moves you up one line.
the DOWN ARROW key moves you down one line, and the LEFT ARROW and
RIGHT ARROW keys move you left and right one character, respectively.
You can also use commands involving the CTRL key to accomplish these
moves. The four keys, S, E, D, and X, form a cross on the keyboard. Each of
these keys, in conjunction with the CTRL key, moves you in one of the four
directions. Thus, CTRL-E moves you up one line, and its counterpart CTRL-X
moves you down one hne. Similarly, the other pair of keys, CTRL-S and CTRL-D
move you left and right one character, respectively. Table 2-1 summarizes these
movement commands.
All of these moves are nondestructive. That is, the commands simply
move the cursor; they do not delete or insert any text, regardless of the mode
you're in.
You can also make larger moves. To move to the right or left one word,
use the RIGHT and LEFT ARROW keys together with the CTRL key. That is, to
move one word to the right, press CTRL-RIGHT ARROW; to move one word to
the left, press CTRL-LEFT ARROW. You can also use CTRL-F and CTRL-A to
move right and left by one word, respectively. (It may help to remember the
latter two commands if you think of them as more extreme versions of the
single character moves, CTRL-D and CTRL-S, based on the relative locations of
the F and A keys on the keyboard.) Table 2-2 summarizes the commands for
moving by words.
Table 2-1. Single Character Cursor Movement
Key(s) Effect
UP ARROW
42 Using QuickC
Table 2-2. Single Word Cursor Movement
Key(s) Effect
CTRL-LEFT ARROW Move cursor left one word

CTRL-A Move cursor left one word
CTRL-RIGHT ARROW Move cursor right one word
CTRL-F Move cursor right one word
we look at more editing commands, let's look at some general

Before
properties of the commands. At a general level, there are three types of keys
involved in editor commands:
• Ordinary character keys, such as E, D, X, and S
• "Special keys," such as the arrow keys, backspace, HOME, TAB, and
the function keys
• "Modifier keys," such as the CTRL, ALT, and SHIFT keys
Ordinary characters cannot be used alone as commands because the

editor will interpret these as part of the text for your file. To use these keys in
editor commands, you need to modify them, as you've seen in commands such
as CTRL-S and CTRL-A, for example. Thus, the minimal requirement for using
an ordinary character in a command is the use of a modifier key with it.
Special keys can be used by themselves as commands, as you've seen in

the UPARROWand RIGHT ARROW commands, for example. You don't need any
additional keys to use special keys as commands.
One strategy for organizing commands is to add inodifiers to existing
commands when these commands are intended to apply to different-sized
units. You've seen an example of this: a RIGHT arrow moves right one
character, but aRIGHT ARROW modified by a CTRL moves right one word. This
strategy is common in the QuickC editor commands; being aware of it will
make it easier to learn what may seem like a lot of arbitrary commands.
To move on the entire screen, you need to modify the E and the X keys for
moving vertically. Thus, to move to the top of the screen, press CTRL-Q E. That
is, press CTRL-Q then the E key. The CTRL-Q sequence tells the editor to
interpret the next character as part of a command, rather than as an ordinary

text character for your file. Similarly, press CTRL-Q X to move to the bottom of
the screen. Table 2-3 summarizes the commands for moving a screen at a time.
To move to the beginning or end of a line, press CTRL-Q S or CTRL-Q D,
respectively. Note that these are the lateral movement characters (S and D),
modified by CTRL-Q. You can also use the special keys, HOME and END to get to
the beginning and end of the line, respectively, as summarized in Table 2-4.
To get to the beginning or end of the//7e, modifythe HOMEand ENDkeys,
as shown in Table 2-5. Thus, CTRL-HOME moves the cursor to the beginning of
the file, and CTRL-END moves it to the end of the file. (CTRL-Q R and CTRL-Q C
will also move the cursor to the beginning and end of the file, respectively.)
Table 2-3. Cursor Movement by Screen
Key(s) Effect
CTRL-Q E Move to the top of the screen

CTRL-Q X Move to the bottom of the screen
Table 2-4. Cursor Movement by Line
Key(s) Effect
HOME Move to the beginning of the line

CTRL-Q S Move to the beginning of the line
END Move to the end of the line
CTRL-Q D Move to the end of the line
44 Using QuickC
Table 2-5. Cursor Movement by File
Key(s) Effect
CTRL-HOME IVIove to the beginning of the file
CTRL-Q R Move to the beginning of the file

CTRL-END Move to the end of the file
CTRL-Q C Move to the end of the file
The QuickC compiler will keep trying to compile your file as long as
possible. Sometimes, the compiler will have to stop because of a fatal compiler
error, such as being unable to open a specified file. In other cases, the compiler
may be able to process your file completely — finding and cataloging errors,
but not producing a compiled file. In that case, the compiler will return you to
the editor at the approximate spot where the first error was found. The
compiler will give you a message telling you the nature of the error and also the
number of errors it encountered, as shown in Figure 2-2, earlier in this chapter.
You can move to errors that the QuickC compiler has found in your file, as
shown in Table 2-6. To move to the next error in your file, press SHIFT-F3, that
is, the SHIFT key and function key F3 simultaneously. To move to the previous
error, press SH1FT-H4.
All the movement commands we've just summarized move the cursor
through the file. You can also move the file in relation to the cursor, however.
This is known as scrolling. You can scroll up and down one line at a time or one
screen at a time. To scroll up one line, press CTRL-W; to scroll down one hne,
press CTRL-Z. These two keys are right next to the E and X keys, respectively,
so you may find it helpful to use those keys for orientation in remembering the
scrolling commands.
Similarly, to scrollup one screen, or window, at a time, press CTRL-R; to
scroll down one screen at a time, press CTRL-C. These two keys are on the other
side of E and X, respectively. You can also use the special keys, PGUP and PGDN,
to scroll up and down one screen. Scrolling commands are summarized in
Table 2-7.
Table 2-6. Cursor Movement Between Errors
Key(s) Effect
SHIFT-F3 Move to next error in file

SHIFT-F4 Move to previous error in file
Table 2-7. Scrolling Commands
Key(s) Effect
CTRL-W Scroll up one line

CTRL-Z Scroll down one line
PGUP Scroll up one screen
CTRL-R Scroll up one screen
PGDN Scroll down one screen
CTRL-C Scroll down one screen
Marking and Moving Text You can easily move text from one part of your
file to another, or even to another file, simply by marking the section of text
you want to move and then specifying where you want to move it. You've
already used some of these commands in the first part of this chapter.
The first step in moving or deletmg a chunk of text is to mark it. Once you
mark the text, you can use the Edit menu to place the text on the Clipboard, a
buffer where you can temporarily place text in order to move it to a new
location, without necessarily deleting your original text. All commands for
marking text involve the SHIFT key.
As with cursor movement, you can specify text units of different sizes to
mark. The smallest unit is a single character, and the largest is an entire file. To
mark characters to the left of the cursor, press SHIFT-LEFT ARROW once for
46 Using QuickC
each character you want to mark. This command does not mark the character
(if any) at the current cursor position. To mark characters to the right of the
current cursor position, press SHIFT-RIGHT ARROW once for each character
you want to mark. This command does mark the character at the current
cursor position.
To mark individual words, you need to use both SHIFT and CTRL as
modifiers. That is, you will need to press three keys simultaneously: SHIFT,
CTRL and an arrow key. To mark words to the left of the current cursor
position, press SHIFT-CTRL-LEFT ARROW once for each word you want to
mark. Notice that this command will also mark portions of words. For
example, you have the cursor on the r in careful, and you press SHlFT-CTRL-
if
LEFT ARROW, the first "word" to be marked will be the ca to the left of the
current cursor position. Thus, this command will mark words or partial words
to the left of the current cursor position; the command does not mark the
character (if any) at the current cursor position. To mark words to the right of
the current cursor position, type SHlFT-CTRL-RIGHT ARROW. This command
also marks partial words, and marks the character (if any) at the current
it also
cursor position. Thus, if your cursor is on the r in careful again, pressing
SHlFT-CTRL-RlGHT ARROW would mark the reful from the cursor to the end of
the word.
To mark an entire line of text, use the SHIFT key in conjunction with the
UP ARROW and down arrow keys. To mark lines above the current one, press
SHIFT-UP ARROW once for each line you want to mark. Notice that this
command does not mark the current line. To mark lines below the current one,
press SHIFT-DOWN ARROW once for each line you want to mark. This com-
mand does mark the current line. Figure 2-6 shows an example of marked text
in a file.
To mark from your current cursor position to the beginning of the file,
press SHIFT-CTRL-PGUP to mark from your current position to the end of the
;
file, press SHIFT-CTRL-PGDN.
Table 2-8 summarizes the commands for marking text.

Once you've marked text, you can copy it to the Clipboard by pressing
CTRL-INS. This is equivalent to calling up the Edit menu (press ALT-E to do
this) and selecting the Copy option. You can accomplish this by pressing C
when you have the Edit menu selected, or by using the down arrow key to
highlight the Copy option and then pressing RETURN.
File Edit Uieu Searcli Run Debug Calls

l>bH>gdne.c
linclude <stdio.h>
I include <dos.h>
t include <stdlib,ii>
tdef ine rmX^TR 88
tdefine CYCLE 1024
define UNIT "kg"

Hdefine nRXJMTRV 11
char «obj I riflXJEMTRVJ = < "uater noleciile") "uasp") "chicken") "person"

"blue uliale") J'747"i "noon") "Jupiter")
"flilky Way") "Uniuerse"i "car"};
double data c nAXJNTRYJ = < 7,99e-26, 5e-9) 3,15) 67,3) l,38e5, 3,51e5)
7,5e22, l,9e27) 2,2e41, leSl, 1908, B>;
int ny_rand ( int «seed)

I
«seed = (29 » («seed) + 1) z 1824;

return ( «seed);
>
Progran List: <rioiie> Context: <Progran not conpiled>
Figure 2-6. Screen showing marked text
Once text has been copied to the Clipboard, you can paste the text into
other files or at other locations in the current file. To paste the text at a
different location in the same file.
1. Move the cursor to the target location.
2. Select the Edit menu, by pressing ALT-E.
3. Select the Paste option by pressing P. You can also use the arrow keys
to highlight the Paste option, and then press RETURN to select the
option.
48 Using QuickC
Table 2-8. Text Marking Commands
Key(s) Effect
SHIFT-LEFTARROW Mark Characters to left of cursor

SHIFT-RIGHT ARROW Mark Characters to right of cursor
SHIFT-CTRL-LEFT ARROW Mark words to left of cursor
SHIFT-CTRL-RIGHT ARROW Mark words to right of cursor
SHIFT-UP ARROW Mark lines above cursor line
SHIFT-DOWN ARROW Mark lines below cursor line
SHIFT-CTRL-PGUP Mark to beginning of file
SHIFT-CTRL-PGDN Mark to end of file
You can also copy from the Clipboard to a different file, as you did earlier.
(You did try that, didn't you?) Recall that you first need to open the target file:
1. Press ALT-F O to select the File menu and the Open option in that
menu.
2. Enter the name of the file in the dialog box.
3. Once in the new file, move the cursor to the desired location.
4. Press ALT-E to select the Edit menu again.
5. Select the Paste option by pressing P.
Actually, if you have just copied the text to the Clipboard, you will be able
to carry out steps 4 and 5 (that is, call Edit menu and select Paste option) much
more easily. You can simply move the cursor to the desired location and press
SHIFT-INS while editing. This will paste the text from the Clipboard to the file
at the current cursor position, which is equivalent to pressing ALT-E P after

you've moved command sequence will paste the desired text.
the cursor. This
The reason the ALT-E P command sequence works here is because the Paste
option is accessible as a single letter command if you have just copied material
to the Clipboard.
To see what's going on here, look at the Edit menu. The menu includes six
options. Some of these options have single characters underlined. If you type
an underlined character, that option menu you get

will be selected. The Edit
after copying to the Clipboard has the P in Paste underlined. That's why you
can select the option in a shorter command sequence. (It's also why ALT-F O
lets you open a file.)
The options depend on the actions you've just

available at a given time
carried out. For example, the Paste option is available only if something is on
the Clipboard. Options that have a character underlined in the menu are
available.
There is another way of moving material from one place to another. The
Merge option in the File menu (ALT-F M) copies the contents of an entire file to
your current file, inserting them at the current cursor position. Note that the
entire file merged with your current
is file.
To use the Merge capability:
1. Move the cursor to the location in the current file where you want to
add the material.
2. Press ALT-F M to select the Merge option on the File menu.
3. In the resulting dialog box, specify the file whose contents you want to
merge with your current file.
4. Press RETURN.
Once you've successfully pasted your text, you'll probably want to delete
the text from its original location. To do this, mark the text you want to delete,
then press DEL. This deletes the text without copying it to the Clipboard.
Pressing DEL while editing your file is equivalent to pressing ALT-E E, to call
the Edit menu and select the Clear option. (Notice that in this case the e in
Clear is underlined in the Edit menu.)

It is and copy it to the Clipboard
possible, but not advisable, to delete text
in one step using the SHiFT-DEL key while editing or the Cut option in the Edit
menu. This essentially combines the copying before pasting and the subse-
quent deletion. you get into the habit of using this lazy way to move text you
If
will almost certainly regret it at some point when you accidentally lose
something vital.
50 Using QuickC
Table 2-9 summarizes the operations that are possible when you have
selected text using the commands listed in Table 2-8. You can also use the
commands shown in Tables 2-10 through 2-12 to insert and delete text while
editing — that is, without going to the Edit menu. You don't need to select the
text before invoking the commands listed To delete the charac-
in those tables.
ter at the current cursor position, use the DEL key or press CTRL-G. The DEL
command is also used to delete marked text, as you've just seen. The editor will
know what to do from the context. To delete the character to the left of the
current cursor position, use the BACKSPACE key or press CTRL-H. When
editing, press RETURN any time you want to end a line or insert a blank line.
Table 2-9. Commands for Deleting and Copying Text
Key(s) Effect
CTRL-INS Copy selected text to Clipboard

ALT-E C Copy selected text to Clipboard
SHIFT-INS Paste text to specified location
ALT-E P Paste text to specified location
ALT-F M Merge file to be specified into current file
DEL Delete text without copying to Clipboard

ALT-E E Delete text without copying to Clipboard
SHIFT-DEL Delete text and copy to Clipboard
ALT-E T Delete text and copy to Clipboard
Table 2-10. Character Deletion Commands
Key(s) Effect
DEL Delete current character

CTRL-G Delete current character
BACKSPACE Delete preceding character
CTRL-H Delete preceding character
Table 2-11. Word Deletion and Undo Commands
Key(s) Effect
CTRL-T Delete to end of current word

ALT-BACKSPACE Undo action on current line
CTRL-E U Undo action on current line
Table 2-12. Line Deletion and Undo Commands
Key(s) Effect
CTRL-Y Delete entire line

CTRL-Q Y Delete to end of line
SHIFT-INS Undo line deletion
To delete a word (actually, the part of the word to the right of the current
cursor position, including the current character), press CTRL-T. If you decide
that this deletionwas not a good idea, immediately press ALT-BACKSPACE or
select the Edit menu and press RETURN. These commands select the Undo
option on the Edit menu, which restores a line to its status before your last
action. Undo works only for the current line, and only if you have not yet
moved the cursor from the current line. Table 2-11 summarizes these
commands.
You can delete an entire line or the portion of the line to the right of the
cursor. To delete the entire line, press CTRL-Y. To delete just to the end of the
line, press CTRL-Q Y. Line here refers to a line on the screen, not to a sentence.
You can undo either of these actions by pressing SHlFT-lNS. This command
will restore only the last line deleted.
If you want to look at your file but don't want to make any changes,
especially inadvertent ones, you can make your work file read-only. This
prevents accidental changes. Press ALT-E R to set this option. Pressing the
same keys again turns the option off When your file is read-only, an R appears
.
52 Using QuickC
on the status line at the bottom of your file.

To insert tabs, use the TAB key or press CTRL-l, as shown in Table 2-13. As
you saw earlier, you can also move left to a tabspace by pressing SHIFT-TAB. If
you have marked several lines of text and you press TAB or shift-tab the ,
selected lines will jump to the next tabspace in the appropriate direction.
More QuickC Features Sometimes you will want to return to certain

portions of your file frequently. For example, while writing one of the pro-
grams in the first part of this chapter, you may have needed to check the
definition lines while writing various parts of the program. Getting to a
particular location can be tedious, especially if it is not at the beginning or end
of the file, which can be reached with short command sequences.
Never fear,QuickC has an easy solution. You can mark up to four
locations in your file, associating them with the numbers 0,1,2, and 3. To mark
such locations,
1 Move your cursor to the desired location.
2. Press CTRL-K followed by 0, 1, 2, or 3.
Later, when you want

jump quickly to one of those locations, just press
to
CTRL-Q followed by the number associated with the targeted text. Table 2-14
summarizes the commands for setting and jumping to markers.
Table 2-13. Miscellaneous Edit Commands
Key(s) Effect
ALT-E R Turn read-only format on/off

TAB Move to next tabspace
SHIFT-TAB Move to preceding tabspace
.
Table 2-14. Commands for Marking and Finding Text
Key(s) Effect
CTRL-K 0,1,2, or 3 Set marker 0, 1, 2, 3, respectively

CTRL-Q 0, 1,2, or 3 Jump to marker 0, 1 , 2, or 3, respectively
C on braces and parentheses to block off sections of text.

relies heavily
You can get into real difficulties if you mismatch braces or parentheses. To help
minimize the chance of this happening, QuickC lets you find matching braces
or parentheses. To find the left brace that matches a right brace you recently
typed,
1 Move the cursor to the right brace whose counterpart you want to find.
2. Press CTRL-} to find the matching left brace. (To find a right brace
matching a left brace, you would type CTRL-} after moving the cursor
to the appropriate location.)
Table 2-15 shows the commands for locating matching braces.
File Manipulation with the File Menu The File menu provides the com-
mands for opening and saving files. You've already used several of these
commands, so the discussion here will be brief
Press ALT-F N to create a new file. You will be asked to provide a name for
this file. QuickC checks for duplicate file names, and will allow you to choose
another name if you are accidentally about to overwrite an existing file with
the same name as the one you want to create.
The Open and Open Last File options let you open existing files for
editing. The Open option (ALT-F O) lets you specify the file to edit. The Open
Last File option (F2 or ALT-F F) opens the file you had open just before
switching to your current work file. For example, suppose you edited game.c
54 Using QuickC
Table 2-15. Commands for Finding Matching Braces
Key(s) Effect
CTRL-{ Find matching left brace

CTRL-I Find matching right brace
then used the Open option to start editing another file, area.h. If you press F2 at
that point, QuickC will automatically return you to game.c, since that was the
last file open before area.h.
Finally, you can write a file to disk using the Save option. If the file has no
official name (that named untitled.c), QuickC asks you to provide a
is, if it is
name. If the file exists, QuickC will prompt you to verify that you really intend
to overwrite the existing version of the file.
The Save As option you specify the name under which to store the
lets
current working file. This can be handy if you need to revise a program
temporarily. For example, suppose you want to modify game.c in some way.
Knowing that the current version of the program works fairly well, you want to
keep that source code from accidental destruction. After making many
changes to game.c, you are reluctant to overwrite the file since your new
version may have unanticipated bugs, in which case you will need to go back to
the original.
To handle this situation, you can create a new file "on the way out." You
can tell QuickC to save the current file under a new name, let's say game2.c.
The original version of the work file will be unchanged, and gamel.c will
contain the altered version of game.c. To accomplish this, press ALT-F A, then
specify a file name and press RETURN.
Table 2-16 summarizes the first set of File menu commands. We'll discuss
the File menu options relating to program lists later in this chapter.
The Search Menu The Search Menu lets you move through and modify
your file based on textual rather than physical criteria. The options you've seen
so far have involved physical units, such as current character, word, or line.
Table 2-16. File IVIanipulation Commands
Key(s)
ALT-F
56 Using QuickC
Table 2-17. Commands to Find and Change Text
Key(s) Effect
CTRL-Q F Find text to be specified

ALT-S F Find text to be specified
F3 Find next occurrence of specified text
ALT-S R Find next occurrence of specified text
CTRL-\ Find selected text
CTRL-Q A Change text to be specified
ALT-S C Change text to be specified
ALT-T (in Change dialog box) Move to Change To box
Find Options When finding and replacing text, you can put constraints on
the actions or make your commands even more summarized in general, as
Table 2-18. The dialog boxes for the Find and Change options allow you to
specify whether QuickC is to consider something found only if it is surrounded
by space or punctuation — that is, if the text is a word, rather than simply part
of a word. To make this stipulation, press ALT-w. This command toggles, so
you can cancel the restriction by pressing ALT-w again.
Similarly, you can specify that the case of the characters in the text found
should match the case in the text you're looking for. For example, if you ask
QuickC to find MAX— ENTRY, and press CTRL-M to select the Match
Upper/ Lowercase option, QuickC will not find Max Entry.
You can also generalize the text QuickC is to find by creating a regular
expression. Regular expressions consist of text that includes certain characters
that are given particular interpretations.To get QuickC to accept your Find
What text as a regular expression (as opposed to a literal expression), you must
select the Regular Expression option, by pressing ALT-R in the dialog box. The
following characters have special significance in regular expressions:
.*$- \[][-][^]
You can put a period ( ) in the Find What text you specify. This tells
.
QuickC to accept any single character in that position. For example, suppose
Table 2-18. Options When Finding Text
Key(s) Effect
ALT-w Require word match

ALT-M Require letter case match
ALT-R Text to find is a regular expression
you specify the following in the Find What dialog box:
QuickC would match any of the following words if they appeared in your file:
doer
door
dour
The search would not match dollar, however, since the period can represent
only a single character. Characters that are used to stand for other characters
in this way are called wild cards.
You can also tell QuickC to accept one or more consecutive occurrences
of a particular character. To do this, put an asterisk (*) immediately after the
character you want to handle in this way. For example, specifying
f\ir*y
matches /urv as well &% furry.

If you put a dollar sign ( $ ) at the end of your Find What text, QuickC will
report only those occurrences of the text that come at the end of a line in the
file. For example, suppose you specify the following as your Find What text:
are you?$
QuickC would match the first of the following lines, but not the second.
;
58 Using QuickC
Hello there. How are you?
/* not acceptable */ Hello there. How are you? That's good.
Similarly, you can begin your text with a caret (" ) to tell QuickC to search
only for text at the start of a line. For example.
finds the first, but not the second of the following lines.
void beep_user ()
void beep_user C); /* Leading blanks are characters too! */
Sometimes you may want to search for the occurrence of any of a number
of characters. For example, suppose you wanted to search for the first occur-
rence of any digit. Both of the following Find What strings would specify this:
If you put square brackets around text in the Find What string, QuickC
will search for the first occurrence of any of the characters specified between
the brackets. The first string explicitly lists each of the digits you are seeking.
The second string uses one of the two special characters allowed within these
brackets.
If you put a hyphen (-) between two characters in this context, QuickC
will search for any occurrence of an ASCII character with a value between the
values of the two characters surrounding the hyphen. It turns out that the
digits are represented as consecutive characters in the ASCII character set (see
Appendix A). Therefore, the second Find What string simply says to match
any ASCII character between and 9 inclusive — that is, between ASCII
values 48 and 57, inclusive.
The other special character is a caret ( ) again. In this context, the caret
'^
must be the first character after the left bracket. The caret tells QuickC to
match any characters except those within the brackets. Thus, the following
expressions both tell QuickC to match anything except a digit:
[0123456788]
[-0-9]
Suppose you actually wanted to search for a dollar sign, a period, or a

caret. The backslash character ( \) tells QuickC to treat the next character
literally, rather than as a special character. The following three strings would
tell QuickC to search for a dollar sign, a period, and a backslash, respectively:
Table 2-19 summarizes the options and characters used in regular

expressions.
Table 2-19. Special Characters in Regelar Expressions
Key(s) Effect
Match any single character

• Match one or more occurrences of preceding
character
$ Match only at end of line
" Match only at start of line
\ Treat following character literally
[ ] Match any characters within brackets

\ (in [ ]) Match any ASCII values between two characters
^ (in
[ ]) Match any characters except those specified
60 Using QuickC
Change Options There are also several options available if your are
replacing text. By default, QuickC verifies each replacement before making it.
This means that QuickC stops at each occurrence of the string to be replaced,
and waits for you to press RETURN to verify that the change should be made.
When QuickC finds the text, it pauses and you are able to specify whether
to change that occurrence or to skip it. To change it, simply press RETURN; to
skip it, press S first. This changes the default setting to Skip, rather than
Change. Now if you want to skip something you must press RETURN. If you
want to change something, press C. This restores Change as the default action.
Notice that these actions merely change the default; they do not affect the
current text occurrence. To do that, you need to press RETURN to verify the
appropriate action. In such a context, pressing RETURN accepts the current
setting, whatever it is at the time.
you do not want QuickC to verify each change, you can press ALT-C in
If
the Change dialog box. This tells QuickC to change all occurrences of the
specified text, without verifying. You had better be sure of this one, because
QuickC makes the changes very quickly.
Table 2-20 summarizes the options you have when changing text.
Two other options on the Search menu are commands to find the next
and the previous error found by the compiler. You learned how to do this
earlier.Such jumps can be very handy if you want to quickly correct the errors
the compiler has found. You can compile your entire file, let the compiler find
all the things to correct, work through the file making the required changes,
then simply compile the program again.
Table 2-20. Options When Changing Text
Key(s) Effect
ALT-c Change each occurrence without verifying

S (when text is found) Change default action to skip
C (when text is found) Change default action to change
The Run Menu

The Run menu lets you compile and execute your programs.
Starting and Continuing Programs Once you've finished editing your

program file, press ALT-R for the Run menu and pressRETURN or S to select
the Start option. This option compiles the program to memory and runs it if
the compilation is successful. This is the option you will usually select while
creating your programs.
The Continue option lets you resume execution of a stopped program. A
program may be stopped because the compiler found an error, or because you
were running the debugger and the program had stopped at a breakpoint. For
example, if the compiler finds an error while compiling your program, it will
put you back in the You can make the correction and tell
program source file.
Quick C to Continue by pressing the F5 function key or CTRL-R N. The

compiler will let you recompile before resuming the program. Table 2-21
summarizes the Run menu options.
Compiling a Program When you compile your program, you may want to
specify various things to the compiler. The Compile option on the Run menu
gives you access to a dialog box containing several possible instructions for the
compiler. Figure 2-7 shows the dialog box for the Compile option.
Table 2-21. Run Menu Options
Key(s) Effect
ALT-R S Start compilingand running

F5 Continue halted program execution
ALT-R N Continue halted program execution
ALT-R R Restart program execution
ALT-R C Set compile options
ALT-R O Set Run-Time options
62 Using QuickC
File Edit Uieu Search mm Debug
Progran List: <none>

Current File: c:vSHVa3.c
Marning Levels Output Options niscellaneous

( ) Leuel e ( ) Obj CXI Debug
(•) Leuel 1 () llenory t ] Pointer Checi<
( ) Leuel 2 ( ) Exe c 1 Stack Check en)

( ) Leuel 3 ( ) Syntax Check Only [X] Language Extensions
[ ] Optinizations
Include:
Define:
Build Progran | Conpile File Rebuild <\l\ Cancel
II
Progran List: <none> Context: <Progran not riinning>
Figure 2-7. Compile option dialog box
One thing you can tell the compiler is how broad a range of warnings it is
to give you during the compilation process. In the C world, compilers are able
to warn you about things in your program that are not syntax errors, but that
may affect program results, execution, or portability. Experiment with some
programs compiling them at different Warning Levels.
Level is completely silent. At this level, the compiler tells you only about
errors, not about questionable practices. Level 1 is moderate, and tells you
about such things as incorrect use of pointers. Level 2 is considerably noisier;
in particular, this level complains about possibly discrepant function declara-
tions and calls. Finally, Level 3 complains about the largest number of things.
including deviations from the Draft Proposed ANSI Standard definition of

the C language. Appendix E in the QuickC Programmer's Guide shows you
the Warning Level required for the compiler warning messages summarized
there. (Compiler warnings are the errors with numbers in the 4000s and with
the prefix C, such as C4056.) In this book, we'll compile with the Warning
Level set to Level 1. The UP ARROW and DOWN arrow keys let you move
among the levels.
The QuickC compiler can create various compiled output versions of
your program. For any compilation, you can have only one of these ouput
options set. If you are just trying to compile and run the program in the
QuickC environment, the Memory option is the appropriate one. This is also
the defauU option. With this option, no permanent compiled version of your
program is created. To select this option if a different one is checked, press M
while in the Compile option dialog box.
If you are building libraries, as described in Appendix B, you will want to
create an object (.obj) file. This is a compiled version of the file that can be
linked with other files when building programs or libraries. To select this type
of output file, press O in the dialog box. To build an executable version of the
program (an .exe file), as you did in the first part of the chapter, press X.
Finally, you can have QuickC check your program only for syntactic
errors, without running the program and without producing either an .exe or
an .obj file. Press Y for the Syntax Check option in the dialog box for this type
of compilation.
The remaining compiler options instruct the compiler to provide various
types of information for use when debugging or running your program. These
option settings toggle. That you select the option
is, if to turn the setting on,
you can turn it off by selecting the same option again.
The Debug option tells the compiler to prepare the information needed
for the debugger to let you step through your program, watching what lines are
executed and what happens to variable values as the program executes. Press
D to set this option.
The Pointer Check option tells the compiler to run portions of your
program during compilation, to make sure you are not using pointers in a way
that could destroy things you want to keep. To select this option, press P in the
dialog box.
Pointer checks are a very good idea when you are first learning C, because
64 Using QuickC
they help protect you against common and careless use of pointers.
errors
When you select this option, the resuhing program may run much more slowly
then otherwise, however To make the program faster, you can tell the compiler
do such checking only for certain pointers. See the Programmer's Guide for
information on how to do this.
The Stack Check option (S in the dialog box) provides another check on
your program's performance. In this case, the compiler tries to make sure that
there will be enough of the required (stack) memory available to load functions
and their variables when running the program. This check is also recom-
mended when you first start developing your program. As with the Pointer
Check option, you can tell do Stack Checks on portions of
the compiler to
your program. See the Programmer's Guide for details.
Microsoft's implementation of C provides the constructs and syntax
specified by the Draft Proposed ANSI Standards committee. However,
Microsoft has provided some language extensions in their C version 5.0 and
QuickC compilers. When writing QuickC or Microsoft C 5.0 programs, you
need to decide whether you will want to compile them under non-Microsoft
compilers. If so, you should not choose the Language Extensions option —
that is, the box for this option should be blank. If you decide to choose the
option, press L.
Finally, you can ask the compiler to generate the fastest code it can, at the
price of making the resulting program file somewhat larger. To select this
option, press Z.
As you'll find out in Chapter 4, C programs often use header files that
contain special definitions or other information. Ordinarily, QuickC has
certain default places where it searches for such files. Two places are the
current directory and the \include directory (if you installed QuickC with the
default directory structure).
You may want QuickC to search other directories as well when compiling
a particular program. In that case, write the paths to all these directories in the
Include text box. These paths should be separated by commas, and the names
must conform to DOS conventions. To get into the Include text box, press I if
you are in the dialog box for the Compile options. Press ALT-l if you are in the
Define text box.
The Define text box letsyou specify definitions that are to be used with
the current program file. Press F in the dialog box or ALT-F if you're in the
Include text box. This facility is useful if you want to compile your program
differently under different circumstances. You are unlikely to need this facility
very much when you first start programming in C. See the Programmer's
Guide for more details about the Define text box.
Once you've set everything the way you want it, you can tell QuickC what
to compile by selecting one of the boxes at the bottom of the Compile option
dialog box. The Build Program option compiles only those source files used in
the program that have been changed since the last compile, and links these
with the unchanged object files. Press RETURN to select this option.
To compile just the source file you're editing, press C, to select the
Compile File option. Finally, to compile all source files used in the program,
regardless of whether they have changed, press R to select the Rebuild All
option.
Table 2-22 summarizes the compiler options.
Table 2-22. Compiler Instructions
Key(s) Effect
UP ARROW Change warning Level setting

DOWN ARROW Change warning Level setting
M Compile to memory
Compile to object file
X Compile to executable file
Y Just check syntax, do not create a compiled file
D Turn Debug on/off

P Turn Pointer Checks on/off
S Turn Stack Checks on/off
L Turn Language Extensions on/off
Z Turn optimization for speed on/off
1 Search in paths to be specified for include files
ALT-i Search in paths to be specified for include files
D Include definitions to be specified
ALT-D Include definitions to be specified
B Compile only changed source files
C • Compile only current source file
R Recompile and relink all source files
66 Using QuickC
Run-Time Options Sometimes you will want to specify certain things

when running {rather than compiling) the program. The Run-Time option on
the Run menu lets you specify such information. Earlier you saw how to
specify additional information to be passed to the program before it starts. You
specified a seed to be used in generating random facts. To specify such
information, type the information in the Command Line text box.
The only other Run-Time option you might use when you first start out is
the Stack Size option. If the Stack Check compiler instruction indicates that
there is not enough stack space to run your program, increase the value
currently specified for this option, by pressing ALT-s and specifying the
amount of stack space to allocate. The largest amount of stack space you can
allocate is 65,536 bytes (64K).
Table 2-23 shows the Run-Time options. These options are available only
in the dialog box for Run-Time options.
The Debug Menu

In the first part of the chapter, you learned how to step through a program,
watching the changes in values of specified variables at certain lines in the
program. You used the QuickC debugger to do To make use of the
this.
QuickC debugger, you first need to compile your program with the Debug
Compile option on (with an X in the Debug option box), as you did earlier.
Table 2-23. Run-Time Options
Key(s) Effect
ALT-N Specify space to be allocated for global variables

ALT-s Specify stacl< space to be allocated for local
variables
Once this is done, you can specify the variables and expressions you want
to watch while running the program. To do so, select the Add Watch option in
the Debug menu (ALT-D RETURN), and write the variables or expressions you
want to watch into the text box that appears when you select this option. If you
want to watch more than one variable or expression, they must be separated by
semicolons.
You can ask to see the values of the watch variables in a variety of output
formats, including octal (base 8) and hexadecimal (base 16). These are de-
scribed in the Programmer's Guide, and Appendix C. They are similar to the
formats you can use to display information in C programs, as described in
Chapter 5.
You can delete all currently set watch variables by selecting the Delete All
Watch option in the Debug menu (press ALT-D L to do this). Or you can delete
the most recently specified watch variable by selecting the Delete Last Watch
option (press SHIFT-F2 or ALT-D E).
If you select the Trace option in the debugger, the program will execute
from breakpoint to breakpoint. In the process, each statement will be high-

lighted as it executes. If this option is off, only the breakpoint statements will
be highlighted during execution. This option toggles. The default setting is off
To turn this option on, press ALT-D T When tracing is turned on, a check will
appear next to the option in the Debug menu.
Finally, you can set breakpoints as you did earlier in the chapter. To set a
breakpoint, move the cursor to the desired line in the file. Then press the
function key F9 or press ALT-D B to set a breakpoint at that line. This
command also toggles. To clear all breakpoints, press ALT-D C.
Table 2-24 summarizes the Debug menu options.
Searching for Functions

The Search menu includes a Function option that we haven't yet discussed, but
that can help make program editing easier. The Function option lets you jump
to the beginning of a function's definition in the file.
That is, this command essentially serves to find something. However, it
doesn't simply find an occurrence of a particular phrase (here, a function

name). Rather, it finds a. particular occurrence of this phrase — namely, the
occurrence that begins the definition of the function itself.
68 Using QuickC
Table 2-24. Debug Options
Key(s) Effect
ALT-D A Add watcli variables

SHIFT-F2 Delete last watch variable set
ALT-D E Delete last v\/atch variable set
ALT-D L Delete all watch variables currently set
ALT-D T Turn tracing on/off
ALT-D S Turn screen swapping on/off
F9 Turn breakpoint on/off
ALT-D B Turn breakpoint on/off
ALT-D C Clear all breakpoints
For example, nice print is the name of a function in the game.c pro-
gram. This name occurs at several points in the file. Ifyou search for this name
using the Find option in the Search menu, the first occurrence will be near the
beginning of the function main( ), since this is the first time the phrase
nice print is used in the file.
Ifyou search for this same name using the Function option — that is, by
pressing ALT-S U — the cursor will be moved to the left brace that starts the
main body of the function, near the end of the game.c file. This is convenient
when you have large files, or when you are trying to find a function that is
called frequently in the program.

To make it possible for QuickC to find this particular occurrence of a
function name, you first need to compile the program with the Debug com-
piler option selected. Again, this provides the information needed to deter-
mine which occurrence of the name in a file represents the beginning of the
function's definition.
Table 2-25 shows the command for finding a function's definition.
Program Lists
Many C environments have utilities that will let you keep track of changes
made to different files that make up a larger program. This is important when
you have large programs that take very long to compile.
Instead of compiling the entire program each time, it is often possible to
recompile only those component files that have changed since the last time the
program was compiled. These new .obj (object) files can be linked with object
versions of the unchanged files that did not need to be recompiled.
\ program list specifies all the source files that are used in a program. You
can create a program list for a program by using the Set Program List option
on the File menu. Press alt-F S to get a dialog box that will let you specify the
files to be included in the program list. For each file, or program module, you
want to include in the program list, type the name and press RETU RN. If the file
is not yet on the list, QuickC adds it; if the name is already on the list, QuickC
removes it. That is, the Add/ Remove option in the dialog box toggles. When
you have finished entering all the file names, press ALT-S to save the file.
QuickC will create a file with the same name as your program, but with
the extension .mak. This file will contain the information the compiler needs to
determine what files to recompile.
To discard a program list associated with a program, use the Clear option
in the File menu after you've called up the program source file. To edit an
existing program list, press ALT-F E.
Table 2-25. Commands to Find a Function's Definition
Key(s) Effect
ALT-s U Find start of function to be specified

70 Using QuickC
You probably won't need program lists when you first start programming
in C, but you'll find this facility extremely useful when you start writing long
programs. See the QuickC Programmer's Guide for more details about pro-
gram lists.
Table 2-26 summarizes the File menu options for working with program
lists.
Other Features
QuickC includes two additional features that can be very helpful on occasion.
Sometimes it can be useful to have a printed version of your You can
file.
print your file, or portions of it, while in QuickC. To do this, press ALT-F P to
call up a dialog box for printing. Specify whether you want to print the entire
file or just the text you have marked. The Print option sends your file to the
printer attached to LPTl.
QuickC also lets you go back, temporarily, to the DOS command line.
This command suspends (but saves) your current session with QuickC, and
temporarily transfers control back to DOS. QuickC remains in memory,
however, because you will return to the QuickC environment. To specify this
command, select the DOS Shell option on the File menu (press ALT-F D).
Table 2-26. Commands for Program Lists
Key(s) Effect
ALT-F L Create a program list file
ALT-F E program list file

Edit existing
ALT-F C Clear program list associated with file
Once on the DOS command line, you can run other programs or do
whatever you need, within Hmits. Be very careful when deleting files during
such a side do not delete any .mak files, source files, or files
trip. In particular,
included in your current program list. See the Programmer's Guide for more
information. When you're finished with DOS, type
to return to QuickC. Table 2-27 summarizes these commands.

We have not covered all the features and commands available in QuickC,
since that would take us beyond what we can cover in this book. As you
become more proficient in C, you may find a need for these other features. At
that point, with a solid grasp of the more common commands and features
that you'll gain by working through this book, you can learn about these
additional capabilities.
One topic about which you may want more information is compiling and
linking programs outside the QuickC environment — that is, using the com-
piler and linker separately for greater flexibility. A brief introduction to this
topic is included in Appendix B.
more information about QuickC in Appendixes C and D,
You'll also find
which provide a QuickC command summary and a comparison of QuickC
and Microsoft C 5.0, respectively.
Table 2-27. IVIiscellaneous File Menu Commands
Key(s) Effect
alt-fP Print current file

ALT-F D Exit temporarily to DOS shell
72 Using QuickC
Summary
In this chapter, you've had an informal introduction to QuickC and how to use
it; you've also read a brief discussion of the most common commands and
features. There's much more to learn about QuickC, but there's little point in
doing so more about C, which is what you're about to do.
until you've learned
The following chapters will tell you about C and will give you an oppor-
tunity to consolidate your understanding of the features and capabilities of
QuickC so that you can take advantage of this powerful environment from the
start of your C programming career. Happy learning!
Simple Types
and Operators
In this chapter, we'll look at some of the data types available in C, and how to
define variables in a program. We'll look at some of the operators C provides
for working with data. In the process of exploring these topics, you'll learn the
rules and conventions for naming things in C. You'll see that there's more than
one way to write a number or a letter.
Before jumping into these topics, let's look quickly at some of the general
characteristics and components of a C program —
the program itself, func-
tions, and statements. You'll find enough information about these elements to
provide a foundation for the other constructs in this chapter.
73
;
74 Using QuickC
C Program Structure
C programs consist of functions (similar to subroutines in other programming

languages); functions consist of statements. Statements serve to define or
express something, or to carry out some action. The following program
illustrates each of these:
/* Sample C program to illustrate three components of a program:

program; functions; statements.
*/
mainO /* the main program */

{
lirst_message (); /* call function f irst.message */
second_message () ; /+ call function second.message */
}
f irst_message () /+ a simple function: writes a word on screen. */

{
printf ( "hello, ")
}
second_message () /* another simple function; write to screen. */

<
printf ( " world\n");
}
This program is similar to prior examples in Chapter 1. This time, however,

let's focus on the components of the program, rather than on what the
program does.
First, all information in this listing is contained in the same source file.
The program contains three functions: first _message( ), second _niessage( ),

and main( ). The actual program starts executing with niain( ).
The niain( ) function contains two simple statements, each a function call
(the command to execute a function) and each ending with a semicolon (;).
The function calls have a format similar to the printf( ) calls in the Chapter 1
examples. This time, however, calls are to functions already defined in the
program.
Note that parentheses are used when main( ) calls the functions, even
though there are no arguments (values or variables) to be passed to the
functions. In C, these parentheses are necessary when calling any function.
The two "message" functions, first message( ) and second niessage( ),
each call printf( ). This time, calls to printf( ) have only one argument. Every-
thing to be written is contained in the first arguments ("hello," and

"world \n"); there are no placeholders to be replaced when actually writing.
This is not an efficient program because the job could have been done by
main( ) alone, calling printf( ) directly. However, the purpose here is not to
write an efficient program, but to illustrate functions, function calls, and
statements.
Comments
Program comments make it possible to include remarks and reminders within
program listings. This, in turn, makes it easier for other people to read your
code, and help you to understand your own code six months after you wrote it.
Comment your code thoroughly. The next time you need the code you will
thank yourself
Program comments in C begin with /* and end with */. The compiler
ignores all material between the comment start characters *) and the com- (
ment finish characters (*/). Comments may occupy multiple lines, but you
may not nest comments, as shown in this (incorrect) example;
/* Nested comments, such as /* followed by * are not allowed. */
because the compiler takes the first * / encountered as the end of the comment,
leaving "are not allowed.*/" as uncompilable text after the comment.
^CAUTION Beware of accidentally commenting out code (inadvertently

including code between comment start and finish characters). If you do that,
you may lose lots of hair, sleep, or both, trying to find your programming
error.
C's main() Rule

C programs are built of functions. For now, think of a function as consisting of
a name or identifier (such as main), followed by a pair of parentheses ( ). which
may be filled under certain conditions. These two components (identifier and
parentheses) make up the function's interface. The actual body of the function
is contained between the left curly brace following the function interface and
;
76 Using QuickC
the matching right brace. Figure 3-1 shows a function's major components.
The main( ) function is special in C. A C program starts executing in
niain( and the function's closing brace marks the end of the program. All
),
other function calls are made (directly or indirectly) from main( ). Put simply,
main( ) is the program.
Although a program begins and ends with niain( ), you can place this
function anywhere in your program file. You may not have more than one
main( ) in a program. If you do, you'd have two programs.
^REMEMBER C programs must have the main( ) function since the pro-
gram starts and finishes executing in this function.
The printfO Function

The printf( ) function serves to write information to the screen. It is predefined
in QuickC and in other implementations of C. To call printf( ), type the
function name, putting any arguments to the function within the parentheses.
(An argument is information passed to a function; the function is generally
expected to use or modify the information. Functions may have more than one
argument.)
The following is a call to printf( ) with one argument:
printf ( "a string argument for printfO"):
main () -^ Function name

{ -* Opening brace for function
f irst.message () ; -*— Statements (function calls)
second.nessage {)
} -^ Closing brace for function
Figure 3-1. Major components of a C function

; ; ,
This function call writes the sentence within the double quotes to the screen.
Writing to the screen can be a simple task or it can involve various
substitutions by printf( ). The string argument to printf( ) may contain special
character sequences, beginning with %, that serve as placeholders for other
information. When printf( ) does its work, it replaces each placeholder by a
value of a specific type. The following program illustrates placeholders and
some other features of printf().
/* Program to illustrate some features of function printfC). */

#include "strings. h" /* Read file containing string definitions. */
main ()
<
int il, i2; /* define two variables */
il - 37;
12 = 73;
printf ( "one string, \n but written on two lines\n\n");
printf ( "one placeholder, for a string: y,B\n\n" PF.EXAMPLE) ,
printf ( "one placeholder, for an integer: %d\n\n" il) ,
printf ( "two placeholders, both for integers: y,d and '/,d\n\n" il, ,
printf ( "two placeholders, a string: %s and an integer: '/,d\n\n"

,
PF.EXAMPLE2, il);
printf ( "four integer placeholders, note spacing: %d '/,d'/,d '/.dXnNn"
il, 12. 11. 12);
This produces the following result:
one placeholder, for a string: THE SUBSTITUTED STRING.
one placeholder, for an integer: 37
two placeholders, both for integers: 37 and 8
two placeholders, a string: THE STRING PORTION, and an integer: 37
four Integer placeholders, note spacing: 37 7337 73
Again, this program has many aspects in common with the examples
you've seen. There is which contains the values substituted for
a header file,
PF_EX AMPLE and PF„EXAMPLE2; there is a variable definition; and

the calls to printf( ) write things similar to what you've seen in earlier examples.
A feature of printf( ) that has not been explored in previous examples is
that it can be called with a varying number of arguments. The first call
contains only a string (contained within quotation marks), without place-

holders. Don't be misled by the fact that the output appears on two different
78 Using QuickC
lines. This is because the \n (for newline) escape code was placed in the middle
of the string. (The two newhne commands at the end of the string terminate the
second line and force a blank line in the output.) Calling printf() with just a
string is probably the simplest call you will ever make to the function.
Each of the next two calls has two arguments. In both cases, the first
argument has a placeholder in it (%s and %d, respectively). The printf()
function replaces each placeholder with the information contained in the
second argument. In one case, the second argument has a string value; in the
other, the argument is an integer variable. In each case, the placeholders (%s
and %d) will be replaced by the current values of the second argument.
The next two calls have thiee arguments each: a string argument and two
additional arguments. In each case, there are two placeholders in the string
argument (which is always the first one). The number of placeholders in the
first argument must always equal the number of additional arguments to
printf( ).
Look at the output for these calls, particularly the spacing. In the call that
writes a string and an integer, notice that the comma comes immediately after
the substituted string, without space. Also, there is no space between %s and
the comma in the string argument to printf( ) for that example.
Finally, the last call to printf( ) has five arguments. This statement is
intended to clarify some points about spacing in the output. Notice in the
output that the middle two numbers are "fused. "There is no space between the
73 and the 37. Now look at the function call that generated this output. There is
no space between the middle two placeholders; hence, there is no space
between the numbers substituted for them in the output.
Later, we'll look at other placeholders and at additional format com-

mands available when using printf( ). For now, there are three aspects of the
function to keep in mind:
• The printfO function generally has at least one argument, a string

(enclosed in quotation marks). This may be followed by additional
arguments, separated by commas. Each additional argument consists
of a variable or expression.
• Portions of the string argument that begin with % are placeholders that
specify where particular values are to be placed, and the type (integer,
string, etc.) of variable to be written at that spot in the output.
• You must have exactly as many placeholders in the first argument to

;
printfO as there are additional arguments.
^REMEMBER If there are multiple arguments to printf( ), the string argu-

ment must be first.
Escape Codes
You have already seen the use of the newline character, \n, to move to the next
line in the output. Newline is an example of an escape code or escape sequence.
You may put escape codes anywhere in your string argument to printf( ).
Escape codes consist of two characters: a backslash ( \) followed immediately
by a single character. For example:
\n (newline)
\t (tab)
\b (backspace)
\\ (backslash character)
are all escape sequences. Escape codes are two characters long (with one group
of exceptions, which we'll see later). Any characters after the escape code are
considered part of the regular string, rather than of the escape sequence:
printf ( "line 1 \najid line 2\n");
produces the following output:
Because the escape code for a new line ended with \n, the character a was
treated as the next character in the string.
Table 3-1 summarizes some of the more common escape sequences.
Given the information in this table, how would you write a single quote ( ')? Try
it. What do you suppose will happen if you write \r, followed immediately by
\b? Also, can you predict the output from the following printf( ) call?
printf ( "a \bn historic occasionXno?")

; ;
80 Using QuickC
Table 3-1. Common Escape Sequences
Escape Code Meaning Description
\ b backspace IVlovecursor one space to the left

\n newline IVlovecursor to start of next line
\r CR Return cursor to start of current line
\t tab Move cursor to next tab position
\ \ \ Write the backslash character
\" " Write the double quote character
Statements
Statements are the main components of functions, instructions, or definitions.

C allows simple and compound statements. Statements can be used in various
contexts (for example, if-then tests and loops) and can serve many purposes,
such as writing expressions, assigning a value, returning from a function, or
continuing a loop. In this section, you will find some basic information about
statements and their use.
Simple Statements
The following are all simple statements in C:
printl ( "this is a simple statement in C\n'*) ;
curr_int = 7
return ( 8.5)
continue;
Each simple statement ends with a semicolon. Semicolons are important

characters in C, as they are in languages such as Pascal. Their use is different,
however. In Pascal, semicolons separate statements, meaning that you need to
put a semicolon after a statement only if there is another statement after it. In
C, semicolons tertriinate statements, meaning that you must put a semicolon
after a statement, whether another statement follows or not.
^REMEMBER Every simple statement in C must end with a semicolon.

;;
Compound Statements
You can "collect your thoughts," by grouping several statements together and
treating them as a single, extended statement, known as a compound state-
ment. A compound statement consists of zero or more statements (simple or
compound), with the statement collection being bounded by left and right
curly braces ({ and |), respectively. Compound statements are often called
blocks. Thus, the and symbols correspond to BEGIN and END, respec-
{ 1
tively, in languages such as Pascal.

The following are two compound statements:
printl ( "this is not");

printl C
" a simple statement An")
printf ( "since it consists of several simple statements");

printf { " followed by a right brace. \n");
printl ( "The entire collection of statements makes up a");

printf ( " compound statement .\n")
In Pascal, some programmers omit the semicolon between the last state-
ment in a block and the END that terminates the block. However, they must
usually put a semicolon after the END, since another statement is likely to
follow. In C, the semicolon rules are just the reverse: you must end the last
statement before the right brace with a semicolon, but you need not put a
semicolon after the right brace.
^REMEMBER Compound statements in C consist of simple or compound

statements bracketed by { and j.
We'llexamine certain types of statements (such as assignment statements)

later in this chapter. For now, just remember when and where you need
semicolons. (Incidentally, what do you suppose will happen if you change the
compound statement {;) to {
} ?)
Identifiers
So far, we've discussed two functions, namely main( ) and printf( ); we have
82 Using QuickC
used some variables (il and i2); and we've used names for values specified in
header files: PROG_MESSAGE, PF_EXAMPLE, PF_EXAMPLE2,
and FALSE. In what constitutes a valid name, or
this section, you'll learn
identifier, in C. and also learn about some naming and spelling conventions
among C programmers.
Naming Rules in C
The naming rules for C variables and functions are similar to the rules in other
languages. An identifier, or name, consists of some combination of valid
characters. The only real trick is remembering what characters are valid and
when each is valid. Valid characters for C identifiers are:
• The letters 'A' through 'Z', 'a' through 'z' (letters);
• The underscore characters, '

'
(underscore);
• The characters '0' through '9' (digits);
Identifiers nwsi begin with a letter or an underscore. Digits are not allowed as
the first character of an identifier.
^REMEMBER must begin with a letter or an underscore; this

Identifiers
starting character may be followed by any combination of letters, digits, or
underscores. Identifiers may not begin with a digit.
Table 3-2 shows examples of valid and invalid identifiers. The table also
contains a column of identifiers on which to test your understanding of the
naming rules for C. If you're unsure whether an identifier in the third column is
valid, try it in a short program. Even you are sure, it's sometimes interesting
if
to test your certainty; after all, surprises do happen.

By convention, library variables and functions (which we'll discuss later)
often have names beginning with an underscore. Don't start your identifiers
with an underscore. For example, try to keep from using names such as
_ my —identifier for your variables and functions.
In C, the case of the characters in a name does matter. Thus, hello. Hello,
and HELLO are different names. If you are used to languages (such as Pascal)
where case does not matter, you'll need to be extra careful.

Table 3-2. Identifiers-

84 Using QuickC
No Keywords for Identifiers
As you read in Chapter 1 , C is a small programming language, with only about

30 keywords. Although the list is small, C is very serious about these words
being reserved. Compilers will not let you use any of the keywords as identifi-
ers. Table 3-3 lists C's keywords.
^REMEMBER You may not use reserved words as identifiers.
Keywords in parentheses in Table 3-3 have been added in the proposed

ANSI standard version. Some older compilers also include the following
reserved words: asm, entry, fortran.
Variable Definition:
IVIalcing Room
C programs generally manipulate information stored in specific memory
locations in your computer. When writing a program, you'll use variables to
store the information. A variable is essentially a slot capable of holding
information.
A memory address is associated with a variable, and the variable's value is
stored at that address. To use variables in C, you must give the compiler a list of
variables names that you'll be using in your program. For each variable
identifier, you must also tell the compiler what kind of information you want to
store in that variable; that is, you must associate a type with each variable
name.
A variable's type tells the compiler something about how the information
is to be stored, what operations can be performed on the information, and also
how much storage space must be allocated to store the variable's value.
When you provide both a variable name and a type specifier, you are
Table 3-3.
.
86 Using QuickC
P^REMEMBER A variable definition has the following form:

<variable type> <variable identifier>[, <variable identifier>]\
Terms in the braces may be repeated; the semicolon is required.
Terminology for variable definition is inconsistent and may be a bit

confusing. Sometimes you'll see a related term, variable declaration, used to
represent the process of specifying variable identifiers and types. However,
variable declaration differs in subtle ways from the definition process de-
scribed above. Until we get to the differences, don't worry about it; just try to
get into the habit of using "definition" in this context.
Assignment Statements
Values are stored in variables by means oi assignment statements. This process
puts the value found on one side of the assignment statement into the variable
specified on the other side. Assignments are made using the assignment
operator (=). For example, the followmg listmg shows how to assign a number
to a variable.
main ()
{
Int il, 12;
11-37;
12 - 27 + 10;
printf ( "after asslgnnent, 11 has the value ild\n" , 11);
prlntf ( "after assignment, 12 has the value Xd\n" , 12);
This program does three things:
1 Defines variables il and i2
2. Assigns 37 as the value to both il and il
3. Writes values of variables to the screen along with messages
The variable definition has set aside space for two variables of type int.
The assignment operator, = stores the value on the right side of the
first ,
assignment operator (37) in the variable specified on the left side (il). The
result is that the memory location associated with il now contains the value 37.
In the second instance, the system first evaluates the expression to the
right of the assignment operator (27 + 10), then assigns the result of the
evaluation to the variable, i2.
In the first assignment, the right hand side of the assignment statement
contains a single number. The right hand side can also be a more complex
expression, which evaluates to a specific value, as in the second assignment
statement. In that case, the system first evaluates the expression, then assigns
the result to the variable on the left.
^REMEMBER C assumes that you are assigning values of an appropriate

type to a variable.
C gives you great flexibility in the expressions you can put on the right
The expressions can actually contain assign-
side of the assignment operator.
ments under certain conditions. Such assignments "within" assignments are
unnecessary and potentially troublesome.
If you want to explore complex assignment statements on your own,
begin with a statement such as this:
Make sure you have defined all three variables to be of the same type.
What are the values of i2 and i3 when all the assignments are completed?
What, if anything, does this tell you about the order in which QuickC evaluates
assignments? Use printf( ) to answer these questions.
Initialization During
Variable Definition
There is a special form of assignment that can be used under certain circum-
stances. Essentially, a variable can be initialized when it is first defined. Look
carefully at the following program:
main
int il = 45, 12 • 23;

;
88 Using QuickC
printf ( "the Initialized il has the value %d\n" . il)

printl ( "the initialized i2 has the value '/,d\n" , i2)
This program writes the values of the two variables, il and 12. While basically
thesame as the previous program, this version does not have the two assign-
ment statements of the earlier listing.
This time, the assignments are made when the variables are defined. In
this program, the system immediately stores the value 45 in the memory
location reserved for il when that variable is defined; in the same way, the
system stores the value 23 in i2.
C will let you assign initial values to variables when you first define them.
Because variables are separated by commas in a definition statement, all you
need to do is add the assignment operator and the initial value before the
comma.
You cannot nest initialization assignments in QuickC. The following is
invalid:
int il = i2 = i3 = 45;
This is only one way in which the initialization rules differ from those of
regular assignment in C; you'll learn about other restrictions later.
^REMEMBER You may not initialize multiple variables with nested

assignment statements.
Simple Data Types
After the brief discussion above of the structure of C programs and functions,
let's find out about some of the data types C provides for programmers.
Variables may contain simple pieces of information (such as a character
or a number) or multiple pieces of information (such as a string of characters
or an array of numbers).
In the following discussion, we'll concentrate on variables that contain a
single piece of information. Such variables belong to a simple data type.
C has the "usual" simple data types, characters, integers, and numbers
with fractional components. In addition, C allows variants on some of these
types, and lets you convert some simple types into others. Simple types include
char, int, float, and double. These types differ in the sort of information they
contain and amount of storage space

in the allocated to them on different
systems, ranging from to 8 bytes.
1
The char Type

C's character type is known as char. C allocates 1 byte for storing a character.
This means you can have at most 256 character values. Generally, the byte used
to store a character variable is interpreted as having values ranging from — 128
to 127. QuickC represents characters this way.
Depending on the character encoding scheme used, positive values of a
character variable correspond to particular characters. For example, a charac-
ter value of 100 corresponds to the character d in the ASCII character set used
on most systems. (See Appendix A for a list of ASCII codes.)
Negative values generally do not have a "useful" interpretation; however,
the values themselves can be used in operations, as we'll see.
The int Type

The integer type (int) is used to represent whole numbers within a specified
range of values. Variables of type int are usually stored in a 16-bit area of
memory on PCs. This letsyou store 65536 different values. QuickC uses the 16
bits allocated for int variables to represent values ranging from — 32768 to
32767(-2'^{151 to2^{15i-l).
On larger systems, 32 bits may be allocated for an integer, with possible
values rangingfrom-2,147,483,648 to 2,147,483,647 (-2'^{31! to 2'^{31}-1).)
Suppose you try to represent a number larger than the maximum possi-
ble? If you try to store such a number, you will get odd results. For example, if
you try to add to 32767 on a computer with 16-bit integers, you will not get
1
32768. Try Because of the way integer values are represented, the system
it.
ends up reading this new value as a very large negative number. This result is
; ;
90 Using QuickC
due to overflow in the representation of the integer; overflow simply means

you have exceeded the possible range of values.
^REMEMBER Beware of overflow when doing computations using integers.
What do you suppose will happen if you try to use a negative number
beyond the allowable range? For example, what does the following program
return?
/* Sample program to illustrate the consequences of trying to use

values beyond the permissible range of integers.
*/
main
int il, i2;
il * -32770; /* exceeding negative range limit by 2 /

printf ( "instead of -32770, il has the value XdNn" il) .
i2 = 32769; /* exceeding positive range limit by 2 */

printf ( "instead of 32769, i2 has the value '/,d\n" i2) .
Hint, think of the integer values as being on a giant wheel, with at the top,
and the maximum and negative values next to each other at the
positive
bottom, as shown in Figure 3-2. Then think of overflow conditions as arising
when you continue counting in the same direction, but past the maximum
value.
The float Type

This type represents what is known as a floating point or real number. A real
number is one that may have a fractional part, as opposed to an integer, which
is a whole number.
Such numbers are called numbers because a value is usually
floating point
represented in three parts, a sign, a numerical value, and an exponent that
tells how to move the "decimal" point separating the fractional from the whole
number part. For example, you can represent the number 500.250 in each of
the following ways. 500.250eO, 50.0250el, or 50025.0e-2. These representa-
tions tell you to move the decimal point places, 1 place to the right, and 2
places to the left, respectively.
2765 32765
32766 32^56
32767 32767
-32768
Figure 3-2- êpresentaHon of Oie" c '
latenaUy, float \'alaes also are stored in three components, a sign bit,
some number of bits to store a fractional component of the number (called the
numtissa), and the remaining bits to store an exponent (see Figure 3-3). These
components correqmnd to the three parts ofai floating point representation.
The only difference between the actual representation of floats and our
discussion is that the internal values are all in terms of binary values. (That is,
the exponent in an internal representation tdls ho«' many "binary" places to
move the point.)
92 Using QuickC
Float (32 bits)

; ; ;
As with floats, arithmetic makes the range of possible values larger than it
might have been. A double allows representation of values ranging from 1.7 *
10~ to 1.7 * 10"^
, with the same range of values possible for negative
numbers.
The main difference between floats and doubles is the amount of space
allocated for these numbers. Be careful about assuming that two variables have
exactly the same values. Because of the way floats and doubles are represented,
not all possible values within the permissible range can be represented. Also,
intermediate computations in an expression may introduce rounding errors
that could change the value of a particular variable slightly. This means that
such values may only be approximately correct, or nearly equal. (For most
you won't need to worry about the
calculations, effects of such errors. Just
remember they can occur.)
The following listing and output illustrate some of the ways in which
values can differ because of limited representation accuracy and because of
factors such as rounding when computing results.
/* Program to illustrate that

1) floating point representations are only approximate, that
2) rounding errors in computations can lead to different values, and that
3) double representations are more accurate than float representations.
•/
main ()
<
/• define float and double variables:
initialize to arbitrary starting values.
*/
float fl - 230.6.
f2 - 230.6. f3 • 1.0.
f dv - 11.0; /* float DiVisor */
double dl - 230.6,
d2 - 230.6, d3 - 1.0,
d_dv • 11.0; /* double DiVisor */
/• display initial values. */

prlntf ( "STARTING VALUESVnfl - X20.17f\ndl - X20.171f\n\n" , fl. dl)
/* compute quotients, using REPEATED DIVISION */

fl - fl / f.dv / f.dv / f.dv / f.dv / f.dv / f.dv / f.dv;
dl - dl / d.dv / d.dv / d.dv / d.dv / d.dv / d.dv / d.dv;
/* compute new divisors, using REPEATED MULTIPLICATION •/

fS - f3 • f.dv * f.dv • f.dv • f.dv • f.dv • f.dv • f.dv;
d3 • d3 * d.dv * d.dv • d.dv * d.dv » d.dv * d.dv * d.dv;
/• compute "same" quotients, using SINGLE DIVISION •/

fa - f2 /f3;
d2- d2 / d3;
/• display new results */

printf ( "RESULTS\nf2 - X20.17f\nd2 • X20. 171f\n\n" , f2, d2)
/• display the DIVISORS used */

printf ( "DIVIS0RS\nf3 - X20.17f\nd3 X20.171f\n\n" . f3. d3)
; ;
94 Using QuickC
/* report outcone •/
prinM ( "X20.17f (fl) does NOT equal\nX20.17f (12)\n\n\n", fl. f 2)
prlntf ( "X10.1711 (dl) equals\n%lB.171f (d2)\n". dl d2) .
/* Output lor listing •/
STARTING VALUES
fl - 230.60000000000000000
dl - 230.60000000000000000
RESULTS
f2 - 0.00001183342556033
d2 - 0.00001183342620640
DIVISORS
13 - 19487172.00000000000000000
d3 - 19487171.00000000000000000
0.00001183342646982 (fl) does NOT equal

0.00001183342556033 (f2)
0.00001183342620640 (dl) equals

0.00001183342620640 (d2)
This program computes the "same value" in two different ways, and displays
the results of the two computational methods. The program does this with
variables of type float as well as double. The results for the two types are
different.
The method computes the quotient by repeatedly dividing the cur-

first
rent value by the same divisor, until the division has been carried out far
enough. Each division may introduce approximation errors.
The second method first multiplies the divisor by itself as often as needed
to get the "appropriate" quotient. Then the program carries out the division.
Each multiplication may introduce approximation errors, but these will be
different from those introduced by repeated division.
Mathematically, these two methods produce the same results. Therefore,
any differences are due to representation or computational "approximations."
There are three differences in the output; there is also one important result
where there is no difference.
The difference between fl and f2 is the result of computation error The
difference is very small, less than one part in 10 billion. You won't have to
worry about such errors in most of your work, since they will probably be too
small to make any practical difference for your answer.
If the two answers are not identical, which is more accurate, which is
Such questions are studied (and sometimes even

closer to the "true" result?
answered) by analyzing algorithms (computational methods). Keep in mind
that sometimes the manner in which you compute a result might make a
difference in the outcome.
Notice that the two double results are identical. That's because the
precision used to represent double values is enough to be accurate within
great
17 decimal places for this problem. If you did enough computations, you would
get differences even in the double representation.
The differences between f3 and d3 and between
and d2 are also due in
f2
part to the effects of rounding during computations. The differences between

the divisors (f3 and d3) show that such errors arise even when dealing with
large numbers.
The last point to notice concerns the output format specifications. Notice
that the float results (fl versus f2) are indented one column, unlike the double
two outputs. The float information is
resuhs, because of the field widths for the
to be written in 20 columns, the double information in 19. The format specifies
17 decimal digits, the decimal point takes one place, and the takes another.
This makes 19 places, and leaves one empty column in the float output. In such
a case, the function puts any empty columns to the left of the output.
Integral and Floating Point Types

So far we have seen four of C's simple data types, char and int variables are
called integral types, and float and double diXtfloating point types. The reason
for including char as an integral type will become clear soon.
Exploring Simple Types
The following program shows how to define and write simple types. The
program is fairly long, and contains lots of new features. We'll go through it in
detail in the following pages.
/* Sample program to illustrate properties of simple data types

and certain syntactic rules and conventions for using these types.
•/
main ()
<
char cl, c2. c3; /* define three variables of type char */
int il. i2. i3: /* ... type int */
float fl, f2; /* ... type float */
double dl, d2: /* ... type double */
; ; ;;
96 Using QuickC
/* assignment statements involving chars; note the different uses. */

cl = 'a': /* assign character constant 'a' to variable cl */
c2 = 97; /* substitute 353 (255 + 98); what's happening? */
c3 = cl + 3; /* what are the types in this "addition" expression? */
/* display the inforration; note the differences between the 2 lines */

printf ( "char as char: cl = 7,c c2 = '/,c c3 = */.c\n" cl, c2, c3)
; ; , ;
printf ( "char as int cl = '/,d; c2 = '/.d; c3 = '/.dNnXn"

: cl. c2, c3) .
/* assignment statements for ints; note the types in third assignment */

il = 23;
i2 = il + 3;
i3 = i2 + cl; /+ note types being added. */
/* write the int values */

printf ( "ints: il = '/.d; i2 = '/.d; i3 = '/.dXnXn" , il. i2, i3)
/* assignment statements for floats. */

fl = 23.000000000000001;
f2 = fl + 3.00000000000000; I* see result of this addition. */
/* write float results; note use of formatting */

printf ( "float fl - '/.f
: f2 = '/.40. 37f \n\n"
; . fl. f 2) ;
/* assignment statements for doubles. •/

dl = 23.00000000000001;
d2 = dl + 3.00000000000000; /* see result of this addition. */
/* write double results; compare output with that for float. */

printf ( "double: dl = '/.If; d2 = •/.40.371f\n" dl d2) . . ;
/* write double results AS INTEGERS; compare output with above. */

printf ( "\nThe following is INVALID OUTPUT, incorrect results. \n")
printf ( "double as int: dt = V.d; d2 = •/.40d\n" dl d2) , .
This program produces the following output;
char as char: cl - a; c2 » a; c3 " d

char as int cl - 97; c2 - 97; c3 " 100
:
ints: il - 23; 12 - 26; 13 - 123
float : fl - 23.000000; f2 - 26.0000000000000000000000000000000000000
double: dl " 23.000000; d2 = 26.0000000000000100000000000000000000000
The following is INVALID OUTPUT, incorrect results.

double as Int: dl > 3; d2 -
In addition to illustrating topics discussed above, this program shows

some new features of printf( ) and of some variable types. Essentially, the
program does some manipulations using each of the four simple types we've
seen so far, then it writes the result to the screen. Altogether, the program
defines 10 variables, three char, three int, and two double.
two float,
The first two char assignment statements show that you can assign a value
to a char variable in more than one way. by actually specifying the character
to be stored there or by assigning the ASCII value associated with the
character to the variable. In the first assignment, the system translates your
character (written within the single quotes) into its ASCII code, and stores this
code in binary form. You can assign 97 to c2 because characters are stored in a
byte capable of holding values between - 128 and
127, and 97 falls within this
range. (Note what happens if you add a larger number, as the program
suggests.)
The third assignment actually adds an integer to a character. While this
may seem odd, it is allowed in C because, internally, C actually represents char
variables as integers anyway. Essentially, you are adding 3 to a numerical
(ASCII) value. Since 100 is still a valid character, the system handles the result
in the same way as if you had simply assigned the value 100 to c3. This
assignment also illustrates the use of the addition operator (+). You'll learn
more about other operators later is this chapter.
The first call to printf( ) has four arguments, the string argument (con- ,
taining three placeholders) and three char variables, whose values will be
|
substituted for the placeholders. This call to printf( ) also illustrates how to get <
the function to write a char, by using the %c (for character) placeholder i

'
Notice that the values written for c2 and c3 are actual characters, rather
than numerical codes, despite the fact that we had assigned numerical values
to the variables. Using %c tells the function to translate the numerical code
into the actual character before writing it.
The second call to printf( ) seems to violate a rule we saw earlier that the —
placeholder type should match the types of the variables passed as the addi-
tional arguments to printf( ). That is, the %d does not match the char variables
whose values will be written. This is allowed for the same reason that adding
characters and integers was valid, because char variables are actually repre-
sented as integers internally.
The third integer assignment statement (i3 = i2 + cl) also illustrates that
int and char variables can be used together in an expression. The result can be
assigned to an integer variable.

The float assignments actually use values too small for the system to
handle completely as a float. That's why the output doesn't include the 1 in the
rightmost digit of fl.
To write a float, use the %f placeholder. The printf( ) that writes the floats
uses two different forms of the placeholder To write fl, the function uses the
system defaults for the number of decimal digits shown; for f2, we told the
system how to write the result. The first number (40) tells the the system the
98 Using QuickC
field width — how many places to allocate for the entire value. The second
format parameter specifies the number of decimal places to write. The period
between these two formatting parameters is not a decimal point; it's just the
character used to separate the two values.
^REMEMBER Formatting parameters must appear between the % and the

variable type indicator (in this case, f).
The assignments and output for the double variables had the same goal as
for the float values. This time, however, the 1 does show up in the output —
because a double can represent more numbers within its range than the single
precision float can. Notice the syntax for placeholders for double varia-
bles. %lf (for long float, which is essentially what a double The %lf is not
is).
available as a placeholder in all implementations of C. In some cases, you

would use %f to write either a float or a double.
The Draft Proposed ANSI Standarduses%f for float and %lf for double
variables. The system recognizes know the variable's type from its definition.
^fiEMEMBER Make sure that the variable type on the left side of an
assignment statement is able to store information of the type which the right
hand side evaluates.
The last call to printf( ) illustrates an error that will get you into all sorts of
trouble. Trying to substitute a floating point value for an integral placeholder
leads to unpredictable results, just about guaranteed to be wrong. Notice that
the system writes seemingly arbitrary values; it does not simply leave off the
fractional part of the number. The reason for this concerns the way the bits are
organized for integral and for floating point types.
The second integral placeholder also contains a format command. You
can specify the field width for integers as well as floating point types. Since
there are no decimal places, you need only one number to specify the format
for integers. Check the QuickC documentation for even more ways to specify
formats.
The last thing to notice is the use of the newline escape code ( \n) at the
beginning of the string argument. We've already seen the trick of using two
consecutive newlines to produce a blank line between entries. The introduc-
tory sentence in the next-to-last printf( ) shows that you can put the newlines
codes anywhere in your string argument.
;
Variants on Simple Types

In addition to simple types, C provides other types, which are variations on
char and int. These types are essentially requests for a different range of values
or for different amounts of memory to be allocated for storing a value.
Signed types, where numbers can be positive or negative, are standard in
most languages. C also lets you declare integers as unsigned, so the sign bit is
used as part of the number rather than as a sign indicator.
For example, unsigned char and unsigned int are requests to allow only
positive values and zero. This roughly doubles the size of the largest possible
positive char or int value by taking away negative values entirely. An unsigned
char can take on values from to 255. In QuickC, an unsigned int can take on
values between and 65535. There are also signed char and signed int types in
the proposed ANSI standard. These types do what the base types char and int
do already, in most implementations. There are no unsigned floating point
types.
The following program illustrates how to define variables of these new
types.
/• Program to illustrate how to define signed and unsigned variable types. */
nain
{
signed char scl
signed Int sil;
unsigned char ucl;
unsigned int uil:
prlntf ( "Just a filler llneAn");
Short and long are requests for versions of the int type for which different
amounts of storage may be allocated, depending on implementation. You can
also define variables of types unsigned short, unsigned long, signed short, and
signed long. The syntax for defining such variable types is the same as for the
other simple types. For example.
short sil:
long 111;
These two definitions allocate space for variables of type short (integer) and
long (integer). The amount of space allocated for these variants depends on the
implementation. For example, QuickC allocates the same amount of space to
.
100 Using QuickC
int and short (two bytes), but more to long (four bytes). Regarding storage
allocation, the only guarantees are.
1 The same amount of storage will be allocated to int and unsigned int
variables.
2. The storage for a short int <= the storage allocated for an int.
will be
3. The storage for a long will be >= the storage allocated for an int.
C also requires char variables to be stored in 1 byte, and insists that a

double variable be allocated at least as much space as a float. The following
program will show you how much space QuickC allocates for each simple type.
/* Program to show the amount of storage allocated for each of C's

simple types.
NDTE sizeofO is an operator that returns an integer
:
indicating the number of bytes of storage allocated to

for the base type of the variable passed as an argument.
*/
main ()
<
printf (
^CAUTION The types whose storage sizes are most likely to differ from
system to system include short int, int, and long int. Such differences may
affect the portability of your program.
Table 3-4 summarizes information about simple data types. Notice that
some of the variants on a type have the same range of values. For the floating
point types, note that both extremes have very large positive exponents. This
amounts to saying that float and double values range from very large negative
to very large positive numbers. Remember, a positive number with an expo-
nent such as —38 (e.g., 5e— 38) is a very tiny number, but still positive, and
therefore larger than a number such as — le25.
Constants
You may find the need for a specific value at some point in a program. This
may be the only place you need the value; or you may need it in lots of places,
but the value never changes. Such unchanging values are called constants.
Specific values —as opposed to variable names —
that are used in assignment
statements or other expressions are also called constants.
Depending on its value, a constant will be interpreted as being of a
particular type. For example, the letter q is a character constant, hello is a
Table 3-4. Summary of Simple Data Types
Type Range of Values In QuickC

char
102 Using QuickC
string constant, the number 8 is an integer constant, and the number 2.78 is a
floating point constant. As we'll see, C is quite flexible in how it lets you write
constants for the various types.
Integer Constants
C facilitates representation of integers in various ways. To write a decimal

integer, write the digits of the number. For example, 32254 is a decimal integer;
so —32254. Note that there are no commas
is in the number; commas are not
allowed in an integer.
C also makes it number bases other than
easy for you to write integers in
base 10. In particular, it is sometimes convenient to write a number in base 8
(octal form) or base 16 (hexadecimal form). Such alternate bases can be more
convenient because it is easier to translate a binary representation into one of
these bases than into base 10.
The following program writes the same number (32254) in three different
bases; 10, 8, and 16. We'll discuss these alternate number bases after we
analyze some of the program's new constructs.
/* Program to write a number in decimal, octal, and hexadecimal format. */
main ()
int il = 32254: /* initialize variable during definition */
/• Write the number 3 different ways.

Note that the same variable is substituted each time.
*/
printf ( "decimal '/.diXtoctal '/,o;\thexadecimal /ixNn" . il, il, il) ;
>
This program produces the following output. Each value represents the same
number (the decimal 32254).
decimal 32254; octal 76778; hexadecimal 7dfe
This program simply writes numbers. It uses the initialization during defini-
tion that we have already seen. It also introduces two new placeholders and
uses an escape code we haven't tried yet.
The %o placeholder tells the system to write the value substituted in octal
form. This means that the value stored in variable il is transformed before it is
written to the screen. Similarly, the %x specifies that the value is to be written
in base 16.
The \t escape code is a tab, and tells the system to move to the next
tabstop before continuing with the writing. Notice that there is no space
between \t and the following word. This is because everything after the t in \t
is interpreted as part of the string argument.

The decimal numbering system uses powers of 10 for its place values. For
example, the number 32254 consists of 4 ones, 5 tens, 2 hundreds, 2 thousands,
and 3 ten thousands. If you add (3 * 10000) + (2 * 1000) + (2 * 100) + (5 * 10) +
(4 * 1), you will get 32254. Each place value is ten times the power of the place
value to its right. Thus, the third column from the right (hundreds) is ten times
the second column from the right (tens).
The octal numbering system uses the same principle of increasing powers
going from right to left. However, in this case, powers of eight are used. Thus,
each place value is eight times the place value to its right. The octal representa-
tion for this number is 76776. 6 ones, 7 eights, 7 sixty-fours, 6 five hundred
twelves (512 = 64 * 8), and 7 four thousand ninety-sixes (4096 = 512 * 8). (With
names such as four thousand ninety-sixes, aren't you glad we use decimal
numbering?) Check this by computing (7 * 4096) + (6 * 512) + (7 * 64) + (7 * 8)
+ (6 * 1).
In base 16, the same principle applies, but this time the powers are based
on 16, so that each place value is 16 times the place value to its right. The
hexadecimal value for our number is 7dfe. This translates into, e ones, f
sixteens, d two hundred fifty-sixes (16 * 16), and 7 four thousand ninety-sixes
(256 * 16). If you don't know what these strange numbers d, e, f are, check — —
the next paragraph.
In base 10, you use 10 digits. through The next number is 10
9. — 1 ten
and ones. In base eight, there are eight digits. through 7. The next octal
number is 10. 1 eight and ones.Not surprisingly, you need 16 digits to count
in hexadecimal. There aren't enough digits to count in base 16. Therefore, the
first six letters of the alphabet —a through f — are used to represent the
"digits" 10 through 15 in hexadecimal. So, the hexadecimal digits are
through 9, a through f The next hexadecimal number is 10. 1 sixteen and
ones. Thus, the hexadecimal representation translates into. (7 * 4096) + (13 *
256) + (15* 16) + (14* 1).
104 Using QuickC
You will find hexadecimal and octal representations in many C programs.

The nice thing about hexadecimal representations is that every "digit" in base
16 corresponds to 4 bits in binary. This makes it easy to represent a binary
pattern in hexadecimal form. A 16-bit number will have 4 hexadecimal digits.
Similarly, every octal digit corresponds to 3 binary digits.

When you write an integer, the system has to know whether you are
writing it in decimal, octal, or hexadecimal. We've already seen that the
decimal representation is just the number itself If you are writing an octal
number, write O) immediately before the octal
(the digit 0, not the letter
representation of the number. To write 32254 in octal, write 076776. Notice
that the program does not write a zero before an octal number when it writes
the number. Presumably you know what kind of representation you've asked
for, so the system sees no need to preface the value in any way.
Finally, to represent a number as a hexadecimal constant, write Ox or OX

immediately before the hexadecimal representation. Ox7DFE. Case does not
matter when writing hexadecimal values. To write the negative form of this
number, write — Ox7DFE, not Ox— 7DFE.
^CAUTION Decimal integers are written as you would normally write

them. Octal integers start with the digit 0. Hexadecimal integers start with Ox
or OX. Signs must come first in any representation of a negative integer.
Constants of Character
Character constants are written within single quotes. For example, 'Q' is a char
constant. You can also specify a character constant in other ways, however.
For example, the letter 'Q' has ASCII code 8 ( 2 in octal). C lets you specify
1 1 1
a character by writing its ASCII code. Because of this, 'Q' and 81 are
equivalent ways of writing the value of the character constant. When discuss-
ing integers, we learned that integers could be written in bases other than base
ten. Thus, you could just as well write 0121 to represent this char constant.
(Remember, the indicates the number is an octal.)

Finally, you can write a character by specifying an octal escape code
( \121) corresponding to the character's ASCII value. Note the following about
this representation, a backslash starts the escape code; the use of octal, rather
than decimal, and the absence of the before the octal representation when
writing the character as an escape code.
;
The following program illustrates these different ways of writing a char-

acter value.
/• Program to illustrate four ways of writing a character value. */
main
{
char cl = 'A', c2 > 65. c3 = AlOl". c4 = 0101;
printf ( "%c\ty.c\012'/.c\t',4c\n". cl, c2, c3, c4)
This produces the following output.
The program writes the same character value, 'A', based on four different
initial representations. In all instances, the same numerical value is being
stored, but different representations are used.
Notice that the output is on two lines, split between the second and third
characters. The reason is that \012 immediately follows the second char
placeholder. This is another way of writing a newline command, using the
ASCII line feed character (decimal 10, octal 012).

The \012 to move to the next line is an escape code, like the \n, you used
previously. Such an octal escape code is the exception to the one character
limit on escape codes that was mentioned in a previous section.
String Constants
String constants consist of a sequence of characters. We've already seen

examples of string constants, such as the first argument to printf( ). String
constants begin and end with double quotes. For example,
"this is a string constant. \n"
is a string constant. On the other hand, the following is not a string constant
because it is not within double quotes.
'this is NOT a string constant. \n'
^REMEMBER String constants begin and end with double quotes.

106 Using QuickC
Float and Double Constants

C is remarkably flexible in how it lets you write float or double values. For
example, the following are all valid.
-.5 -5.0e-l -.05E+1 50e-2 1.
When writing constants, the only difference between a float and a double is in
the possible range of values. You may get an error if you try to assign a value to
a float that is too large for the allocated storage. Except for size, float and
double values are written in exactly the same way.
number can be written in most of the ways you would
Basically, a real
think. The number must have a number portion; this may be preceded by a
sign and may be followed by an exponent portion.
The number portion has one of the following forms.
&.54 Decimal point followed by 1 or more digits
54. One or more digits followed by a decimal point
54.54 One or more digits followed by a decimal point, followed by 1 or

more digits
The sign isand must be either— or+. Most older implementa-

optional,
tions will not let you use a unary + operator. The Draft Proposed ANSII
Standard includes a unary plus operator, which would make a number such as
+54.54 legal. The exponent portion is also optional; the exponent starts with e
or E, and is followed by an integer. The integer may be preceded by a sign, for
example, 7.5E+5.
There is number, as one or more digits,
one other way of writing a real
with no decimal point or portion following. In this case, the number must have
an exponent portion. For example, le5 is a valid float, but 10 is not. Ten is an
int, no matter what you intended. This is how the system distinguishes floats
from ints. Be careful when writing floats without fractional components. Write
1.0 rather than 1 because the latter is an int.
^REMEMBER Float and double constants can be written using three com-
ponents, an optional minus (— ) sign, a numerical part, and an exponent part.
The sign and exponent portion are optional (with one exception, as described
in the text). Parts must be included in the order listed.
Arithmetic Operators
C provides arithmetic operators you know.
+ - * /
Each of these works with integral as well as floating point types. Some of
the operators produce different resuhs, depending on the type on which the
operations are being carried out. In this section, we'll look at some of the
properties of the arithmetic operators, and will discuss them in terms of
operator precedence, or evaluation priority.
Operators with Floating

Point Types
When applied to floating point types, these operators do the obvious, add,
subtract, multiply, divide. The only quirk here is the danger of exceeding the
range for the variable type. If the resuh of an operation is a value outside the
floating point type's range, you will get an error message.
The result of operations with floating point variables and values should
be stored in a floating point variable. Thus, if you are adding two float values
and want to assign the results to another float, the system will assign a float
result to the variable. If you are assigning the results to a double, the system
will return a double.
Operators with Integer Types

Again, arithmetic operators do what you expect them to do — in most instan-
ces. A frequent problem in doing arithmetic with integers is overflow. If an
integer computation overflows, the system returns an incorrect value, but no
error message.
For example, the following program produces an incorrect result, but you
get no error message from the system.
/* program to illustrate integer overflow. /

main ()
{
int il = 32000;
il = il * 3;
printl ( "value after overflow: "/.dXn" , il) ;
108 Using QuickC
This program returns 30464, rather than the 96000 you would expect, because
96000 exceeds the largest integer value possible. There is no error message.
^CAUTION Avoid overflow when doing integer arithmetic.
When applied to integers, the operators will return integers. This means
that certain operators must work differently with integers than they do with
floating point types. For example, if you divide 7.0 by 2.0, the result is 3.5. On
the other hand, if you divide the integer 7 by the integer 2, the result cannot be
3.5 because 3.5 is not an integer The result will actually be 3, which is what you
get if you divide 7 by 2 and throw away the remainder. The C compiler decides
what kind of division (integer or floating point) it is doing, based on the types
of the variables or numbers involved.
In addition to the four common operators already mentioned, there is
another operator — % — available for int variables. This modulus operator

returns the remainder when dividing one integer by another. Thus, in the
previous example, where 7 / 2 returned 3, 7 % 2 would return 1, which is the
remainder when 7 is divided by 2.
Be careful when doing division or when using the modulo operator with
negative numbers. When doing division, the sign of the result depends on the
sign of the numbers involved in the division. Specifically, if both the first and
second values involved are positive or both are negative (that is, if the values
before and after the division operator ( / ) have the same sign), the result is a
positive number. If the numbers involved have different signs, the result is a
negative number. For example, 36.0 / 12.0 = 3.0, as does —36.0 — 12.0. On the
/
other hand, 36.0 / -12.0 = 3.0, as does -36.0 / 12.0.
For the modulus operator, the first of the numbers determines the sign. If
the first number (i.e., number from which the remainder will be computed)
the
is positive, the result is positive; if the first number is negative, the result is
negative. These are the rules for the modulus operator in QuickC; other
implementations may handle this operator differently.
Binary and Unary Operators

All of the preceding operators (+,—,*,/,%) are binary operators. This means
they take two values, and return a single value as their result. For example, 7 %
4 takes the two values 7 and 4, and returns the single value, 3.
There is an important unary operator that you already know about.
also
Earlier, —31000 was mentioned as a valid integer value. This is actually the
number 31000, modified by the unary operator, — known
, as arithmetic
negation. This is not the same as subtraction.
^REMEMBER Arithmetic negation, a unary operator, is not the same as

subtraction, a binary operator.
In most older implementations there is no unary plus operator. The Draft

Proposed ANSI Standard does provide for such an operator, however. This is
why you may find that a number such as +32254 is not valid, if you have an
older compiler. Because there is a unary minus operator, —32254 is valid in any
implementation. QuickC does include a unary plus operator.
Operator Precedence
The relative precedence of two operators tells you which of the operators to
apply first in an expression. For example, 3 + 5*4 could equal 32 or 23,
depending on the order in which the computations are carried out. In algebra,
we learned that the answer should be 23, because multiplication takes prece-
dence over addition. 5 * 4 is computed first. On the other hand, (3 + 5) * 4
does equal 32, because the parentheses tell you to add 3 and 5 before multiply-
ing the result by 4. The parentheses override the existing operator precedence
hierarchy.
The operators we have seen so far also fall into a precedence hierarchy,
summarized in Table 3-5. The topmost operators have the highest precedence
in the table.
Operators on the same level have the same precedence. In this case,
operators are evaluated in the order in which they are encountered, usually left
to right. In the case of the arithmetic binary operators, expressions are

evaluated left to right. This means the leftmost operator is evaluated first,
provided all operators are at the same level.

110 Using QuickC
Table 3-5. Precedence Hierarchy for Operators
Operator
; ;
unsigned char and unsigned short variables are automatically promoted

to unsigned int.
After any of the above conversions have been made, additional promo-
tions are made, as needed, up the following hierarchy (from lowest to high-
est), int to unsigned to long to float to double.
This means that the value of an int in an expression containing a float is
promoted to float; then the expression is evaluated and the result is of type
first
float.The following program contains some examples of type promotions.

The program also illustrates the importance of being careful when dealing
with mixed expressions.
/* Program to illustrate some of the rules and subtleties of

mixing variable types in expressions.
•/
int il = -12, i2 = 3, i3 = 4;
unsigned ul = 10, u2: /* define some unsigned integers. */
float fl, f2 = 3.0. f3 = 4.0;
u2 = ul + il; /* add an unsigned and an int */

/* a new output type is introduced, u for unsigned */
printf ( "unsigned result y,u\n" u2) .
/* float gets assigned result of operating on ints */

fl = 12/13; /* is division result int or float? */
printf ( "\nil / 13 (3 / 4) --> float, written as float: Xf \n" , fl);
fl = 12 / f3; /* is division result int or float? */

printf { "11 / 13 (3 / 4.0) --> float, written as float: %t\n" . fl);
fl = 13 / 12;
printf ( "\ni3 / 12 (4 / 3) --> float, written as float: '/.f \n" , f 1) ;
fl = 13 / f2;
printf ( "13 / f2 (4 / 3) --> float, written as float: '/.fXn", f 1) ;
/ write int result as float type BEWARE of doing such things */

:
printf ( "\nBAD: 4 / 3 as float: '/,f \n" 13 / 12); ,
/* write int result as int type this is OK */

:
printf ( "OK: 4 / 3 as int: '/,d\n" , 13 / 12);
/* write float result as int type BEWARE of doing such things */

:
printf ( "\nBAD: 4.0 / 3.0 as int: '/.d\n" f3 / f 2) .
/* write float result as float type this is OK */ :
printf ( "OK: 4.0 / 3.0 as float: '/,f \n" f3 / f 2) , ;
This program produces the following output.
unsigned result 65534
11 / 13 (3 / 4) --> float, written as float: 0.000000

11 / fS (3 / 4.0) --> float, written as float: 0.750000
13 / 12 (4 / 3) --> float, written as float: 1.000000

13 / f2 (4 / 3) --> float, written as float: 1.333333
112 Using QuickC
BAD: 4 / 3 as float: 0.000000

OK: 4 / 3 as int: 1
BAD: 4.0 / 3.0 as int: 21845

OK: 4.0 / 3.0 as float: 1.333333
The program again shows how to when defining them.

initiaUze variables
It also shows how to define an unsigned integer variable. The remaining points
concern the process of evaluating expressions and the transformations when

writing information.
One important point can be made using the last four printf( ) calls. The
information to be substituted for placeholders in those functions calls is
actually an expression, rather than a variable name. This means that the
expression is first evaluated, and its result is substituted for the placeholder.
The examples in the listing show what happens under good and bad condi-
tions.
Note that when the resuh of (—12 +10), an expression that we would
evaluate to —2, is stored in an unsigned int, the result is a very large positive
number. This is because the sign bit (the high order, or leftmost, bit) is 1 for
negative numbers, but is used to help represent magnitude for an unsigned int.
Be careful when working with different combinations of signed and unsigned

values.
The next few assignment/ output couples show what happens when your
expressions involve different types. Note that the result of evaluating the
integer expression, 3 / 4 (which yields by integer division) returns 0.00 as the
value assigned to the float. Remember, division has a higher precedence than
assignment. The system first carries out an integer division, producing in this
case; the (integer) result is then promoted in the process of being assigned to
the float variable. Thus, the relative precedence of the assignment and division
operators influenced the value assigned to the float.
The same thing happens in the second division. 4/3. This example also
shows that promotion in this case happens after the division is evaluated, not
before the expression is even touched.
The next two couples show that things work smoothly if either of the
elements in the division expression is a float. Type promotion occurs during
division here, rather than upon assignment.
The final couples illustrate how to write information correctly and incor-
rectly. Earlier, we found that the placeholder and the argument to be substi-
tuted had to be of the same type. Later we learned that char values were
exempt, to a certain extent, from this requirement. Here, we'll find out what
happens if you really violate this restriction.
The first of these function calls is expected to substitute the results of an

integer operation for a float placeholder. This substitution process is not an
operator, so type promotion doesn't apply. Instead, you get odd answers, such
as 0.000000. Similarly, trying to substitute the result of two float values into an
int placeholder also produces bizarre values, such as 21485.
^CAUTION Be very careful when computing expressions containing

mixed types, especially if the types include both an integral and a floating
point type. which operators are applied may make a difference.
The order in
When writing out the results of expressions containing mixed types, make sure
the resulting type and the type specified in your string argument to printf( )
match.
printf( ) Once More

You have learned most of the placeholders and a few of the formatting options
possible with printf(). Table 3-6 summarizes the types you can write with
printf( ).
Notice the %ld placeholder command. This says that the information
coming is a long and should be written as such. Similarly, %lf is intended for a
double in the Draft Proposed ANSI Standard (and, hence, also in QuickC),
Table 3
114 Using QuickC
but is not used in all implementations. Some systems make no distinction
between float and double in placeholder specifiers. They simply write the
variable passed as required by the variable's data type.
Summary
In this chapter, you've learned something about the makeup of a C pro-
gram, the structure of a program, of functions, and of statements (simple and
compound). Two functions that are particularly important in C — main( ) and
printfO — were also discussed. You've also seen how to put comments into
your program, and how to define variables of different types.
The chapter and their
also introduced you to C's simple data types
variants. In the process, you learned how to represent these types and how to
carry out certain operations using variables and constants.
In the next chapter, you'll find out more about the structure of C pro-
grams and about the files that make up such programs. You'll also learn ways
to make your files cleaner and easier to read.
4
Preprocessors and
Programs
I
;|i
In this chapter youll find out more about C programs. In the last chapter, we
saw a very simple program — made up of a few functions defined in a single ]
",
source file. In this chapter, we'll elaborate a bit on that barebones program i,
il
structure. You learn about the C preprocessor and the directives you can give
it. You'll also learn how to write macros to do certain things, and how to
declare library functions you want to use.
In Chapter 1 you learned about program source and header files, and in
Chapter 3 you learned that programs consist of functions. Now, we'll look
more closely at program files, and at how to use definitions in programs.
Program Structure
In addition to functions, a program can contain instructions on the contents of
a file, or it can contain variable definitions. You can hide many detailed
TI5
; ; ; ;
116 Using QuickC
definitions or environment-specific information in header files. You can also

more than just one function.
create variables that are accessible to
The following listing provides a more extensive example of a program's
structure and features. Below the listing is the output the program will
produce.
/* Program to illustrate instructions for header files, and

global definitions.
•/
#include "proginfo.h" /* contains various substitutions */
int line .number: /* a global variable definition •/
/* write a greeting to screen. Add to line counter for each line written. */
wrlte.message
<
line.number • line.number +1; /* increment line counter. •/
printf ( "•/.2d\ty,s\n5'.2d\t\t'/.s\n'/.2d\t\t y.s\n".
line .number. GREETING,
line.number + 1, CLOSING,
line.number 2, SENDER)
line .number line.number +2; /* increment line counter. */
>
/* display information about program. Add to line counter. */

wrlte.progran.info ()
<
line.number line.number +1; /» increment line counter. */
printf ( "%2d\ty.8 Version '/.B.lfNn",
line.number, PROGRAM, VERSION.HR)
>
mainO
/* no variable definitions this time. */
line.number "0; /* Initialize line counter */

write.program.inf o ; /* start calling other functions •/
wrlte.message ()
empty. line ()
write.program.info ();
wrlte.message ();
; ;; ; ; !
j
empty.line ()
lake.empty ()
empty.line C)
wrlte_program_info ();
wrlte.nessage ()
printf ( "\n\ny,2d lines writtenXn" . line.number)
>
/* write an empty (but numbered) line on screen. */

empty.line ()
{
line .number line.number + 1
prlntf ( "%2d\n" line.number)
.
/* write aji empty line with message to screen •/

fake.empty () |).j
line.number " line.number + 1 |

I
prlntl ( "X2d\t y,s\n" line.number. BLANK MESSAGE);

,
,
Ml
/* Output from Program •/
1 QuickC Version 1.0 I
2 Hello. |i
3 Sincerely. ) |
4 World e
5 t'
e QuickC Version 1.0

7 Hello,
8 Sincerely.
World
10
11 <this line intentionally left blank>
12
13 QuickC Version 1.0
14 Hello,
15 Sincerely,
18 World
16 lines written
118 Using QuickC
The next listing shows the header file read by the program.
I* PROGINFO.H : header file for QuickC listings. (6.20.87) */
/• one-line version */
•define PRQG.MESSAGE "QuickC version 1.0"
/* two components to program information •/

•define PROGRAM "QuickC" /• program being used •/
•define VERSION.NR 1.0 /
product version number */
"
•define GREETING "Hello,
•define CLOSING "Sincerely."
•define SENDER "World"
•define BLANK.MESSAGE "<this line Intentionally left blank>"
The program writes the same messages to the screen. In addition, it counts the
number of lines being written and gives you a total at the end.
The program above uses substitutions defined in the proginfo.h file.
When QuickC encounters a name defined in proginfo.h in the source file, it
replaces the identifier with the information associated with the name in
proginfo.h.
If you could read function write program_info () after it has been
compiled, it would look like the following listing:
write.program.lnfo
<
line.number = line.number + 1;
printf ( "'/,2d\t'/.s Version '/.B.lfXn", line.number, "QuickC", 1.0);
The difference between this and the original, pre-compiled version is that the
references to identifiers found in file proginfo.h have been replaced by their
string or numerical equivalents. For example, instead of PROGRAM, the
function now has "QuickC." Note, however, that you never actually see the
substituted text in your source code. Instead, QuickC places the substituted
value into the executable code. The substitutions are literal — exact replicas of
what you wrote in the header file are reproduced in the function. Later, you'll
learn how to make more complex substitutions that will actually perform a
task.
The version number (1.0) is being written in five columns, with one
decimal place. Although "1.0" is an exact substitution from proginfo.h, you
must specify the format if you want control over the output. This is because the
substituted value is treated like any other value of the type specified by the
placeholder. Thus, the identifier VERSION NR was replaced by the floating

point value 1.0; this value was then sent to the output processes in printf( ).
The variable line_number is intended for use by several functions in the

program. Each function must be able to change its value. The main( ) function
writes the current value of the variable at the end of the program.
A variable defined within a function is accessible only to that function,
unless the variable is defined globally — that is, outside of any particular
function. In the preceding program, line_number is an example of such an
external variable. For now, we'll just make any external definitions at the
beginning of the main source file, after any #include instructions, but before
any function definitions. Later, you'll learn how to position and define vari-
ables to make them accessible only to certain functions.
The C Preprocessor
The C preprocessor provides a means of modifying a C source file in various
ways before the actual compilation. This capability lets you extend the C
language to make it easier or more useful for particular purposes. The prepro-
cessor is conceptually distinct from the compiler, but it isn't necessarily a
separate program. The important distinction is that the compiler treats your
source as if you had actually typed the material the preprocessor substitutes for
the appropriate identifiers.
For example, the #define directive enables you to use mnemonic names
(such as FALSE or VERSION_NR) instead of the arbitrary numerical values
needed in your program. In such cases, the preprocessor replaces the identifi-
ers with the actual values you've associated with those names. After the
substitution, the compiler never knows that the source file ever contained
anything but the actual values.
In this section, you'll learn how to use some of the preprocessor com-
mands, or directives, available in QuickC. You'll see that the preprocessor
commands provide a sort of "mini-language," which lets you do some fairly
program before compilation.

extensive modification of your
C preprocessor commands, according to the Draft
Table 4- 1 contains the
Proposed ANSI Standard. Notice that you've already used two of the com-
mands in previous programs.
;
120 Using QuickC
Table 4-1. C Preprocessor Commands
#define #elif #else

#endif #error #if
#ifdef ffifndef ffinclude

#line #pragma #undef
One of the preprocessor's major functions is handling simple substitu-

tions, where the replacement is just a single value, such as a number or a string
constant. The identifiers replaced by the values are known as manifest con-
stants. The #define commands we have used so far have all been manifest
constants.
The preprocessor also handles macros. A
macro is a name that will be
replaced by other material, such as a statement or an expression. The replace-
ment text is called the macro body. Later, we'll look at such macros, in which
you can even use arguments to specify what substitutions are to be made. Such
macros are sometimes called function-like macros because they can be used
instead of C functions. We'll see how macros and functions differ when used in
a C program.
An example of a function-like macro will help make the discussion
clearer. Suppose you had the following in your program:
#deline SQUARE(x) (x) • (x) / sample function-like macro */
main ()
{
printf ( "5il\n", SqUARE(3.5))
}
The preprocessor substitutes (3.5) * (3.5) when the line calling printf( ) is
encountered. This is actually two replacements, (x) * (x) for SQUARE(x),

and (3.5) for (x).
When the preprocessor encounters a macro identifier, it replaces the
identifier with the macro body you have specified. For manifest constants, a
direct substitution is ail that is needed. For macros with arguments, the actual
information included as the argument must also be put into the text (as in the
Then the substitution text replaces the macro. This process of
listing above).
exchanging the macro call for the information it represents is known as macro
expansion.
General Preprocessor Rules

All preprocessor commands or directives begin with #. Most C compilers —
including QuickC and Microsoft C 5.0 — will let you start your preprocessor
command anywhere on the line, provided there is only blank space before the
#. Some older compilers make you start preprocessor commands in the first
column of a line. The Draft Proposed ANSI Standard lets you put a space
between the # and the command name. Both QuickC and C 5.0 will let you do
this. However, some older compilers will not allow this, so check your compiler
for the exact form a preprocessor command must take.
^REMEMBER All preprocessor commands begin with #. There may be

blank space (but nothing else) before the # on the line. The ANSI Standard
will also let you put space between the # and the command name.
After the directive name, the command includes the constant or macro
name and the replacement text for the macro or constant, each separated by
one or more blanks, as shown here:
ffdefine NAME "Quick C"
! t t
Directive IVlanifest Replacement
constant text
If your entire command won't fit on one line, or if you want to make the
command easier to read, you can tell the preprocessor that the command con-
tinues on the next line. To do this, end the current line with a \ (backslash). When
the preprocessor sees the backslash, it will keep reading the next line. For example:
»define SQUARE (x) \

(x) * (x) /» multiple line command — lor readability. •/
"
122 Using QuickC
#define TOO.LONG "I made this too long to fit on one preprocessor \
line .
main ()
<
printi ( "'/.f\n\n". SQUARE (2.5));
print! ('"/.aNn". TOO LONG);
}
/* Output from Program */
6.250000
I made this too long to fit on one preprocessor line.
This program writes the results of processing two definitions. One value is the
result of a simple substitution for a manifest constant (TOO LONG); the other is
the result of expanding a macro (SQUARE(x)).
The two #define commands each extend over two lines. Notice that the output
for the TOO LONG constant has a large blank space in it — because the original
command has blank space before the text on the second line. The preprocessor
takes the replacement text literally, blank space and all.
This also explains why preprocessor commands don't have semicolons at the
end. Any semicolon at the end of the string would show up inside the parentheses
for the printf( ) call, which is not acceptable to the compiler.
The use of space in the string replacement text for TOO LONG has had an
effect. By putting the space at the beginning of the second line, a gap was
introduced in the output text. On the other hand, the SQUARE(x) macro was
called with a space between the name and the argument list (in parentheses),
despite the fact that the original macro name had no such space. This is allowed by
most compilers — including QuickC, and in the Draft Proposed ANSI Standard —
because the system ignores any spaces between names and argument lists for
functions or macros.
In other words, the SQUARE (2.5) is processed just as if it had read
SQUARE(2.5). This means you can use spaces to help make your source file easier
to read. You may not leave spaces in the middle of a name, however.
Preprocessor Commands
There are many preprocessor commands, which serve various purposes. In
this section, you will find information about these commands, constants, and
macros.
The #include Command

This command tells the preprocessor to substitute the contents of the file
named at the spot in the source file where the #include command is found.
For example,
#include "proginfo.h"
causes the contents of the file proginfo.h to be written in the source file
location where the command was found. You could have achieved the same
thing by actually typing the contents of #proginfo.h directly into your source
file.
There are two forms of the #include command. In one case (used in the
examples so far), the file name is specified as a string constant, between double
quotes (e.g., "proginfo.h"). The system searches for the file in the current
directory. Some implementations may also search in other places, if the file is
not found in the current directory. This form of the command is most useful for
including header files you've created.
In the other form of the command, the file name is written, without
quotes, between < and >. For example,
#includs <proginlo.h>
tells the preprocessor to search for the file in a directory specified for the
implementation. Usually, this directory will be where the particular implemen-
tation keeps its header files. For example, QuickC looks for such header files in
a directorynamed \include. Again, if the file is not found in that directory, the
system may look in other places specified by the implementation. This form of
the #include command is primarily for including files created by the developers
of QuickC or whatever C compiler you're using.
^REMEMBER The two main ways to specify what file to include:
1. Within quote marks (" ") for files in the current directory.
2. Within angle brackets (< >) for files in a default "include file"
directory.
In QuickC, you can have#include commands inside include files. That is.
; .
124 Using QuickC
you can nest include files. Most implementations of C let you do this; however,
they differ in the number of nesting levels you can use. QuickC and Microsoft
C 5.0 let you nest up to 10 levels deep. Check your compiler to see how many
levels of nesting it allows.
The #define Command

Most of your preprocessor commands are likely to be definitions, using the
#define command, which we used in most of the header files discussed so far.
In this section we'll look more closely at this command.
Manifest Constants
A manifest constant is an identifier without arguments. The preprocessor

substitutes the replacement text exactly as written for the constant name at the
appropriate points in the program file. The substitution text begins right after
the name, although there must usually be at least one blank between the name
and replacement value. For example, the following are all valid preprocessor
definitions. (All but the macro FL_BYTES are manifest constants.)
/* Program to print out number oi bytes on a double sided DOS floppy disk.
Disk capacity Is computed using several preprocessor definitions.
Note use ot L at end of DQS.SECTOR.SIZE macro body

to indicate long.
Remove the L, then run the program. What happens? Why?
Hint: Display the Information in long hexadecimal format (Xlx)
»/
#deflne DQS.SECTOR.SIZE Ox200L /* size of a DOS sector. B12 bytes •/

Mdefine FL.SIDES 2L /• number of sides on a floppy disk •/
*deflne FL.TRACKS 40L /• number of tracks on a floppy disk */
#define FL.SEC.PER.TRACK 9L /» sectors per track on a floppy disk •/
split over two lines •/

/» Niimber of bytes on a floppy disk;
•define FL BYTES FL SIDES » FL.SEC.PER.TRACK » FL.TRACKS • \
DQS.SECTOR.SIZE
mainO
{
printf ( "declmal\t\t HldXn". FL.BYTES)
printf ( "octal\t\t 511o\n" FL.BYTES);
,
printf ( "hexadecimalVt XlxXn", FL.BYTES);

This program produces the following output:
decimal
;
126 Using QuickC
The preprocessor then sees four new substitutions to make, and makes
them, so that the first printf() call looks as follows when all the macro
expansion has been carried out:
printf ( "decimal\t\t '/.IdVn", 2L • 9L * 40L * 0x200L)
The resulting expression is evaluated before the resuh is substituted for

the %ld placeholder in the string argument for printf( ).
The preprocessor keeps expanding macros until all required substitutions
have been made. There are some limitations on possible substitutions, particu-
larly when it comes to macros with arguments. At that point, there will also be
implementation dependent limitations. Check your compiler documentation.

Why do you suppose the manifest constants in the previous listing were
defined as long? Here is the output for the same program, except that the
manifest constants are defined without the L in the replacement text, which
makes the system treat them as int.
decimal
As a long, the leftmost bit is 0, so the number is considered positive. By

specifying at least one of the manifest constants as a long, the computations
are done using 4 bytes, so that the correct result is written.
Notice that there no assignment operator between an identifier and the
is
replacment text. Replacing manifest constants and macro expansion are

substitution processes, not assignments. No storage is allocated for variables
named FL_SIDES, FL_TRACKS, etc.
The preprocessor will not complain if you do something such as the
following:
•define FL.SIDES - 2L
The expansion process will simply substitute = 2L instead of 2L. Depend-

ing on where the macro is being used, this may be acceptable to the compiler.
However, the chances are good that the results of this substitution will produce
information that may get you into trouble later.
REMEMBER Unless you have a very specific reason for including assign-
ment operators in preprocessor definitions, don't include them.
Similarly, you may inadvertently put a semicolon at the end of the
replacement text. Again, there may be times when you actually want to do this.
In most cases, however, this will resuh in a compiler error.
LI'
Macros with Parameters
The preprocessor command #define can be used with function-like macros to
make more complex substitutions. These macros have "slots" into which you
can pass specific values when you call the macro in your program. The slots are
known di^ formal parameters, and are essentially placeholders. When you call
the macro, you pass one argument for each formal parameter in the macro
definition. These arguments are also known as actual parameters.
For example, the following preprocessor commands define macros with
parameters:
•define BAD.SQUARE(x) x * x /• a definition that can lead to problems. */

•define SQUARE(x) (x) (x) /• a better definition for the square. */
•define SUM(a, b) (a) + (b) /• a macro for adding two values. */
Each of the "square" macros has one formal parameter, specified by the x
within the parentheses immediately following the macro name. Any formal
; ;
128 Using QuickC
parameters in a macro definition must be within the parentheses, and the

parentheses must come immediately after the name, with no intervening space.
If there were a space, the preprocessor would treat the formal parameter list as
macro body.
part of the
The SUM(a, b) macro has two formal parameters; a and b. Formal
parameters are separated from each other by commas. You can leave space
between formal parameters in your definition because the preprocessor will
interpret everything up to the right parenthesis as part of the formal parameter
list for the macro.
We've already discussed what happens when macros with parameters are
expanded, the macro body replaces the macro call; then all formal parameters
are replaced by the arguments, or actual parameters, passed when the macro
was called. Let's look at this process in the following listing, which will also
show why BAD SQUARE(x) is not the best way to compute the square of
two numbers.
/* Program to Illustrate macros with parameters. */
•define BAD.SqUARE(x) x * x /'a definition that can lead to problems. */

•define SQUARE(x) (x) * (x) /• a better definition for the square. •/
•define ADD(a, b) (a) + (b) /* a macro for adding two values. */
mainO
int good_int_sqr, bad.int_sqr. int.sum;
double good.dbl.sqr, bad_dbl_sqr. dbl.sun;
good.int_sqr SQUARE ( ADD (2. 3));

bad.int.sqr - BAD.SQUARE (ADD (2, 3));
int. SUB - ADD (2, 3):
/* macros can be used with Integral or floating point types,

good.dbl.sqr - SQUARE (2 + 3.0);
bad.dbl.sqr - BAD.SQUARE (2 + 3.0);
dbl.suin - ADD (2.0. 3.0);
printf ( "Good INT: '/.d\n" good.int.sqr)

, ;
printf ( "Bad INT: "/.dXn", bad.int.sqr);

printf { "INT Sum: y.d\n" int. sum)
.
printf ( "Good DOUBLE: %lf\n", good.dbl.sqr);

printf ( "Bad DOUBLE: Xlf \n" bad.dbl.sqr);
,
printf ( "DOUBLE Sum: 7.1f\n", dbl.sum)
/* Output from Program */
Good INT: 25
Bad INT: 11
INT Sum: 5
Good DOUBLE: 25.000000
Bad DOUBLE: 11.000000
DOUBLE Sum: 5.000000
This program computes a number of things and displays the results. Three
;
function-like macros are defined for the C preprocessor, and are used several
times in the main program. Two of the macros, SQUARE(x) and BAD
SQUARE(x), are supposed to do the same thing; however, they behave quite
differently, as shown by the output.
First, notice that the macros are being used with both int and double.
Preprocessor macros can be used with any type of information. The prepro-
cessor will make nonsensical substitutions, if you tell it to, although the
compiler would then complain. In the listing, the substitutions result in valid
expressions, so all is well syntactically. Although you can use the macros with
integral or floating point types, you still need to make certain that the right
types are returned and used in other statements, such as the printf( ) call.
what happens when the first assignment statement is carried out.

Let's see
The assignment goes through the following versions, as a result of macro
expansion:
good. int. sqr - SQUARE ( ADD (2, 3));

good.lnt.sqr - (ADD (2. 3)) * (ADD (2, 3)); /• expand SClUARE(x) •/
good.lnt.sqr • ((2) + (3)) * ((2) + (3)); /* expand ADD(a,b) */
good.lnt.sqr (5) * (5) /• add terms within ( ) •/
good.int.sqr - 25; /* multiply 2 sums */
The preprocessor expands the first macro it encounters, in this case

SQUARE(x). It replaces the macro call with the macro body, substituting the
actual argument, ADD (2, 3), wherever the formal parameter, x, is used in the
macro body. This macro expansion produces the second form of the state-
ment.
The preprocessor then expands the first macro it encounters, ADD(a,b),
again substituting arguments for formal parameters. The macro is found
macro expansion is carried out twice. After
twice, so the the all calls to
ADD(a,b) macro have been expanded, the statement involves only numerical
expressions and an assignment operator.
Notice all the parentheses appearing as the statement is processed. These
are introduced in the macro bodies, for both SQUARE(x) and ADD(a,b).
Let's look at the statement involving bad_int_sqr, to see why it pro-
duces a different result.
bad.int sqr - BAD SQUARE ADD (2, 3));

(
bad int sqr - ADD (2, 3) ADD (2. 3):
* /* expand BAD.sqUARE(x) */
bad.int.sqr - (2) + (3) • (2) + (3); /* expand ADD(a,b) */
bad.int.sqr • (2) + (6) + (3); /* multiply( !) two middle terms */
!
badllntlsqr • 11; /* add three terms resulting */

130 Using QuickC
The BAD SQUARE (x) macro does not put parentheses around the formal
parameter in the macro body. When argument is substituted in the
the
expansion, no parentheses are included in the expanded version of the state-
ment. The absence of parentheses becomes a factor after the ADD(a,b) macro
has also been expanded. Because multiplication has precedence over addition,
the two middle elements — (3)
and (2) —
are multiplied together first. The
parentheses in the SQUARE(x) macro override the precedence hierarchy,
forcing the two sides of the multiplication operator to be added first.
^ REMEMBER Macros with parameters can be tricky to write. It's generally

wise to use parentheses generously when writing macros with parameters.
After seeing how nested macros are expanded, you should have no trouble
working through the transformations for the statements involving variables of
type double.
Many commands that are already available to you in QuickC are actually
macros which are expanded when the preprocessor modifies your program.
Some of the "functions" available will actually be macros, which are expanded
by the preprocessor.
For our purposes here, there's no difference in how to use the command,
except in what happens when a macro or a function is called. When a function
is called in a program, the function variable definitions must be loaded into
memory (placed on the stack). This takes time. When a macro is expanded, the
instructions in the macro body are inserted directly into the source code. This
is done either before or during compilation. When compiled, the instructions
will be in the compiled program at all the required places; the program will not
need to load anything extra into memory.
So, you can sometimes make your program run faster by using macros
instead of functions. The trade-off for the speed increase is increased code size.
However, macros can be tricky, so it probably won't pay to place too great an
emphasis on macros over functions. Still, when used correctly, macros greatly
and portability of your code.
increase the readability
One danger in using macros with parameters is incorrect results coming
about because of operator precedence. The solution is to put parentheses
around each parameter in the macro body. It turns out that even this may not
be safe enough in certain cases. Often, the safest thing is to put parentheses
.
around the entire macro body. For example, ADD(a,b) would then be defined
as follows:
#deflne ADDCa.b) ((a) + (b)) /• note the extra ( and ) •/
Decision-making with
Preprocessor IVIacros
You'll probably encounter situations where you may want to make different
types of substitutions for the same constant or macro, depending on context.
For example, suppose you wanted a program to report the number of bytes on
a floppy disk — where the disk could be single- or double-sided, or high-
density. The following listing shows how to specify this information using
preprocessor commands.
#deline DOS.SECTOR.SIZE Ox200L / size of a DOS sector. 512 bytes */
#deline FL.SIDES 2L /» number of sides on a floppy disk */

/* */
#uiidef FL.SIDES
/* •/
#define FL.TRACKS 40L /• number of tracks on a floppy disk */
#deline QUAD.TRACKS 80L /* number of tracks on high density disk */

/•
#undef QUAD.TRACKS
*/
/* test whether a particular identifier has been defined.

if yes, carry out the subsequent actions;
if not, go to another point in the listing (one starting with #else)
*/
#ifdef FL.SIDES /* do following only if FL.SIDES defined */
Kdefine FL.SEC.PER.TRACK 9L /* sectors per track on a floppy disk »/
#dofine FL BYTES FL SIDES * FL.SEC.PER.TRACK * FL.TRACKS * \
DOS.SECTOR.SIZE
«elBe /* do following if FL.SIDES not defined •/
#ifdef QUAD.TRACKS /* do following if QUAD.TRACKS defined */
#define QUAD.SIDES 2L
•define FL SEC PER TRACK IBL
•define FL BYTES QUAD SIDES FL SEC PER TRACK * QUAD.TRACKS * \
DOS SECTOR SIZE
•else /* do if QUAD TRACKS not defined */
•define FL BYTES FL SEC PER TRACK * FL.TRACKS * DOS.SECTOR.SIZE
•endif /• end the QUAD.TRACKS if-else »/
•endil /• end the FL.SIDES if-else •/
mainO
{
printf ( "decimal\t\t '/,ld\n" FL.BYTES)
, ;
printf ( "octal\t\t "/.loXn", FL.BYTES);

printf ( "hexadecimal\t "/.IxVn" FL.BYTES);
,
>
132 Using QuickC
This program computes and displays the capacity, in bytes, of various types of
DOS floppy disks, single- or double-sided, or quad density. The preprocessor
commands determine what value to display. Currently, the macro
FL BYTES will evaluate to the capacity of a quad density disk used with
ATs. Let's see why.
The #undef Command

After defining FL
SIDES, the program removes the definition by "undefm-
ing" the constant. After #undef FL SIDES, it is as if the identifier
FL SIDES had not been used. The #undef command removes the definition
of the constant or macro name following the command.
Notice that #undef was not used for QUAD TRACKS because that
preprocessor command is inside a comment. So, by the time the preprocessor
gets to:
#lfdef FL.SIDES /* do following only if FL.SIDES defined */
we have three new definitions. DOS_SECTOR_SIZE, FL_TRACKS,

and QUAD—TRACKS.
The #ifdef and #else Commands

The #ifdef FL SI DES
command tells the reprocessor to check whether it has
a definition for the identifier FL SIDES. In this case, no such definition is in
effect (because of the #undef). If such a definition exists, the preprocessor
processes any commands encountered in the file until one of the following
commands is encountered:
*endif
#else
*elif
If FL SIDES has been defined, then two new definitions are made:
FL_TRACKS and FL_BYTES. If FL_SIDES has not been defined, then
neither of these definitions occurs. Instead, the preprocessor checks the com-
mand following the #else.
In the example, the next command is another #ifdef, this time asking
whether QUAD TRACKS has been defined. If so, all lines until the next
#endif, #else, or#elif are read. If the macro has not been defined, the prepro-
cessor skips all lines until the next #endif, #else, or #elif.
In the example, QUAD TRACKS has been defined, so the preproces-
sor adds three new definitions. Had QUAD — TRACKS not been defined, the
next decision point would have been the #else following the definition of
FL BYTES. If the preprocessor makes it that far, it means that neither
FL_SIDES nor QUAD_TRACKS has been defined. This means that the
disk being asked about is single-sided, and is not a high-density disk.
The next two lines tell the preprocessor that an "if statement has been
finished. The first #endif signals the end of the #ifdef QUAD TRACKS
portion, and the next #endif terminates the #ifdef FL SIDES test. Notice
that the inner "if was terminated first. and
Corresponding #ifdef (or #if)
#endif pairs behave like parentheses, and you should make sure you match
them as carefully as you match parentheses.
Although the macro FL BYTES is defined in three different places,
only one of them is processed during any one run of the program. The result to
which FL BYTES evaluates depends on the pattern of definitions in the
program. In the current form of the example, the first and third definitions are
ignored, since the preprocessor reads only the commands between #ifdef
QUAD_TRACKS and the next #else.
The #if and #endif Commands

Two additional commands deserve mention here. The #if command is similar
to #ifdef, but gives you greater leeway in what you would like to test. The text
following the #if command must evaluate to an integer. For example:
«il 5 > 10
«deflne ARBITRARY OL
«endlf
In this case, nothing is defined, because 5 > 10 is false. In C, a false result is
indicated by returning the integer 0. Any other numerical value returned is
assumed to represent true. Thus, the 5 > 10 evaluates to 0, which means that
the definition is not made.
134 Using QuickC
There is considerable flexibility in what follows the #if command. We've

already seen that the expression must return an integer value. Some implemen-
tations, including QuickC, will even let you put macros in the expression.
The #elif command is a combination of #else followed immediately by an

#if. You'll find it useful in the middle of a sequence of "if — else" loops.
Another command for conditional actions is #ifndef. This macro is
similar to #ifdef, except that #ifndef says to carry out the subsequent actions if
the name specified with the #ifndef command has not been defined.
Other Processor Commands

Some of the remaining preprocessor commands are more specialized, and will
be discussed here briefly.
The #error command you specify an error message that the prepro-
lets
cessor will display if it finds specific situations which it is testing. For example,
you may want to ask whether a particular macro has been defined, and display
an error message if it has not. You could do this in the following way:
#ilndef MY.MACRO
terror "ERROR: MY.MACRO is midef ined"
#endif
Ordinarily, the compiler counts lines as it processes your program, start-

ing at line The #line command lets you specify an arbitrary line number at
1 .
any point in your source file. The compiler treats the following lines as having
numbers continuing from the number you specified. For example:
mainO line 1 in source file */

{ line 2 in source file */
printf ( line 3 in source file */
#line 100 specify a new value for current line */
line 100 in source file */
line 101 in source file */
This capability is most useful when you are debugging your program, that
is, when you are tracing the execution of your program in order to locate errors
or incorrect results.
A #pragma is a preprocessor command that lets you tell the implementa-
tion to behave in certain ways. For example, it lets you tell the implementation
; ; ;
that you want to keep a trace of the program's execution if your implemen- —
tation supports such a capability, an action or a declaration specified with a
if
#pragma command is not supported by an implementation, the implementa-

tion should just ignore the pragma.
These commands may not be defined in your particular implementation.
QuickC, for example, does not support the #error command. See your com-
piler documentation for more about these preprocessor commands.
Library Functions
We've used the predefined printf( ) function in many of the programs so far.
This is only one of the many functions that have been precompiled, and put
into a Run-Time Function Library for use with QuickC.
The Run-Time Library is a compiled module accessible to your C pro-
grams. Functions defined in this library are available for use in your programs.
Such functions are handy because they save you the trouble of writing instruc-
tions to carry out the tasks the library functions are designed to do. Microsoft
has put a great deal of work into creating a useful and sound function library;
it's to your advantage to make use of the capabilities it provides.
In this section, we'll look at some of the functions available to you
through this library, and you'll learn how to tell the compiler you intend to use
one of these functions. See the documentation for your Run-Time Library for
information about the available functions and macros.
The following program shows how to use predefined functions to com-
pute the absolute value of an int or a long. (There is also an absolute value
function for floating point types, but that requires an additional header file.)
main ()
<
int pos.Btart " 357. neg.start • -200;
Int abs ;
long pos.long - 357L. neg.long = -BOOOO;

long labs () pos_long_reBult neg_long_re8ult
, .
printf ( "POS INT. Start '/.d\t\tAb8olute value

- - V.dXn"
pos.Btart, abs (pos.Btart));
printf ( "NEG INT. Start - '/.dXtXtAbsolute value - y.d\n"
neg_start. abs Cneg_start))
pos_long_result labs ( pos_long)

neg_longjresult = labs ( neg.long)
;
136 Using QuickC
printf ( "POS LONG. Start « '/.ld\t\tAb80lute value - y,ld\n"

pos_long, pos_long_result)
printl ( "NEG LONG. Start » '/.IdXtAbsolute value - XldVn".
neg.long, neg.long.result)
POS INT. Start - 367 Absolute value - 357

NEG INT. Start " -200 Absolute value - 200
POS LONG. Start • 357 Absolute value - 357
NEG LONG. Start » -50000 Absolute value - 50000
This program computes and displays the absolute value of several variables.
The abs( ) function returns the absolute value of an integer. If the number
is positive or zero, the function returns the number itself; if the number is
negative, the function returns the positive form of the number (that is, the
number without the minus operator). The labs( ) function operates similarly
for longs, and the fabs( ) function returns the absolute value of a floating point
variable or value.
There are two important concepts in the preceding program. First, the
program shows how to tell the compiler about the functions you want to use.
Second, the program shows how to use such functions.
Although the abs( ) and labs( ) functions have been predefined, the com-
piler has no way of knowing whether you are using the functions correctly in
your program. One thing the compiler needs to know is what kind of informa-
tion a particular function is going to return. To tell the compiler this, you
declare the function before it is used. The declaration for the labs( ) function is
long labsO :
This associates a particular identifier (in this case, labs) with a data type (in this
case, long). The double parentheses (after the name) indicate that labs() is a
function. Essentially, the function declaration tells the compiler that labs( ) is a
function that evaluates to, or returns, a value of type long. The declaration for
abs( ) is similar, except that the declaration specifies that the function returns
an int.
The program also shows two ways of using function calls in program
statements. With some restrictions, you can call a function anyplace you use a
value of the sort returned by the function. So, you can call abs() in an
argument to printf( ), because abs( ) returns an int, which is substituted for the
appropriate placeholder in the string argument to printf().
. —
You can also call a function on the right side of an assignment statement;
for example, when the result of computing labs() is assigned to pes long
result or to neg_long_resuit. Note here that you cannot put a function call
on the left side of an assignment statement.
A function declaration in C does not allocate any memory for the vari-
able, unlike a definition, which does allocate storage for a function or variable
of the specified type.

The general format for a function declaration is data type followed by
function name, including parentheses to indicate that it's a function.
^ REMEMBER The general syntax for a function declaration is
<.data type> ^function name>{ )
You may be wondering why we haven't declared printf( ), even though

we've used it in several programs. The reason is that printf( ) returns the
number of characters printed, which is an integer. If the compiler encounters a
function for which no declaration has appeared, the compiler assumes the
function returns an int. Function declarations for library functions that return
an int are therefore optional.
This is why declaring printf( ) is unnecessary. It also means that the

function declaration for abs( program above was actually unnecessary
) in the
because the compiler would have assumed that the function returned an
integer. You may, however, get warnings about this from the compiler
depending on the level of error reporting you have selected when you compile.
Let's look at one more example, to introduce some more library func-
tions. The following listing uses the library functions, getch( ), getche( ), and
rand( ), each of which return integers. The program also introduces a new
operator, the equality operator: ==, as well as providing a first look at a way
of making decisions in C.
/* Program to Illustrate use of library functions.

Program asks for a user ID, then writes a random integer between
and 100 or between and the maximum integer value,
depending on the user s input
'
•/
main ()
<
tdefine MY.ID 'w' /• user ID; just to show use of getchO */
#define RESTRICT 'r' /• restrict random range */
»define TDP.RAND.VALUE 100
, , ; . ;
138 Using QuickC
#define MAX.INT 32767 /» maximum integer in implementation. */
int char_read.
rand_resultl raiid_re8ult2;
int randO ,
/* function returns a random integer */
getchO /* read a character from keyboard; NO echo */
getcheO; /* read a character from keyboard; echo */
printf ( "Type in your one character ID. please. \nYour character: ");
char.read = getchO /* get user's id */
;
if ( char.read -- MY.ID)
{ /* beginning of a compound statement. */
printf ( "\nThanks.\n") ;
printf ( "Let's try the random number function. \n")

} /* end of compound statement. */
else /* if ID was not recognized */
<
printf ( "\nl don't recognize that ID, but\n");
printf ( "let's try the random number function anyway. \n");
}
printf "Please type\n\t\t%c\nto restrict range to

( .. 10.
\nYour selection: ", RESTRICT);
char.read » getcheO; /* get character, echo it. */
if ( char.read == RESTRICT)
{
printf "\nOK. Number will be between
( and y,d\n" .
TOP.RAND.VALUE) ;
rand.resultl = randO TOP.RAND.VALUE;

•/.
rand.result2 = randO TOP.RAND.VALUE;

'/.
}
else /+ if any random integer will do */
{
printf "\nOK. Number will be between
( and %d\n"
MAX.INT);
rand.resultl = randO ;
rand.result2 = randO ;
printf ( "Random result 1 = V.dNnRandom result 2 = '/,d\n" .
rand.resultl. rand.result2)
This program produces the following output, when w is entered in response to

both prompts, for personal ID, and to the question whether to restrict range.
Type in your one character ID. please.

Your character:
Thanks.
Let's try the random number function.
Please type
r
10.
OK. Number will be between and 32767

Random result 1 41
Random result 2 - 18467
This program has two major tasks: getting a single-character ID value

from the user, and computing two random integers. Upon reading the ID value
entered, the program displays one of two messages, depending on whether the
value is equal to the predefined MY ID. The program then computes and
returns two random integers —
either between and TOP RAND VALUE
( 100) or between and MAX INT, the maximum integer value defined in the
implementation (32767).
The function declarations for the three new functions all have the same
format. Functions were declared separately from the int variables in main( ) to
make the declarations easier to read.
Look carefully at the output from this program. There are two places
where the user is supposed to enter characters. But only one w shows up in the
output. Why? The program uses two functions to read the two characters:
getch( ) for the first (ID) character, and getche( ) for the second character. Of
these two functions, only getche( ) echoes the character it has read to the
screen. This w is displayed in the output, but the character read by getch( ) is
read but not displayed.

Notice that getch( ) and getche( ) return int values, even though we're
looking for character values. Recall that characters are essentially treated as
integers in C. Character arguments or returns will almost always be treated as
int.
The rand() function returns a pseudo-random integer. Pseudo-random

refers to the fact that the program will return the same sequence of "random"
numbers each time it is run. Thus, you will get the same random numbers each
time you run the program in a particular mode. If you asked for the restricted
range of random values, the program would return 67 for the second random
value. This is just the remainder after applying the modulus operator to the
18467 returned by rand() mode.
in non-restricted
The program has some other features worth mentioning. First, notice
that the preprocessor definitions occur inside the main( ) function. Preproces-
sor commands can appear anywhere in a file, although most programmers
place preprocessor commands at the start of a program.
The program introduces a new operator, ==, which evaluates to true (a
nonzero value in C) if the elements on either side of the operator have the same
value, and to false (0 in C) otherwise. The equality operator has lower
140 Using QuickC
precedence than the arithmetic operators we've seen so far, but higher prece-
dence than the assignment operator. (C returns the value if a result or test is
false; a nonzero value if the result is true.)
^CAUTION Do not confuse the equality operator (==) with the assign-
ment operator (—).
This program also includes the first compound statements we've seen in
actual programs. There are four of them: after each of the two if statements
and after each else.
Finally, the program shows how do different things depending on a

particular value or set of conditions. This construction:
a (some condition holds)

<
}"
else /* if the condition does not hold */
{
is the first C control construct we've seen. You'll find out more about it and
other constructs in Chapter 6.
The last point to mention about this program concerns the call to
printf( ), asking about the /^f^T^/Crselection. The string argument for this
function call actually is split over two lines. To indicate this to the compiler,
we've ended the first hne with a backslash ( we did when a preproces-
\), just as
sor definition did not fit on a single line. You need to do this if you split a single
stringargument over multiple lines; you need not use the backslash if you write
additional arguments on a second line.
The important thing to remember about using library functions is that
you need to declare the function, that is, associate the function name with a
particular type. The type should correspond to the type of value to which the
function evaluates. If you don't declare the function, the compiler will assume
the function returns an int. If you declare it as returning the wrong type, you
will get bizarre results. A library function should be declared at the start of
whatever function calls it the library function.
: ; ; , :
Macros That Look Like Functions

In addition to library functions, most implementations provide a large number
of predefined macros, many of which you can use just as if they were functions.
Just from their usage you would not be able to tell that a particular call was to a
preprocessor macro rather than to a true function.
The next program illustrates several such macros which are designed to
determine whether the character passed to the macro as an argument has
certain properties. For example, isxdigit( ) returns a (false) if the character is
not a hexadecimal digit — that is, if it is not among
0, 1,2,3,4,5,6,7,8,9
a, b, c, d, e, f
A, B, C, D, E, F
The function returns true if the character is such a digit. Here is the
program:
/• Program to illustrate the use of predefined '' library" macros.
Note the inclusion of the file CTYPE.H, which defines the macros used.
*/
#include <ctype.h>
»define TEST.STR "Hello, world. \0"
mainO'C
int how.long; /* will store length of TEST.STR */
char alnum_char = 'Q',
non_alnum_char = '*';
char hex.char = 'F',
non_hex_char = 'G';
int strlenO; /* actually, a true function */
how.long - strlen ( TEST.STR)

printf ( " Length of\n'/.s\nis '/.d chars\n\n", TEST.STR. how.long)
printf ( "'/,c is an alphanumeric so function returns '/,d\n"

,
alnum.char, isalnum C alnum.char))

printf ( "'/,c is NOT an alphanumeric, so function returns '/,d\n\n"
non.alnum.char, isalnum ( non.alnum.char))
; ,
142 Using QuickC
printf C "VtC is a hexadecimal digit, so function returns %d\n"
hex.char. isxdigit ( hex.char));

printf ( "'/,c is NOT a hexadecimal digit, so function returns '/,d\n"
non_hex_char, isxdigit ( non.hex.char))
The program produces the following output:
Length of
Hello, world,
is 13 chars
Q is an alphanumeric, so function returns 1

* is NOT an alphanumeric so function returns
,
F is a hexadecimal digit, so function returns 128

G is NOT a hexadecimal digit, so function returns
This program writes the results of testing various characters for certain
properties. The macros used in this program are defined in the header file,
ctype.h, which is found in the implementation's header file directory ( \include

for QuickC). Notice that you need not declare macros. Because the preproces-
sor just substitutes, the compiler needs to make sure only that the macro
expansion is syntactically correct. If the replacement expression has any
function calls in it, the same rules about declaration apply as for any other
function.
The isalnum( ) macro returns true if the character argument is a letter or a
digit, and returns false otherwise.
The function strlen( ) returns the number of characters in the string

argument passed to strlen( ). This is a genuine function. You need not declare
this particular function because the compiler assumes a function returns int if
no return type is declared.

You can use preprocessor macros as you would library or other functions.
You can put them wherever a value of the appropriate sort is supposed to be
returned. Look through your Run-Time Library Documentation to find out
what functions and macros are available. Also, take time to look at some of the
files with the .h extension in the directory \include.
Header and Other Include Files
The preprocessor can be a powerful programming tool making your programs

cleaner, faster, and easier to develop. By using preprocessor commands, you
can sometimes save time when the program is running —
because instructions
are already in the code, rather than having the overhead for a function call. By
creating macros to represent more complex expressions or arbitrary values,
you can make your programs more readable and easier to revise. By collecting
such definitions, either in one place in the program listing, or in a separate file,
you can make it easier to use different sets of definitions and macros.
Such include files are called header files, and are usually recognizable
because they have the file name extension, .h, as in proginfo.h. You need not
stick to this convention, but you will probably have an easier time keeping
track of your files if you get into the habit of using .h for files containing
macros and other preprocessor commands.
The use of header files is one step towards program modifiability, because
you can create very different versions of a program simply by using different
header files when compiling the same program. This is one technique for
making your programs more transportable, because specific values are found
in the macro definitions rather than in your original source code. When you
change the macro definition, you change the text that will be substituted
during macro expansion.
So far, we've spoken just about preprocessor commands in separate files.
However, you can also collect C functions in separate files, which can also
make it and revise programs. For example, suppose you have a
easier to read
program requiring numerous string manipulations. You might write some
functions to do this work for you. If you design them well, these functions may
also be useful for other programs.
To make it easy to use your string handling functions in other programs,
you might put them all in one file, then include that file in any program that
needs the string handling capabilities your functions provide. One approach is
to compile the source code for these functions into each new program. This is a
144 Using QuickC
Straightforward but slow process, since the compiler must process the func-
tions for each new program.
Another way of using these functions in other programs is to compile the
file containing the functions, and save the compiled version as a new library
file. Then declare the program needs, just as you've been
string functions your
doing with the library functions. When your program has compiled, you can
link in the library file(s) your program needs. Appendix B provides details
about how to do this.
The ability to create and compile library files independently of each other
is one of C's major advantages, especially because C makes it easy to do. One
consequence is the availability of pre-built function libraries for C pro-

grammers. There are dozens of library collections available, and there are
several books that develop such libraries, such as Kris Jamsa's The C Library
(Berkeley: Osborne/ McGraw-Hill, 1985). These libraries can provide useful
tools, and give you good examples of source codes for performing various
tasks in C. Reading source code is often a very effective way to get better at a
language, especially when you can modify the functions, to try different things
or to tailor the functions to your needs.
Summary
In this chapter, you've learned more about the way C programs are put
together.You were also introduced to the preprocessor and the kinds of things
you can do with it. Finally, we've examined some of the advantages of making
your programs modifiable and using separate files to keep distinct portions of
your program.
Along the way, you also learned about another operator, equality (==),
and about the if control construct. There were also two new printf( ) output
formats: %lo (long in octal format) and %lx (long in hexadecimal format).
Finally, you saw how to indicate that a constant value is to be treated as a long.
In the next chapter, we'll discuss how to enter and display information in
C programs. This will be helpful for building a useful collection of functions.
Reading arn
Writing in C
In this chapter, we'll look at some of the functions QuickC provides for Ij O
(input I output), that is, for getting information into and out of a program.
While not part of the C language, these input and output capabilities are
provided in libraries or predefined an implementation. For example, the
in
printf( ) function is built into the QuickC programming environment. The
documentation for your compiler's Run-Time Library has more about the
functions described in this chapter.
Input and output can get tricky in C, so we'll look only at some of the
ways to do I/O. Some of the 1/0 functions will have to wait until we've
covered certain data types and control constraints more thoroughly.
145
.
146 Using QuickC
Reading Characters
You've already seen two functions for reading characters, getch( ) and
getche(). Each of these returns an integer that represents the ASCII code of
the character read. The difference is that getche( ) echoes the character on your
screen, but getch( ) does not.
The getch( ) and getche( ) functions actually read their information from a
buffer (memory storage area), rather than directly from the keyboard. This
turns out to be handy for functions that might read "too much" information.
For example, you may have a function that is supposed to read characters
until it encounters a particular character (such as a '
— ') which is actually
intended for another function. Situations such as this can be tricky to handle in
most programming languages, since the function doesn't know it wasn't
supposed to read the information until it has read it.
C's solution takes advantage of the fact that information can be put into a
buffer as well as taken out. The ungetch( ) function lets you put exactly one
character back into this buffer. The buffer being modified is used to store
information for the console. This "device" is associated with the keyboard for
input and with the screen for output.
The following listing illustrates the use of the ungetch( ) function to put
information back into the buffer, thereby making the information usable by
another function.
#define NEW.VAL 'z' /* value to assign to ch variable, to "prove"

that ungetch really works.
*/
/• nake these definitions and declarations global

80 both lirst.tryO and second.tryO can access them.
*/
int ch;
int getchO , ungetchO;
main ()
{
printf ( "Press exactly one key. Do not press z.\n");
lirst.try ();
second. try ();
>
/• Read a character from the console buffer, using getchO.

Put the character back, using ungetchO,
then assign a new value to ch (a global change)
•/
flrst.try ()
. ; ;; ; ;
Reading and Writing in C 147
ch getchO ;
prlntl ( "after getchO, ch •- Xc\n", ch)

ungetch ( ch)
ch • NEW.VAL; /* to give ch a new value before next getchO
printf ( "after new asslganent, ch %c\n", ch)
/* Display contents of ch before reading console buffer;

read a character from the console buffer into ch;
then display contents of ch after rereading console buffer.
•/
eecond.try
{
printf ( "\n\n\n");
printf ( "before new getchO, ch -- XcXn", ch)
ch getch O :
printf ( "after getchO. ch ~

Xc\n", ch)
}
Press exactly one key. Do not press z.

after gatchO ch a "
after new assignment, ch
,
z •
before new getchO, ch • z

after getchC) ch a ,
-
This program reads some information, then puts the information back, then
reads it again. The variable (ch), into which information was read in this
program, is assigned a new value between the calls to getch( ). The program
displays the values stored at various points in the program.
Notice the global definition of the variable ch, and declarations of the
functions getch( and ungetch( ). These are used throughout the program, so
)
the global definition makes them accessible to all the functions.

The function first try( ) does the following:
1 Reads a character from the console buffer and stores it in the variable
ch. This removes the character from the console buffer.
2. Puts the value stored in ch back into the console buffer. This merely
puts a copy of the value into the console buffer; // does not remove the
value from ch.
3. Assigns a new value to ch, overwriting the value stored in ch before the
148 Using QuickC
assignment. After this, different character values are stored in ch and

in the console buffer.
Function second try() can get a character from the console buffer
because first try( ) has put one back. Had ungetch( ) not been called, the
program would wait for you to press a key for the getch( ) in function
second try( ).
Unlike getch( ) or getche( ), which take no arguments, ungetch( ) takes the

character you want to put back as its argument. You can call ungetch( ) only
once between reads, otherwise it will fail.
getcharO and fgetchar()

A stream is a sequence of characters or bytes depending on the kind of stream
under consideration. Certain characters in the stream serve particular func-
tions, such as indicating end-of-line, end-of-input, or end-of-file. We'll consid-
er only text streams, which are sequences of characters. Streams are generally
associated with files, including devices, such as keyboard or screen. For our
purposes, you can think of streams and files as essentially the same.
The getchar( ) routine reads a character from a predefined stream, the
standard input source, stdin. This file is opened (made accessible) for you
automatically when your C program starts running. Although stdin is usually
predefined as the keyboard, you can specify another source (such as a text or
data file) as stdin, using the DOS redirection facility. For now, we'll assume
that stdin is the keyboard.
In QuickC (and in most other implementations of C), getchar( ) is defined
as a preprocessor macro. To use getchar( ), you need to include the file in which
this macro is defined. This file is usually called stdio.h as in QuickC. So. to use
the macro, you need to give the instruction:
#include <stdio.h>
In your program notice that the instruction uses theO form of the#include
preprocessor command. This tells the compiler to look for the header file in
predefined locations, such as QuickC's \include directory. When you call
getchar( ) in your program, the preprocessor substitutes the macro body for
your call.
)
The getchar( ) macro returns an int representing the character read. If
there is an error, or if it has reached the end of input, getchar( ) returns a

predefined value, EOF, which is usually defined as (—1). There are library
functions that will tell you whether an EOF result
due to an from getchar( ) is
error or because the end-of-file has been reached. QuickC recognizes CTRL-Z
(which you get by typing the letter Z on the CTRL key at the same time) as the
end-of-file character. Other implementations may interpret other characters as
end-of-file.
Unlike getche( ), which returns control to the calling function as soon as it
can return a value, getchar( ) waits until you indicate you are done (usually by
pressing the RETURN key) before letting the program continue. Briefly, get or
ENTER char( ) reads its character, then ignores anything else until you press
Return or indicate end-of-file. (When characters don't echo until the RETURN
key is pressed the system is using buffered input.) For example, the following
program does not end until you press Return:
/* Program to Illustrate getcharO's tendency to keep waiting for input. */
Vlnclude <stdio.h> /• file In which getcharO is defined. •/

main ()
Int ch;
ch " getcharO; /* Read a character from stdln. */

prlntf ( "Xd ». ch);
Implementing getchar( ) as a macro makes it run more Macros

efficiently.
differ from functions, however, in the way things are actually read and in the
parameter checking that is possible. Sometimes you may need the flexibility of
a true function. The fgetchar( ) function is the function counterpart of get-
char( ). To use fgetchar( ) in the preceding program, you could declare the
function (although you don't have to because it returns an int); you do not need
to include stdio.h.
getc( ), ungetc( ) and fgetc(

Sometimes, you need to be able to read characters from specific files, rather
than from stdin. Character values read into a program using getchar( ) or
fgetchar( come from the same source, stdin. As stated, this is usually the
)
keyboard. The getc( ) macro does the same thing as getchar( ), but gets its input
) ;
150 Using QuickC
from the stream (that is, file) you specify as an argument. Until we discuss files,
we'll use getcharO or fgetchar() — instead of getc() and fgetc() — when we
need to read individual characters. To give you a feel for how getc( ) is used, the
following example illustrates the format of a getc( ) call using stdin as the
stream. (Remember, stdin is just another stream. It just happens to be the one
for which the system does the work of opening and closing.)
/* Program to illustrate use of getcO. */

#include <Btdio.h> /• file in which getcharO is defined. */
main
int ch;
ch • getch ( Btdin) ; /* Read a character from stdin. */

printf ( "%d ». ch)
The only difference between this and the preceding example is in the routine
used to get the character. In fact. getchar( ) is actually defined as getc(stdin) in

most implementations.
Again, fgetc( ) is the function equivalent of getc( ), and is available in
QuickC. Both fgetc( ) and getc( ) return either the character read or EOF.
The function ungetc( ) puts the character back into the stream you specify.
It takes two arguments: a char, and a stream name. To see how ungetc( )
works, make the following substitutions in the first listing appearing in this
chapter. Note the order of the arguments.
getc( stdin) for getch(
ungetc( ch, stdin) for ungetch( ch)
putcharO and fputchar(),

putc() and fputc()
It's important to keep inmind that both ungetch( ) and ungetc( ) put characters
back. This means that you must have read a character before trying to put one
back. Do not use these functions for output. Rather, these functions serve to
restore.
C provides several functions and macros for handling character output.

Each of the getxxx( ) input routines we saw in the previous two sections has an
output counterpart.
;
In most implementations, the macro putchar( ) and the function fputchar( )

are the output routines corresponding to getchar() and fgetchar( ), respec-
tively. Eachof these two output routines takes one argument, the character to
output. Both putchar( ) and fputchar( ) write the character argument to stdout,
usually defined as the screen. The routines return the character written or
EOF, if there is an error. The following listing illustrates the use of these two
routines:
#include <stdio.h>
main ()
<
Int chl » 07, ch2 - 100. teat.ch;
putchar ( chl);
fputchar ( chl)
teat.ch = putchar ( chl);
}
This program writes some characters to stdout. Each character is written using
either the putchar( ) macro or the fputchar( ) function.
The stdio.h header file is included because it contains the definition for
the putchar( ) macro. Although it's a macro, putchar( ) in this program is
indistinguishable in its use from the function fputchar( ).
Although both routines return an int, we make no use of this returned

value in either of the first two calls. Rather, the routines are called mainly for
the action they perform, not for the value they return. The program does store
the value returned by the third call, in the variable test — ch. The answer to the
question regarding the number of characters displayed hinges on what
happens in this third call, to putchar( ).
To assign a value to test ch, the expression on the right side of the
assignment operator is evaluated. To compute this value, putchar() is
expanded, and the replacement body is evaluated. The result is then assigned
to test During the evaluation process, however, the statement also writes
ch.
a character (the contents of ch2) to stdout. This means that three characters
are written, in succession: aad.
Although you can call these output routines with or without the returned
value, you'll find it useful to check the value returned, especially if you are
transferring information from one place to another (such as from the key-
board to a file or from a file to the screen). In such cases, you'll need to check
each value to be written to determine when you're done.
The putc( ) macro and the fputc( ) functions are available for character
;
152 Using QuickC
output to a file that you specify, just as getc( ) and fgetc( ) were for input from a
file. The and fputc( ) output routines each take two arguments: the
putc( )
character you want to write and the file to which you want to write that
character. As you may have guessed, you can use putc( ch, stdout) to accom-
plish the same thing as with putchar( ch). You can also use fputc( ch, stdout)
instead of fputchar( ch).
As with stdin, the stdout file is opened automatically for you at the start of
the program, and is closed when the program finishes. You are responsible for
opening and closing most other files used in your programs.
The putch(), getch(),

and getcheO Commands
The getch( ) function also has a corresponding output function, putch( ). This
function writes its character argument directly to the console (screen). The
function returns the character written, or EOF if not successful.
Think of the getche( ) function as a combination of getch( ) and putch( ).
The following listing illustrates this.
/• Program to Illustrate use of the complementary functions

getchO and putehO, to do the work of getcheO.
»/
main
<
newgetche ()
More About printf()
We've already discussed the printf( ) function, one of the workhorse output
routines for C. This function lets you write simple data types, as well as strings,
to the screen (actually, to stdin), and lets you specify the format this output is to
have. In this section, you'll find out more about how to control output with
printf( ).
Integral Types
The following codes are available in printf( ) to specify output of an integral
type:
c d i o u X X
When used to form a placeholder, each of these is preceded by a % in the string

argument. You've already used most of these codes in earlier examples.
The %i also specifies an int to be written. This format specifier is not
available in most older C implementations, but is included in the Draft
Proposed ANSI Standard.
The %u indicates an unsigned int. The two ways of specifying hexadeci-
mal output actually use different versions of the hexadecimal digits.
If you specify %x for your placeholder, your result will use the lowercase
digits (abcdef); %X tells printf( ) to use uppercase digits (ABCDEF).
Each of these format specifiers can be preceded by (lowercase L) or h to
I
indicate that the integral type is a long or short version, respectively. For
example:
• %ld specifies a long int
• %lx specifies a long int written in hexadecimal form
• %hd specifies a short int
• %hu specifies a short unsigned int

;
154 Using QuickC
Floating Point Types
So far, we've used %f and %lf to specify float and double variables, respec-
There are two other codes you can use to specify floating point output.
tively.
Each of these can be written with either lower- or uppercase characters:
e E g G
Specifying %e tells printf( ) to write the value in exponential form. For

example:
printl ( "5ie\n", 1234.587);
writes a value of 1.234587e+003. Had we used %E instead, the output would

also have used an uppercase E: 1.234587E+003. in general, the exponential
form writes the value with one digit to the left of the decimal point.
If you specify %g or %G, the function will use either the "regular" (%f) or
the exponential format, whichever is more compact, based on the value and
the precision you have specified. %G uses the uppercase E, if it writes your
result in exponential form.
You can use 1 with any of the floating point format specifiers to indicate a
double in precision value.
Fieid Width and Precision

We've seen several examples where the placeholder specification has included
digits before the format specifier. Two aspects of the output can be controlled
using these numbers. Let's look at a few examples:
/• Program to illustrate field width BpecifierB lor output •/
nain
<
int il - 32. i2 « 29999;
printf ( ":y.5d ;/'.2d\n". il. i2)

printl ( ":'/.108 :'/,3B\n", "hello", "hello");
}
/* output lor listing */

This program writes various values according to different field width

specifications. Sometimes the program observes the specifications, and some-
times it overrides them.
The first call to printf( ) requests an integer to be written in a five-column
field. The integer is only two digits, so the function leaves three blanks to the
left of the value. The second integer is to be written in only two columns, but
the number is five digits long, so printf( ) ignores the field width specification.
The same thing happens when we ask the function to write string con-
stants: printf( ) puts five blanks before the first "hello," because we've asked it
to write the constant in a ten-column field. As with numbers, printf( ) ignores

field if the string output requires more space. Field width
width specifications
specifies the minimum number of columns to use for the output. By default,
any padding is done to the left of the output.
You can also specify the precision (essentially the number of decimal
places) to be displayed for floating point types. Several examples are shown
below:
/* Program to Illustrate use oi precision specifiers for output. */
ma
<
d2. d2);
;
156 Using QuickC
value. Precision is handled in a manner similar to the default: trailing zeros

are added number has fewer decimal digits, and
if the the number's fractional
part is truncated if there are too many digits.
Notice the third placeholders. These indicate that you can specify preci-
sion without also specifying a field width. In that case, the function uses its
defaults for field width. The decimal point (.) is required, otherwise the
function will assume you are trying to specify the field width.
Flags for printf()
We've seen that printf() right-justifies by default. That is, the function pads
any output with blanks to the left of the value, if appropriate. What if you want
pad on the right? printf( ) has flags you can use
to left-justify or to do that. The
following example illustrates the most common flags:
/* Program to illustrate use ol flags lor controlling output. */
main ()
{
int il - 32, i2 - -29S99;
print! ( ":%Bd :il2d\n", il, i2)

printl ( "-.X-bd :'/.-2d\n". 11. 12);
print! ( "rX+Bd :y.+2d\n", il, 12);
printl ( ":X-+6d :%-+2d\n". il, 12);
printf ( ":y.lOs :%3s\n", "hello", "hello");
printl ( ":y,-108 :y,-3s\n", "hello", "hello");
printl ( ":y,+ 108 :y,+3s\n", "hello", "hello");
>
/* output lor listing */
32 -20009
:
29990
29999
29090
hello :hello
hello :hello
hello hello :
This program writes the same information four times, using different
flags. The first call to printf( ) does not use any and produces the same
flags,
output as in our earlier listing. The next call uses the — flag, which tells the
function to left-justify the output (as on the second output line). In this case,
printf( ) pads to the right of the value.

The third call uses the + flag, which tells the function to include a sign
when writing the number. Ordinarily, printf( ) includes a sign for negative
numbers only. The + flag changes this. Notice that the flag does not tell the
function to write only plus signs (as shown by the —29999).
The fourth call shows that you can use multiple flags in the same place-
holder. The two placeholders also show that the order of the flags does not
matter. These flags tell the function to left-justify and to include a sign.
The next three calls to printf( ) output string values. Only the flag to
left-justify is relevant, and printf( ) obeys it in the second line of string output.
The sign flag makes no sense with a string variable, so the function ignores it.
One other flag may come in handy at times. The # flag can be used with
octal (o), hexadecimal (x, X), or floating point values. When used with octal or
hexadecimal formats (that is, #o or #X), the flag tells printf( ) to include the
leading or OX when writing the value. When used with floating point
formats, the flag forces printf( ) to include a decimal point in the output.
If you are using all the formatting options in printf( ), you need to write
your placeholder specifications in the following order:
%\flags] [field width] [.precision] [format]
Flags, field width, and precision are all optional, but if you use them, they
must appear in the order given. The % and the format are required. If you are
specifying precision, you need to include the decimal point.
fprintfO
The printf( ) function writes its information to the standard output, stdout;
fprintf( ) function lets you specify the file to which it should write the informa-
tion. The only difference between these two functions is that fprintf( ) takes an
argument before the string argument. This argument is the file to which you
want to write. The following two statements have the same effect:
/* two ways of writing the same information to stdout.

il is a variable of type int.
*/
printf ( "Xd". il);
fprintf ( stdout, "%d". il);
The fprintf( ) function will become more interesting after we've covered files in
more detail.
158 Using QuickC
Values and Variables:

The Address Operator
When you pass a variable as an argument to a function, such as putchar( ch),
the variable does not lose its value or become undefined. This is because you
are not really passing the actual variable, but a copy of the variable's value. The
function is free to do what it needs with this value, without affecting the value
stored in the variable itself In effect, the function never really has access to the
actual variable, just to a copy of the value stored there.
What if you wani a function to change a variable? We've seen one way of
doing this: assigning the value returned by the function to the variable you
want to change. This has been successful as long as we've been reading one
piece of information at a time, as in our character input functions.
However, it can easily become too tedious to read all your information
one character at a time. Sometimes you will want to change several variables,
possibly of different types with one function. One way of making this possible
would be to give the function access to the variables themselves.
Because variables are associated with memory locations, or addresses,
you can pass the function addresses, and allow the function to make its
changes at those locations. Since the function would then be doing its work in
the actual memory location corresponding to the variable passed as an argu-
ment, any changes made would remain after the function finishes.
C provides an address operator & ( ) to make it easy to pass such informa-
tion to functions. The address operator returns the location of the variable on
which & operates, rather than returning the value stored at that location.
The next listing illustrates several points about the address operator, and
Table 5- 1 provides a way of representing how the memory for the variables in
the program might be laid out. In the illustration, the actual precision of the
values stored in the double variables -locations 4858, 4866, and 4874 — will
depend on the bit pattern, and will almost certainly differ from the six decimal
place precision written by default. Here is the listing:
/* Program to illustrate use of address operator. */
main
{
Int il - 23. 12 - 12345. 13 - 234;
double dl - 23.0. d2 - 12345., d3 - .234;
Reading and Writing In C 159
printf ( "11 address: Xd, va! Xd\n", til. 11);

prlntf ( "12 address: %d. va Xd\n", 412. 12);
printf ( "13 address: %d, va Xd\n". ftlS. 13);
prlntf ( "dl address: Xd, va Xlf\n". 4dl, dl)
printf ( "d2 address: Xd, va Xlf\n", td2, d2)
prlntf ( "d3 address: Xd, va! Xlf\n". td3. d3)
/• output for listing •/
11 address: 4866, value: 23

12 address: 48E4, value: 12346
13 address: 4862, value: 234
dl address: 4874, value: 23.000000
d2 address: 4866, value: 12346.000000
d3 address: 4868, value: 0.234000
This program writes information about the locations of six different variables
and about the values stored there. Three of the variables are integers, and three
are of type double. The calls to printf( ) illustrate the notation for the address
operator (& followed by the variable name).
Notice that the placeholders for addresses are integral values, even if the
variable located there is a floating point type. There is no such thing as a
fractional address. The distinction between the location and the value of a
variable is important, as we'll see in later chapters.
Let's look at the numbers displayed for the addresses. Notice that the
addresses of the int variables differ by 2 while the addresses of the double
Table 5-1. Memory Layout for Variables
Variable
Name
) ;
160 Using QuickC
variables differ by 8. Recall that C allocates 2 bytes to an int and 8 bytes to
double. For now, this program is intended to illustrate the use of the address
operator. Later, you'll see how to do "arithmetic" on address locations.
Incidentally, notice how d2 and d3 are initialized (with a trailing and a
leading decimal point, respectively). Both of these are valid floating point type
representations in C, as we noted in Chapter 3.
Because it takes one element and returns one element, & is a unary
operator, with the same precedence as the other unary operators we've seen so
far: sizeof( ),
— (arithmetic negation operator), and + (arithmetic plus sign).
scant (
The scanf( ) function is the input counterpart to printf( ). It can be a tricky
function to use, with many variations, so we'll introduce it now and explain
further as we go along. Consult your QuickC Run-Time Library reference
manual for more information.
The function scanf( ) reads data from stdin. The data must have your
specified format, and scanf( ) stores the data in locations that you specify. The
following line illustrates the structure of a scanf( ) call:
/* this line reads an Int, a char, and a double,
test.double, respectively —
and assigns these data to the variables test.lnt, test.char, and
by storing the Information at the
locations of the variable parameters.
*/
scanf ( "ftd '/,c Xlf" ttest.int, ttest.char, ttest.double)
Notice first that $canf( ) has a structure just like that of printf( ): a string
argument, followed by an additional argument for each placeholder in the
string argument. Notice also that each of the variable arguments is actually an
address. This is necessary for scanf( ), since it needs to put the data directly into
the variables, so the rest of your program can use the values $canf( ) read.
When scanf( ) is called with an argument, the program makes available

the memory corresponding to the address of the variable passed as the
argument. If scanf( ) were called, for example, in the program whose variables
are depicted in Figure 5-1, the calls would write the information directly into
whatever memory locations were passed in that particular call. For example,
scanf ("%d" , &il) would call the function with address 4856 (the location of
il), so the integer read would be stored in that location.
;
^ REMEMBER Except for the string argument, you must pass addresses as
parameters to scanf( ).
As with printf(argument can contain regular text, as well as

), the string
placeholders. However, scanf( ) is much pickier about what it does with the text
in your string argument, it's important to distinguish between whitespace
(blanks, tabs, and newHne characters) and non-whitespace characters. scanf( )
treats whitespace and non-whitespace characters differently. So, in effect, the
string argument to scanf( ) can have three different kinds of information:
placeholders, whitespace, and non-whitespace characters.
If scanf( ) sees a whitespace character in your string argument, it reads
(but doesn't store) any whitespace characters in your input up to the first
non-whitespace character. Thus, the following would be valid input for the
scanf( ) statement above, since scanf( ) would just ignore intervening blanks:
If scanf( ) sees a non-whitespace character, it reads a matching character

in your input. For example, the following statement would require input
different from our previous example:
/ Line to illustrate effects of non-whitespace characters

in string argument to scanfC). Note the comma.
*/
scanf ( "Xd.Xc Xlf" Stest.int . ttest_char, ttest.double)
For this statement, you'd have to enter something like:
If scanf( ) does not find the character it's looking for, the function terminates. If
scanf( ) does find the character, the function simply discards it and continues
processing your input.
^CAUTION Be careful if you put anything other than placeholders or

whitespace in your scanf( )You must make sure the non-whitespace
calls.
characters in the input match those in the string argument to scanf( ).
Non-whitespace characters in a string argument exist to tell scanf( ) what

c ; :
162 Using QuickC
to look for in your input, not to get those characters into your program. This is
handy if you have something hlce a database that has specific words at
particular places in a line. If all you really need are the data around these
words, you can get scanf( ) lo get just that information by including the words
at the appropriate places in your string argument — so scanf() will find and
skip over the words.

You can use whitespace to separate the individual items of information in
your input, but you cannot use other characters (such as commas) to separate
them unless you include those characters at the appropriate place in the string
argument. For example, the following scanf( ) call will fail with the input below
it because of the comma in the input:
/* this line reads an int. a char, and a double,

and aasigns these data to the variables test.int, test char, and
test.double, respectively ---by storing the information at the
locations of the variable parameters.
*/
scanf ( "Xd y,c Xlf" ttest.int, fetest.char, ttest.double)
/• the function will fail with the following input */

17, 35.6
This is because scanf( ) is expecting to see a number after reading the comma
that is the first char encountered after the int. Instead, the function sees
another character.
You can also specify field widths in your placeholders. These are inter-
preted as the maximum number of places to read for that variable. scanf( ) will
literally stop in midword or midnumber if you specify a field width smaller

than the value you expect it to read. Moreover, the function will continue
processing from the next character. The following listing illustrates this:
/» Program to illustrate use of field width specifications for input. *
main ()
{
Int il. 12. 13;
char cl;
13 - scanf ( "Xld Xc y.d" til. tcl, 412);

,
printf ( "11 - Xd; cl - y.c 12 - %d\n" 11, cl. 12);

; ,
printf ( "Xd arguments processedXn" 13) .
/• input to the listing */

123 c 46
/• output from the listing */
11 • 1; cl - 2; 12 - 3
3 arguments processed
This program reads three pieces of information and writes them out. It
also writes out the value returned by scanf( ).
The first placeholder in the string argument for scanf( ) says to read one
digit at most,and to store this in variable il. The function does this; then it
skips over any intervening whitespace (in this case, none) before reading the
next datum. This is a char, and scanf( ) treats the 2 as a character. After
assigning 2 to cl scanf( , ) continues processing the input. It starts reading right
after the last character it processed, and continues until it reaches a separator
(a blank). Because scanf( ) finds only 3, it assigns this value to the variable i3.
The other two inputs are ignored, since scanf() has read everything it's been
told to read.
The statement containing the call to scanf( ) also provides information
about the type of value returned by $canf( ). Whereas printf( ) returns the
number of characters printed, scanf( ) returns the number oi arguments pro-
cessed successfully. You can often use this value to check whether scanf( ) has
at least read the correctnumber of data.
As with printf( ), the number of additional arguments (after the string
argument) must equal the number of placeholders in the string argument.
There is one important exception to this rule, as we'll see below. You can use
the same formats with scanf( ) as with printf( ): %x, %u, %s, %lf, and so on.
^ CAUTION Be careful when reading character values. A whitespace char-

acter in your input is a character just like any other, and scanf( ) will read it and
store it in a character variable, even if you had intended something else.
naln ()
<
Int il;
char ci , c2, c3:
il - scanf ( "Xc'/,c'/,c" tcl, ftc2. 4c3)

, /• note absence of blank ;
prlntl ( "cl - y.c; c2 - '/.c c3 • '/,c\n", cl, c2. c3)

;
;
printl ( "Xd arguments processedVn" il); ,
/* input to the listing */

a b c
/* output from the listing */
cl - a; c2 c3 - ;
3 arguments processed
Think carefully about what will happen in the following program — in

particular, what scanf( ) does when it encounters whitespace.
164 Using QuickC
main
This program reads three integer values. It processes the first and assigns it to
il. The program reads the second integer, but discards it as instructed by the
asterisk (*) preceding the format specifier in the second placeholder. The
program then processes the third integer and stores it in i2.
Notice that only two integer arguments were passed to scanf( ), even
though there were three placeholders in the string argument. The instruction
to suppress tells scanf( ) not to count the placeholder containing the *. You can
also see this in the information concerning the number of arguments processed
(the two arguments passed in, rather than the three placeholders specified).
There's more to using scanf( ) than we've covered here. We'll raise other
issues in later chapters; we'll also talk about reading strings after we discuss
what a string variable is.
The scanf( ) reads its information from stdin. As you might have guessed,
based on our discussion of the getchar( )and getc( )routines, there is a version
of scanf( ) that reads from a specified file. This is the fscanf( ) function. Its
structure and use are just like those of scanf( ), except that its first argument is
the name of the file. Thus, the following two function calls will do the same
thing:
Bcanf ( "%<1". 11);

fscanl ( stdln, "Xd", 11):
Summary
In this chapter, we discussed some of the routines C provides for reading and
writing information. We've elaborated on the printf( ) function that's been so
useful throughout, and introduced scanf( ), the counterpart for input. In order
to discuss scanf( ), we also introduced another operator, the address operator
(&).
and macros for reading
In addition, you learned about several functions
and writing single characters. In most instances, both macros and functions
are available to do the same thing. As you program more in C, you'll develop a
feeling for when to use which routines.
We also found that most of the routines in this chapter had versions that
used the standard streams (stdin and stdout) as well as versions where you
could specify specific files — for example, fscanf( ) and printf( ).
We'll discuss routines for reading and writing strings later, because many
166 Using QuickC
of these routines require string variables (as opposed to constants). String

variables become quite involved, because they rely on pointers.
In the next chapter, we'll look not only at the control constructs C offers,
but also atsome additional operators than are handy in conjunction with these
control constructs. Once you've found out more about the control constructs,
we'll be able to start writing more complex functions and programs.
A
6
Controlling C^
In this chapter we will explore the constructs C provides for controlling the
flow of your program. These constructs let you specify what your functions
and program should do under various conditions. C includes control con-
structs for selection (taking conditional actions) and for iteration (repeating,
or looping actions). These constructs form the core of most C programs.
The behavior of both selection (if-else, switch) and iteration (while,
do-while, for) constructs depends on the resuhs of tests made somewhere in
the construct, usually at the start.
in a selection construct, a particular action may be taken //a condition
holds, or else a different action may be taken.
In an iterative construct, a particular action may be taken (possibly with
variations) while a condition holds. You will see examples of these constructs
in this chapter and throughout the rest of the book.
An important consideration when using control constructs concerns the
actions your function takes when a condition you've specified holds. Some-
167
168 Using QuickC
times, you'llwant the function to do exactly one thing if a condition is true; at

other times, you'll want it to do several things.
we made a distinction between simple and compound statements,
Earlier,
the former consisting of one action, the latter including any number of simple
or compound statements, placed between curly braces.
The C compiler treats a compound statement as if it were a big simple
statement. As you'll see, compound statements, or blocks, are important when
you use control constructs. Compound statements allow you to specify a
group of statements to be performed if a condition holds, or while a condition
holds.
Before discussing C's control constructs, let's look at some more opera-
tors that will be useful for formulating the conditions tested by the control
constructs.
Relational and Equality

Operators
The conditions and iterative constructs are tests that

that control selection
evaluate statements in order to produce a yes-no or true-false answer. There
are, of course, many ways of asking even something as simple as a yes-no
question, such as whether one value equals another, whether two values are
not equal, whether one value is greater than another, whether it is less than
another, and so on.
C provides operators for asking such questions. In this section, you'll
learn about two types of operators: relational and equality, both used in
asking questions for control constructs.
Relational Operators
ThQ relational operators establish the relative magnitude of two elements. For
example, 18 is less than 35; you might also say that 35 is greater than 18. In C,
you would write these statements as:
18 < 35 /• 18 is LESS THAN 35 */

35 > 18 /* 35 is GREATER THAN 18 */
Controlling C 169
Similarly, you might want to be less specific and say something like
24.9999 is less than or equal to 25 or, conversely, 25 is greater than or equal to

24.9999. In C, you would write these as follows:
24.9999 <« 25 /* 24.9999 is LESS THAN OR EQUAL TO 25 */

25 >- 24.9999 /• 25 is GREATER THAN OR EQUAL TO 24.9999 */
All four relational operators in C have the same precedence, which is
lower than that of the arithmetic operators, but higher than that of the
assignment operator. Because the arithmetic operators have higher precedence
than relational operators, an expression such as the following evaluates to
true:
6.5 < 6 + 1 /• reduces to 6.5 < 7. which is true */
Because the addition operator has higher precedence, "6 + 1" is evaluated first.
The result, 7, is then compared to the 6.5 on the left side of the less than
operator. The expression reads 6.5 < 7.
Equality Operators
We've already seen the equality operator, ==, in a previous chapter. The
negative counterpart to this operator is the inequality operator, \—. The
inequality operator lets you test whether two elements are not equal to each
other. For example, the following expression evaluates to true:
7 != 8 /* evaluates to true, since it is true that 7 does not equal 8 •/
because 7 does not equal 8.
Both the equality and inequality operators have the same precedence, and
their precedence immediately below that of the relational operators. This, of
is
course, also puts them below the arithmetic operators. For this reason, the
following expression evaluates to false:
3+7I-6+4 /* reduces to 10 != 10 •/
This is because the additions on either side of the inequality operator are done
1
170 Using QuickC
first, making both sides equal. Since both sides are equal, it is incorrect, or
false, to say that 10 does not equal 10. Logically, this is just a very complex way
of saying that 10 == 10. When creating your condition tests, try to keep the
expression as simple and straightforward as possible.
Logical Operators
When writing a function to accomplish a particular task, you'll often find you
need to test several statements at once. For example, a number is divisible by 6
if the number is divisible by 2 and divisible by 3. In other cases, you may be
satisfied if any of several tests comes out true. For example, a character is a
vowel if it's "a" or "e" or "i" or "o" or "u."
You'll also find cases where you need exactly one of several conditions to
be true. For example, someone filing an income tax return can be either single
or married, but not both, at least not without arousing great suspicions at the
IRS.
C provides logical operators for combining the results of multiple tests.
The compound expressions that are created with such operators can be
evaluated further, to a single true or false result.
Binary Logical Operators

Two of C's logical operators are binary, taking two elements and returning a
single value based on those two elements and the operator.
The logical and operator (&&) returns true if both of the elements it
connects are true. If either or both of these elements are false, the && operator
evaluates to false. For example:
(7 < 12) ftft (12 > 2.7) /* evaluates to true: true S4 true */
(7 > 12) kt (12 > 2.7) /* evaluates to false: false kk true */
(7 > 12) kk (12 > 23.7) /* evaluates to false: false kk false */
The logical or operator (I |) returns true if either of the two elements it
connects evaluate to true or if both elements are true. Thus, the only time 1
evaluates to false is if both elements it connects are false. For example:

Controlling C 171
(7 < 12) II (12 > 2.7) /* evaluates to true: true II true */

(7 > 12) II (12 > 2.7) /* evaluates to true: false II true */
(7 > 12) II (12 > 23.7) /* evaluates to false: false II false */
When your program evaluates expressions connected by binary logical

operators, it evaluates from left to right. The evaluation stops as soon as the
program knows the value that will be returned. For example, a program
evaluating:
(7 > 12) 44 (12 > 2.7) /* evaluates to false: FALSE 44 (true) */
could return false as soon as the first element -(7 > 12) — was evaluated.
Because this element is false, the entire expression must be false as the &&
operator requires all components to be true. Similarly, you can tell what the
following expression will return without evaluating the entire expression:
(7 < 12) II (12 > 2.7) /* evaluates to true: TRUE I I

(true) */
As soon as you see (7 < 12), which is true, you know the entire expression will
be true because it involves only an or operator.

These logical operators have low precedence: lower precedence
fairly
than the equality operators, but higher precedence than the assignment opera-
tor. The && operator has higher precedence than the II operator. The and
operator sometimes called logical multiplication, and the or operator logical
is
addition. Conveniently, the relative precedence of these two operators is the

same as that of the arithmetic multiplication and addition operators. Below,
there's a table bringing our operator hierarchy up to date. First, let's look at
one more operator, however.
Unary Negation Operator

We've already seen the arithmetic negation operator, which converts a number
into its opposite form (for example, positive to negative). C also has a logical
negation operator, which converts a true value into a false one and vice versa.
Recall that in C, false values are represented as zero, and true is any
nonzero value. So, the logical negation operator, !, converts any nonzero value
(true) to zero (false) or, conversely, any zero value (false) to 1 (true), as the
172 Using QuickC
following expressions illustrate:
!( 7 > 3)
Controlling C 173
Table 6-1. Precedence Hierarchy for Selected Operators
Operator
; ;
;
174 Using QuickC
listing, this is a simple statement. If the number is non-negative, the value of

val —read is assigned to the variable result.
If the condition is false (val read is negative), the else portion of the
control construct is carried out. In this case, the program prints a message that
the sign is being changed, and assigns —val read to result. To make sure that
both of these actions are carried out, the two actions are in a compound
statement, which the system processes as a single statement. (If the braces were
left out around the material for the else clause, the function would always
return —val read.Why?)
If you are used to programming in a language such as Pascal, note that
there is no THEN after the condition being tested, and that you need a
semicolon after the result = val read assignment. This is because a statement
comes after the if, and semicolons terminate simple statements in C.
Let's look at another example to illustrate some other points about the if
construct.
/* Program to determine whether an integer entered is

positive, negative, or zero.
Program Illustrates 11 construct.
/
main ()
Int val_read;
/• get value */
prlntl ( "Please enter an Integer: ");
scanf ( "Xd" tval.read)
,
/* classify val.read as positive, negative, or zero */

If ( val.read)
{
prlntf ( "Not zero ...\n");
if ( val.read < 0)
prlntf ( "Negatlve\n")
else
prlntf ( "PositlveVn")
}
else /* if val.read is false, ie -- */
prlntf ( "Number -- zero\n");
This program reads a number, then tells you whether the number is
positive, negative, or zero. The program illustrates a very compact way of

writing a condition, and also provides an example of one if construct within
; ;; ;
Controlling C 175
another. Placing a construct within another construct in this fashion is called

nesting.
The condition, if (val read), amounts to asking whether the value of
val read is nonzero. If so, the condition evaluates to true, and the program
carries out the actions in the compound statement.
One of these actions involves another if-else construct. This construct is
handled in the same way as the outer one. The condition this time is whether
val read is negative. If so, the program writes one thing, otherwise the
program writes that the value is positive.
Let's look at yet another example to illustrate a somewhat different, but
commonly used, form of the if-else construct.
/* Program to determine whether an integer entered is

positive, negative, or zero.
Program illustrates else--if construct.
»/
main
<
int val.read;
printf ( "Please enter an integer: ");

Bcanf ( "%d" Jtval_read) ,
if Ival.read) /• il val.read -- */
(
printl "Number
( = zero\n")
else if ( val.read < 0)
{
printl ( "Hot zero ...\n");
prints ( "NegativeXn")
}
else /* if val read is positive
<
printf ( "Hot zero ...\n");
printf ( "PositiveXn")
This program performs similarly to the preceding program, but in a

somewhat different manner. The previous listing first tested whether
val_read differed and continued from there. This program first
from zero,
tests whether val read equals zero, and continues from there.
Notice the test for the first if construct. Remember that !val_read is a
terse way of asking whether val read == because, in that case, !(val —read)
would evaluate to true. In this example, the expression is easy to evaluate, just
by looking at it. In other situations, testing the negation of an expression could
get. very involved. In that case, it's better to write the expression in the less
compact form (that is, using the equality operator explicitly).
; : ; .
176 Using QuickC
The program also illustrates a common logical construction:
if A then Z else if B then Y else if C then X
In this construction, the conditions are tested in order, from top to bottom. As
soon as the system finds one that is true, the actions associated with that
condition are carried out, and the rest of the clauses are bypassed. The
program then exits the if-else construct.
Notice that there are two if and two else statements. The first else
corresponds to the first if. If the first condition is not met, the program moves
to this else portion. The first statement along this path is another if construct.
The second else corresponds to this if. This second (and final) else catches any
states that had not been caught at previous conditions. The only path to this
last else is to fail the conditions associated with the two if statements.
Beware of the Missing else
Look at the following listing, and try to determine what the output will be
for an input of 0. What is the output for an input of 5?
/* Program to illustrate the importance of balancing or grouping

ifs and elses.
Program contains an else associated with the "wrong" il
*/
main C)
int val_read;
printl ( "Please enter an integer: ");

Ecanf ( "'/,d" tval.read)
.
il C val_read) /* i.e., if val.read !

= •/
if ( val.read < 0)
printf ( "NegativeVn")
else
printf ( "Number == zero\n")
This program reads an integer value, and responds differently, depending

on whether val read is positive, negative, or zero. The program's indentation
indicates the intended flow of control.
According to the indentation, the program's goal is to test whether
val read is nonzero. If this is true, the program should test whether val read —
is negative. If so, the program writes "Negative." If val —read is positive, the
; : ;
Controlling C 177
program is not supposed to do anything because no else construct was

included after this inner if. According to the indentation, the if portion of the
outer construct ends here. If the original test was false (val read was zero),
the program was intended to write "Number == zero."
Unfortunately, the compiler sees this construct somewhat differently. It
matches an else with the nearest if that does not have an else associated with it.
In practice, this is the innermost if without an else. In this case, the inner if has
no else portion. Therefore, the compiler associates the else with this if. The
result is that the program writes "Number == zero" when val read has the
value 5. Because the else is associated with the inner if, there is no alternative
action for the outer if (that is, if (val read)). This means the program does
nothing when val read has the value 0.
There are two ways around this difficulty. First, you can include an inner
else that explicitly tells the program to do nothing. The next listing illustrates
this.
/* Fix for program with the unbalanced if and else.

This program adds a "dummy," or null, else to match the inner if.
*/
main ()
<
int val_read:
printf ( "Please enter an integer; ")

scanf ( "%d" fcval_read)
,
if ( val_read)
if ( val.read < 0)
printf ( "NegativeXn")
else /* to close off the inner if */
/* do nothing */
;
else /* if (val.read, i.e., val.read

printf ( "Number zero\n"); "
The semicolon with nothing preceding it is a null statement which tells the
compiler to do nothing at that point. An else containing a null statement

provides a matching else for the inner if.
The second way of dealing with this problem is to use braces to group the
statements the way you want, as in the following listing.
/* Another fix for the program with unbalanced ifs and elses.
This program uses braces to enclose the inner if
•/
main
int val.read:
printf ( "Please enter an integer: "):

; ;
178 Using QuickC
scanf ( '"/.d". tval_read) ;
it ( val.read)
i /* put inner if into compound statement */
il val.read < 0)
(
printf ( "NegativeXn")
} 7* end out if portion. */
else /* it !val_read. i.e. val_read == */
printf ( "Number == zero\n")
In this version, the braces tell the compiler that anything within the braces
is to be grouped together, andfrom the following material. In
is to be separate
this case, the (implicit) effect is to have the compiler do nothing (as originally
intended) if val read was positive (condition for the inner if was false). This
technique is the preferred method.
^CAUTI ON Beware of leaving "dangling" if statements when you have else

clauses following. You and the compiler may disagree on how to match else
to if.
The switch Statement

So far, we've used fairly simple conditions to control a function's actions. In
particular, we've only used conditions with a single test, and have avoided
compound tests, such as A or B or C or D.
You can use complex expressions when testing for the if statement.
Sometimes these tests can get lengthy and difficult to follow, however. For
example, suppose you wanted to determine whether a particular character was
a vowel. You might need an expression with 10 individual tests: 'a,"e,' 'O,' . . .
'U.' In this section, you'll learn about the switch statement, a selection con-
struct useful when you want to test whether any of several constant values is
found.
For example, suppose you want to read a character and determine
whether it is a digit or whitespace. The following listing shows how to use the
switch construct to make such a decision and how to act accordingly:
/* Program to illustrate use of switch construct to determine whether

a character is a digit, whitespace, or neither.
*/
main ()
{
char char_read;
: : ; ; ;
Controlling C 179
prlntf ( "Please enter a character:

scanf ( '"/.c". ftchar.read) ;
switch ( char_read)
{
case
case
case
case
case
case
case
case
case
case
print! ( "Digit\n");
break; /* force exit from switch */
case ' '
case '\t'
case '\n'
printf ( "WhitespaceXn")
break: /* force exit from switch */
default : /* if neither digit nor whitespace */
printf ( "NeitherNn")
break; /* force exit from switch */
}
printf { "Done\n")
This program reads a character, then tells you whether the character is a digit,
a whitespace character (blank, tab, or newline), or neither type of character.
The program uses the switch construct to decide what response to give.
The switch construct begins with the keyword switch, followed by an
expression in parentheses. This expression must evaluate to an integer in most
implementations. QuickC and Microsoft C 5.0 allow the expression to evalu-
ate to any integral type. The result, however, is converted to an actual int. You
will get a compiler warning if the expression has evaluated to a long. The main
body of the switch construct is contained in a compound statement, which

consists of two types of components: labels (for example, case '0':) and
*
statements (for example, printf ("Whitespace \" ').
Each label represents a possible value for the expression at the top of the
switch statement. Most labels begin with the case keyword. This is followed by
a value and a colon. In the preceding listing, the values are characters (treated
as integers internally). Notice that each value must get its own label. This
means you can't have a label such as case '0,' '1,' '2':. No two labels can
represent the same value. This means you can't have case '0': in two different
places in the switch.

The default keyword represents the case in which none of the other labels
applied. In our example, this label captures any characters that are neither
digitsnor whitespace. You need not include a default label in your switch
statement. If you do, you can have at most one such label.
180 Using QuickC
When the program encounters a switch construct, the program evaluates

the expression, then searches through the labels in sequence, until it finds the
case that corresponds to the current value of the expression. If there are no
matches, the program uses the default label, if present.
The program starts executing from the first statement it finds after the
matching label. For example, for an input of '\t' (a tab key), theprogram
above would start executing at the statement printf ( "Whitespace \n"). The
process continues until it encounters a break statement or until it reaches the
end of the switch construct. The break command causes the program to exit
from the switch construct immediately. Thus, after printing "Whitespace," the
program from the switch, and continues executing from the instruction
exits
right after the end of the switch body. In our case, the program displays Done
after exiting from the switch.
If there is no break after the call to printf( ), the program keeps executing
any statements it encounters until if finds a break elsewhere or until the end of
the switch construct. For example, if you removed the first break (after the
instruction to write "Digit"), and then entered '8' when running the program,
the following output would result:
Digit
Whitespace
Done
Clearly, it's important to include break statements in constructs such as the

switch.
If the program finds no case label that matches the current value of the
expression at the top of the switch construct, the program starts executing
from the statement immediately after the default label. If the program finds no
match and there is no default label, the program simply "drops through" the
switch construct, doing nothing.
Notice the break statement even after the default label, which ends the
switch construct in our example. It's good practice to put such a break
statement in, even at the end because you may add other labels after the default
at some later point.
You can nest switch constructs. The following listing provides such an
example.
: ; ; : ; ; ;
Controlling C 181
/* Program to illustrate nested switch constructs •/
main ()
{
char char.read;
prlntf ( "Please enter a character: ")

scanf ( "Xc". tchar.read)
switch ( char.read)
{
case '0'
case '1
case '2
case '3
case '4
case '5
case '6
case '7
case '8
case
printl ( "DigitVn")
/* this will distinguish even from odd digits •/
switch ( char.read)
{
case '0'
case '2'
case '4'
case '6'
case '8'
print! ( "Even\n");
break;
default
printf ( "Odd\n");
break;
}
break
default :
prlntf ( "HeitherVn");
break
'
case
case '\t':
case '\n'
printf ( "Whitespace\n")
break
This program prints a message depending on whether the character input is a

digit, whitespace, or neither. If the input is a digit, the program's response
depends on whether or not it is an even digit. Notice that the same expression
can (but need not) be used to control both switch statements. The same values
are apparently repeated in two case labels. This does not contradict the earlier
restriction that any value could appear only once in a switch construct,
because the second occurrence is inside the inner switch. In a sense, when the
program is in the inner switch it doesn't really know that the outer one exists.
182 Using QuickC
Finally, notice the use of the default label, instead of five labels for each of
the odd digits. This works here, because any character that leads to the inner
switch construct can only be an even or an odd digit.
^REMEMBER The expression at the top of a switch statement must evalu-

ate to an integral type in QuickC (and to an integer in most other implementa-
tions). No case label can be repeated and each case label can apply to only one
value.
More Operators
C provides several operators that make common tasks easy, but are absent
from most other languages. The operators are used very frequently in C's
control constructs (and elsewhere), so we'll look at them briefly here.
Compound Assignment Operators

If youVe done any programming, it is fairly certain that you have written
statements in this form:
my.int = my.int + another.int;
This statement accomplishes the task of adding the value of another int to
the value already stored in my int.
To accomplish this, you have to do a lot of typing, and the program has to
do some unnecessary computing. The program actually evaluates my int
twice, once for the expression to the right of the assignment operator and the
second time when storing the result in my int.
C provides compound assignment operators to make such statements
easieron you and on the program. They are called compound operators
because they combine an assignment and an arithmetic operator. For example,
you can write the preceding statement as follows in C:
my_int += another_int;
; ; —
Controlling C 183
This accomplishes exactly the same thing as the lengthier assignment

statement, but can be evaluated more efficiently by the program. Essentially,
the compiler is add the value of another_int directly to the value stored
told to
in my int. This saves one evaluation of my int, and it's easier to type.
There is a compound assignment operator corresponding to each of the
five arithmetic operators:
/=
%=
The %= operator can only be used with integral types, as was the case for
the simple modulus (%) operator. (You will soon learn about other compound
assignment operators that use non-arithmetic operators.) Let's look at some
more examples.
/* assume my_int has the value 37 */

my.int /= 5;
/* my_int now has the value 7; why? */
my_int '/,= 7
/* my_iiit now has the value +/
The first of these assignments stores the result of dividing the integer
variable my int by 5, using integer division. Remember, for integers, the
result of a division operation is the quotient with the remainder discarded: 5
goes into 37 seven times, and the remainder of 2 is discarded. After this
assignment, my int has the value 7. The modulus operator returns the
remainder upon dividing 7 by 7. This result is 0.
The statements in the previous listing produce exactly the same results as
the following versions:
/* assume my.int has the value 37

my.int = my.int / 5
my_int = my.int 7; */,
The only difference is that these versions are less efficient.

;
184 Using QuickC
Compound assignments store values in a location, just as simple assign-

ment does. Therefore, you must have a variable (you can't have a constant) on
the left side of a compound assignment operator. The compound assignment
operators all have the same precedence level, which is the same as that of the
simple assignment operator.
Increment and Decrement Operators

There is another type of variable change that's common in programs: chang-
ing the value of a variable by 1. For example, many loops use some sort of
counter whose value is increased or decreased by 1 each time through the loop.
C provides operators to make this easy to do.
C provides two forms of the increment operator (++) and two forms of
the decrement operator ( ). The two forms differ in an important way. The
operators are useful in loops, and make it possible to control looping condi-
tions compactly. Let's look at an example.
/* Program to illustrate use of increment operator, and

to show different effects of prefix and postfix forms of operator.
*/
main
{
int result, test = 0;
/* PREFIX increment: increment then use »/

if result = ++test) == 1)
( (
printf ( "result =
y,d\n", result);
/• else do nothing */
printf ( "after ++test value of test == '/,d\n". test);
,
test * 0; /* reinitialize test to /

/* POSTFIX increment: use then increment */
if ( ( result - te8t++) -- 1)
printf ( "result - '/,d\n" . result);
else /• if test is still zero at assignment time */
printf ( "nothing to do. so test must still =" 0\n")
printf ( "after test++, value of test '/,d\n" test); = ,
>
/* output from listing */
result 1"
after ++te8t, value of test -- 1
nothing to do, so test nust still "
after test++, value of test •" 1
Depending on the value of test, which is assigned to result, the program

writes the value of result or a message saying there was nothing to compute.
The program also displays the value stored in test after its use (and after
incrementing): in the first case, result == 1 , and in the second, result == 0.
The only difference in the test condition is -|-+test versus test++.
.
Controlling C 185
Let's look carefully at the test condition for the if construct. Ultimately,
expression evaluates as true or The program will assign whatever value is
false.
stored in test to the variable result. After this assignment is made, the program
checks whether the value stored in result equals The parentheses around the 1 .
assignment statement ensure that this is the order in which things happen. If
there were no parentheses, the equality operator would be applied first,
because it has higher precedence than assignment.

The program's actions hinge on the value of test at assignment time. This
value, in turn, depends on which version of the increment operator is used.
In the first case, ++test, the increment operator is applied first — before
using test in the assignment statement. Thus, the value of test is incremented
by I (from 0), and this result is assigned to the variable result. Consequently,
the equality test evaluates to true, since 1 == 1.
In the case of test++, the value of test is first used in the assignment, then
the value of test is incremented to 1 . This means that a is stored in result. The
equality test evaluates to false in this case, since != 1
The main purpose of the conditions for the if tests is to return a value of
true or false. Assigning a new value to result and incrementing test occur
almost as side effects. As we'll see, however, such "incidental" assignments and
changes are used very commonly in C, and make it possible to write compact
code.
^REMEMBER The major difference between the prefix (++test) and the
postfix (test++) forms of the increment operator is form
that the prefix
increments first, then uses the new value in the expression. Tht postfix form
first uses the current value in the expression, then increments this value after
use.
As with compound assignment operators, the increment operator can

the
only be applied to variables, that is, entities with memory locations associated
with them. Using these operators, you can only increment or decrement by 1
each time.
Because they are unary operators, the increment and decrement opera-
tors have very high precedence. Don't confuse the precedence of the operators
with the their use in prefix and postfix form. The precedence level only serves
to help the compiler properly group the elements in an expression, as the
following example shows:
main ()
<
int il = 6, 12 » 10, result;
. ; .
186 Using QuickC
result = il * 12--;
printf ( "result == '/.d; 12

result == 50; i2 == 9
The greater precedence of over * ensures that the compiler does not
turn the statement into result
because the expression in
=
parentheses
(il * i2)
is
— ;. This would be invalid anyway
not a variable.
Using the in its postfix form just means that the original value ( 10) of
i2 is used in the multiplication, rather than the lower value (9) after
decrementing.
Loops in C
Computers are good at doing something over and over again,
particularly
perhaps with slight variations. Such repetitions, or iterations, are called loops.
The loop construct is very common in programming.
The main type of loop in C is the while loop, which comes in two forms
and in a more compact variant, called the for loop. The following listing
illustrates a while loop:
/* Program to copute and display cubes and sujns of cubes

of first 10 integers
Program illustrates use of while loop.
*/
#define CUBE(x) ( (x) * (x) * (x))
main ()
int il, running_sum = 0;
il - 1;
while ( il <- 10)
<
rmming.sura += CUBE ( il);
printf ( "•/,2d: CUBE == '/.4d; running.sum == %4d\n"
il CUBE ( il) , running_sum) ,
++il;
Controlling C 187
CUBE
i ,
188 Using QuickC
The program carries oui each of the actions in the body of the loop. Then
the program goes back to the top of the loop, and checks the continuation
condition. If this condition is still true, the program carries out the actions in
the loop once again.
The increment statement, ++il, is a common way of modifying the
counter variable in a loop because most loops simply change the counter by 1
each time through. In this example, the operator increments il by I. As

nothing happens in the loop after the increment, it doesn't really matter
whether we use the prefix or the postfix form of the operator. At other times,
however, it will make a difference. This increment statement is crucial to the
loop. Without it, the value of the counter variable would never change, and the
loop would never end, since the continuation condition would always be true
(1 is always less than or equal to 10).
Components of the while Loop

There are four main components of the while loop:
il = 1; 4 /* Initialization */
while ( il <= 10) 4 /» Continuation Condition */
{ < /* Loop Body */
ruiuiing_sum += CUBE ( il);
printf ( "•/,2d: CITBE == '/,4d; ruiming.Bum == '/,4d\n"
il , CUBE ( il). ruiming.sum)
+*il: * /* Ctiange in looping variable */
}
The initialization refers to the looping variable. It is generally a good idea

to initialize the control variable just before starting the loop to make sure you
know exactly what value the loop starts with. The continuation condition is
the test to determine how long the loop continues. Unless you deliberately
want to create an infinite loop, make sure your continuation condition can
become false. The expression in ordinary continuation conditions will always
involve the looping variable. The loop body contains the actions to be done
when executing the loop.
These actions are the main purpose of the loop; the other components are
really administrative, to make sure the loop executes the proper number of
times, and with the correct values.
;
Controlling C 189
Finally, the change in the looping variable is designed to ensure that you
get closer to making the continuation condition false each time you go through
the loop. If you are changing the looping variable explicitly in the loop, make
sure you change the looping variable in the direction of the continuation
condition's boundary, or ending, value (in our case, 10).
^REMEMBER The four major components ofa while loop are: (l)initial-
ization of looping variable; (2) continuation condition; (3) loop body; (4)
change in value of looping variable.
In our illustration, the looping variable was changed at the bottom of the
main loop body. You can change it anywhere in the body. Be aware, however,
that changing it in different places may affect what happens in the loop. The
following example moves the change to the top of the loop from the previous
example:
/* "Sum of cubes" program with looping variable changed at top of loop. */
#define CUBE(x) ((x) * (x) * (x))
main ()
<
int il, running_sum = 0;
il = 1;
while ( il <= 10)
{
++il;
running_sum += CUBE ( il);
printf ( "'/,2d: CUBE == '/,4d; running.sum
il. CUBE C il) running.sura)
,
CUBE
190 Using QuickC
This means that the first cube to be computed is the cube of 2.
Similarly, the value of il is 10, when

program enters the loop for the
the
last time. Before cubing il, however, the program increments it to 11. Thus,
this version of the loop displays cubes and sums of cubes for the integers 2
through 11, whereas the previous program displayed for through 10. 1
Be careful when specifying your loops. The initial value for the looping
variable, the form of the continuation condition, and the place where the
looping variable is changed can all affect the outcome of the loop. To convince
yourself of this, try running this program with each of the variations listed in
Table 6-2. The first two cases correspond to the examples we've already done.
Study the behavior of your while loop, as you try these variations. They
illustrate the issues and problems that might arise in relation to the boundary
cases— that is, the first and last times through the loop.
More About the while Loop

The structure illustrated above represents the "vanilla flavored" form of the
while loop. Sometimes, in actual practice, one or more of these components
Table 6-2. Suggested Varients on the While Loop
Initial Looping
f :
Controlling C 191
might be missing, or might be present only in an implicit form. For example:
/* Program to read characters until a blank is entered.

Program uses while loop with implicit looping variable.
*/
main ()
{
int ch;
while ( (ch = getcheO) != ' ')

printf ( "y,c" . ch)
If you type the first few letters of the alphabet in order, this program
produces the following output:
aabbccddeef
The while loop in this program has no initialization for the looping variable
(ch, in this case). The looping variable is changed, but not necessarily in a
manner that will eventually make the continuation condition false. Essentially,
this program relies on the fact that the user will eventually get tired and end the
input. Later, we'll read information from files, generally using a loop to do so.
In those cases, we'll rely on the fact that the loop will eventually encounter an
end-of-file character, at which point the loop will stop.
The while loop tests the continuation condition at the top of the loop, if
the condition is from the start, the loop does not execute. Thus, a while
false
loop executes zero or more times. There is a version of the while loop that tests
its condition at the end of the loop body-after the loop has executed. We'll look
at this form of the loop in the next section.
The do-while Loop

Sometimes your program needs to carry out an action at least once. For
•example, suppose you wanted to get a value between and 10 from the user. 1
The following program will accomplish this.

; ; ;
192 Using QuickC
/* Program to prompt user until a value between 1 and 10 has been entered */
main ()
{
double val
do
{
printl "Please enter a number between 1 and 10 ")
(
scanf ( tval)
'"/.If",
if ( (val < 1) II ( val > 10))
printl ( "Number must be between 1 and 10\n");
}
while ( ( val < 1) || ( val > 10));
printf ( "You entered '/.If \n" val);
,
This program prompts for a value between 1 and 10, looping until the value
entered falls within those bounds. The program then displays the value read.
This loop will always execute at least once because the program will not
know what the continuation condition is until the program reaches the while
statement at the end of the loop body. If the continuation condition still holds
(that is, if the value that has been read is outside the desired range), the
program goes back to the top of the do-while loop and tries again.
The syntax for the while portion of the do-while loop is the same as that of
the regular while loop: the keyword while, followed by a continuation condi-
tion in parentheses. This while statement is at the end of the do-whiie loop
unlike its position at the beginning of the regular while loop.
Notice the if statement nested inside the loop body. This is allowed
because control constructs can be nested inside any other. It is just a coinci-
dence that the conditions for the if statement and the while construct are the
same.
Programmers use the do-while version of the while loop less frequently
than the regular form, but, under certain conditions, it is handy.
^REMEMBER The while loop tests at the top and may never execute; the
do-whiie loop tests at the bottom, and will execute at least once.
you are familiar with Pascal, you may recognize the do-while loop as
If
comparable to the REPEAT-UNTIL construct in that language.

Change the cube-computing program into a do-while loop, and see what
differences there are in the output for the eight forms of the loop.
Controlling C 193
The for Loop

As we've already seen, when something is done often, C tends to have a
compact way of specifying or doing it. The same is true of loops. C provides a
very convenient form of the loop construct, the for loop.
Recall that three of the components of a while loop were the initialization
of the looping variable, the continuation condition, and changing the looping
variable's value. The for loop lets you gather these components in one place, at
the top of the loop, and makes it possible to write the code in a compact but
readable manner. Let's look at an example:
/* Program to count from 1 to 20

Program illustrates lor loop syntax ami ubb
*/
main ()
; ; ; ; ;: : ; : ;
194 Using QuickC
Let's look
another example using the for loop: a program using the
at
loop to compute Centigrade temperatures corresponding to certain Fahren-
heit values. Both temperatures are displayed in a table. The particular tempera-
ture values computed depend on the starting and ending values, and on the
increment between successive values to be computed.
/* Program to list temperatures in degrees Fahrenheit and Centigrade

given starting value, ending value, and increment.
Program illustrates use of for loop.
#define F_TO_C C5.0 / 9.0) To convert from Fahrenheit to Centigrade:

subtract 32, then multiply by F_TO_C */
#define OFFSET 32.0
main ()
<
double cent, /* current temperature in Centigrade. */
val. /« value currently being converted */
start, ending, /* starting and ending values to convert */
increment: /• amount by which to change current val */
introduce.program () /* describe program and its use */
/* get information */
printf ( "Starting value? ")
scanf ( '"/.If". Sstart);
printf ( "Ending value? ");
scanf ( "'/.If", lending);
printf ( "Increment? "):
scanf ( "Xlf", tincrement)
/* display headings for table •/

printf ( "\nFahrenheit CentigradeXn")
printf ( " --\n"):
/* compute and diplay the values »/

for ( val = start: val <= ending; val += increment)
cent = ( val - OFFSET) * F TO C;

printf ( "'/.ICSlf ° /,10.51f \n" , val. cent);
introduce program ()
printf "This program displays the temperature ")

printf "in degrees Centigrade and Fahrenheit \n\n") .
printf "Your input: a starting Fahrenheit temperature ,\n")

printf an ending Fahrenheit temperature ,\n")
printf an increment \n\n") .
printf This version does no checking, so it's up to you to

printf "make sure your starting, \nending, and increment valu
printf "produce sensible results. \n\n")
Controlling C 195
This program displays the temperature in degrees Centigrade and Fahrenheit.
Your input: a starting Fahrenheit temperature,

an ending Fahrenheit temperature,
an increment.
This version does no checking, so it's up to you to make sure your starting,
ending, and increment values produce sensible results.
starting va
; ;
196 Using QuickC
In a sense, the for loop simply takes these three elements from the specific
places where they would ordinarily be found and groups them at the top of the
loop. Thismakes it much easier to make sure you've included all three
components, and that they are correct. They are far more prominent grouped
at the top than if they were distributed in the code.
When the program encounters a for loop, the following actions are taken:
1. The first expression is evaluated once, and any initializations are

made. This expression is not used again in the loop.
2. The continuation condition (second expression) is evaluated. If it is
false, the loop terminates, and no further action is taken in the loop
body or in the expressions.
3. If the continuation condition is true, the loop body is executed.
4. After the loop body has executed, the third expression is processed.
This will generally change the looping variable.
5. The program goes back to the top of the for loop, and repeats the cycle
beginning with step 2 (testing the continuation condition).
Let's look at one more example using the for loop, an example that prints
a portion of the ASCII table:
/* Program to display the printable ASCII characters in a table.

Program illustrates use of lor loop.
*/
/* global, BO display function can get at it */
int count; /* used to decide when to move to next line in output */
int curr_char; /* contains current ASCII value being processed */
main ()
{
count = 0;
for C curr_char = 32; curr_char < 127; curr_char++)
display ()
>
/* write ASCII code and corresponding character to the screen.

Write 5 entries per line.
*/
display ()
{
printf ( " %3d '/.c", curr_char, curr_char)
if ( ( ++count •/. 5) == 0)
printf ( "\n");
else
}
Controlling C 197
This program produces the following partial ASCII table as output.
"
32 33 ! 34 35 # 36 $
37 X 38 ft 39 '
40 ( 41 )
42 * 43 + 44 , 45 -
46 .
47 / 48 49 1 50 2 51 3
82
;
198 Using QuickC
Let's look at an example of a "non-standard" for loop that illustrates

several additional things abou this construct.
/* Program to build a long int from character input.

Program illustrates "non- vanilla" version of lor loop.
*/
#define BEEP AO?'

#define TRUE 1
#define FALSE
-
int ch, count =0; /* valid for count == 1 */
'
'
int negative = FALSE; /* TRUE if value should be negated, */

long val;
printf ( "Enter a series of digits: press RETURN when done.\n");

printf ( "The program will build a number from the digits \n\n") , ;
for ( val = 0; ((ch = fgetchar ()) != An'). )
'-' is first character */

count++; /* to see whether
if ( ( ch >= 'O') kk ( ch <= 'O'))
{
ch -= '0'; /* compute the digit's "value" •/
val = 10 * val + ch;
}
else if ( ( ch == •-') 4S ( count == D)
negative = TRUE;
leading '-'
else /* if not a digit nor a »/
{
printf ( "%c" , BEEP)
break;
}
}
if negative)
(
val »= -1;
printf ( "\ninteger built == '/.ld\n" , val);
This program reads character input, and tries to build a long int from the
input. It displays whatever number it was able to build, and beeps at the user if
the input is an invalid character (that is, anything other than a digit, or a '—'in
the first position).
The main control loop is a for statement. However, this time the first
expression initializes the long int being built rather than the looping variable.
The continuation condition in this example is similar to the one we saw in a
while loop above where the loop continued until a certain character was
encountered. Finally, there is no third expression. Any of the expressions at
the top of the for loop can be omitted, if the loop's logic allows or requires this;
the compiler will not complain.
Let's look at some of the other features of this program. There are some
preprocessor definitions, which we haven't been using much in recent listings.
The first manifest constant specifies the ASCII code for the beep. It's much
easier to understand a piece of code that says to display BEEP than one that
Controlling C 199
The other two definitions provide mnemonic names for two

calls for " \07."
values that the program will treat as true and false.

Only two of the variables defined, ch and val, are used in actually building
the number. The others, count and negative, are used to help control the
program's actions. Count is used to make sure that a minus sign is considered
valid only as the first character read. After the first character, count is not
really needed anymore. The other, negative, is set to TRU E if the character was
a minus sign, since this means the resulting value will need to be multiplied by
-1.
The if construct inside the for loop has several features worth noting.
First, it provides another example of the else-if construct in which conditions
are nested inside others. The purpose of the condition for the first if is to
identify digits. If the character is a digit, then its numerical value must be
computed.
We can't simply use the character's ASCII value as the digit's numerical
value because values for the digits range from 48 to 57. The expression used to
compute the digit's numerical value (ch — = '0') takes advantage of the fact that
the digits follow each other in order in the ASCII character set. Each digit's
value can be found by computing its offset from the ASCII value for '0'. For
example, the character '8'
has ASCII value 56. If you subtract 48 (the ASCII
value for '0') you'll get the digit's numerical value, 8.
The next statement in the if construct adds this numerical value to the
number that has been built so far, that is, to the current value of val. As each
new digit is read, it becomes the rightmost digit in the number being built. This
means the current number needs to be moved one place to the left that is, —
multiplied by 10 —
before adding the new digit in the I's place.
If the character read is not a digit, the program tests whether it might be a
minus sign. The minus sign is acceptable only as the first character. If this is the
case, the program sets negative to TRUE.
Finally, the last condition in the if construct (neither digit nor leading
minus As soon as such a character is encoun-
sign) catches invalid characters.
tered, the number building process comes to an end. Earlier, we saw that the
break statement immediately got you out of a switch construct. Here, the
break statement gets you out of the for loop, and back to the next level in the
main( ) function.
Here's a list of the main actions performed in building a number from
character input. The two major actions are: adding this digit in the proper way
to the number (the assignments involving val), and determining the digit (the
assignments involving ch).

200 Using QuickC
ch =
Controlling C 201
lent to have multiple expressions in the for loop. The following example
illustrates the comma operator (,) that provides such a capability.
/* Program to count up from 1 to 20, and down from 20 to 1 at the same time.
Program illustrates use of the comman operator.
•/
main ()
<
int up, down;
for (up - 1, down = 20; (up <= 20) bk ( down >= 1) ;
up++, down--)
printf ( "up y,5d; down '/,5d\n" , up. down);
This program counts up from and down from 20 to at the same time.
1 to 20, 1
The program uses a for loop to accomplish this. The approach is to have two
counters that are changed and used independently. The comma operator
makes it easy to specify multiple steps in each of the expressions at the top of
the for loop.
In this program two variables are changed in both the first and the third
expressions at the top of the for loop, with the assignments separated by the
comma operator.
The operands for the comma operator are evaluated from left to right: up
= 1 then down = 20. Values returned by operands of a comma operator are
discarded, except any value returned by the rightmost operand. The only effect
of the assignments is to store values in the respective variables. For now, think
of the comma operator as a convenient tool for multiple assignments . Later,
some other uses for this operator. The comma operator has the lowest
we'll see
precedence in C, which is why no parentheses were needed in the initializations.
Break and continue

When you need to get out of a loop quickly, before the current iteration of the
loop is completed, the break statement comes in handy.
For example,our program to build integers from character input, the
in
algorithm was designed to stop as soon as an invalid character was encoun-

tered. The only place to detect an invalid character was inside the for loop, so
the solution was to use break to get out of the loop completely.
The break statement terminates the innermost loop or switch in which the
statement is found. At that point, program control transfers to the next
; ;
202 Using QuickC
statement in the immediately surrounding bloclc, which may be another loop.

The break statement can be used only inside a loop or in a switch construct.
The continue statement is similar to break in that both allow exits from a
loop. The difference is in what happens after the exit. The continue statement
exits to the top of the loop in which the statement was found, thus preparing
the program to start the next iteration of the loop. The continue statement
does not apply to switch statements.
^REMEMBER The break statement exits from the innermost loop or

switch in which the statement is found. The continue statement exits from the
innermost loop (but not switch). The continue statement transfers control to
the top of the loop in which the statement was found. The break statement
transfers control to the next statement in the immediately surrounding block.
The following example illustrates one instance in which a continue state-
ment is useful:
/* Program to determine and display all numbers (between and 500)

that are divisible by each even number between 2 and 12.
Program illustrates use of continue construct.
*/
main ()
{
int count;
for ( count = 0; count <= 500; count++ )
{
if ( (count 2))
'/a /* for odd numbers */
continue
else if ( (count % 4))
continue;
else if ( (count '/. 6))
continue
else if ( (count "/,
8))
continue
else if { (count '/, 10))
continue
else if ( (count '/. 12))
continue
else
printf ( "° /ed\n" , count)
}
printf ( "upon exit, count == '/,d\n" , count);
}
120
240
360
480
upon exit, count == 501
Controlling C 203
This program writes out the values of all numbers divisible by each even
number between 2 and 12. The logic is to eliminate a number as soon as one of
the divisors leaves a remainder. Thus, if the number is odd, there is no point
testing 2, 4, 6, etc. if the number is not divisible by 8, there is no reason to try 10
and 12.
Once a number is eliminated, we want to try the next number in the
sequence. That is, we want to go back to the top of the loop and try the next
value. This is exactly what the continue statement accomplishes.
Notice the expressions being used to test each if statement. The tests are
asking whether the resuh of the modulus operation is a nonzero number,
whether division by the number leaves a remainder, if it does, then the number
does not divide the current value of count. We could just as easily have phrased
the tests more explicitly. For example, ((count % 2) == 1)) tests the same
thing, in a manner that is less compact but easier to read.
Contrast the effects of the continue statement with the same program, but
using a break statement instead.
/* "Divisibility" program, but using break instead ol continue.

Notice last value checked.
*/
main ()
204 Using QuickC
encountered. Since this happens when count takes the first odd value (1), the
program ends very quiclcly.
Summary
In this chapter, you've learned about control constructs in C, and have been
introduced to several new operators that are often used in these control
constructs.The two major categories of control construct are selection (if-else
and switch) and iteration (while, do-while, and for).
Most of the operators covered in this chapter are commonly used at
various points in selection or iteration constructs. For example, the relational
(<, <=, >, >=) and equality (== and !=), and the unary negation operator
(!) are often used to create simple tests for an if statement or for the continua-
tion condition of an iteration construct.
The logical operators (&& and II) are used to connect expressions into
longer, more complex conditions.
The increment (++), decrement ( and compound assignment opera-
)
tors (+=, — =, *=, /=, and %=) are used to change looping variables in
iteration constructs. Remember, the increment and decrement operators can
behave differently, depending on whether you use a prefix or a postfix form of
the operator. Finally, the comma operator (,) makes it easier to perform several
assignments or to make several changes in one place (such as at the top of a for
loop).
In the next chapter, we'll look at functions in more detail. You'll find out
how to define functions with parameters, and how to return values from
functions.
Functioning in
A major advantage C gives you is the ability to create function libraries and
then programs using only those library functions needed to accomplish the
tasks the program requires. However, so far we've been using functions
sparingly. That will change beginning with this chapter.
In previous chapters, we used programs for a range of simple tasks: print

ASCII tables, compute sums or sums of cubes, convert temperatures from
Fahrenheit to centigrade, and so on. These tasks were done by the main()
function, which is actually the program in C.
205
206 Using QuickC
We've called Run-Time Library functions, such as printf( ), getch( ), and

scanf( ). Some of these functions have required arguments, and others have
not. We've also written functions to carry out specific tasks in particular
programs, for example, introduce _ program( ) in the temperature conversion

program, and displayO in the ASCII table program. None of the functions
we've defined have involved parameters. So far, we have defined only "bare
bones" functions to carry out a task that is independent of variables or values
in other parts of the program or that have used global variables accessible to
any functions in the program.
In this chapter you'll find out more about functions, and we'll see how to
define functions with parameters. You'll also learn how to get information
back from a function by returning particular values. Throughout the text,
we've been using the values returned by library functions in various ways. For
example, the fgetchar( ) function returns an int that represents the character
read by the function.
C Functions
Think of C functions as specialists that you call when the need arises. A
specialist is someone with a particular collection of skills to perform specific
tasks. A function, then, is a collection of instructions (statements) designed to
compute a particular value or to accomplish a task.
Just as specialists can save time and effort, functions can save you
programming and debugging work. If there is a function available, call it to do
the work. If there isn't a function to do what you need, write one. Once written,
you can use it over and over again in other C programs.
For example, you might need to alphabetize several lists at different
points in a program. You could do this without using functions by writing the
instructions in the main program for each separate instance of alphabetiza-
tion. Suppose it takes 50 lines of instructions to alphabetize, and suppose you
need to do this 50 times in the program. That means 2500 lines of instruction in
the program. A 2500-plus line function is a clear example of bad programming
style. Short functions are much easier to write, understand, and debug than
long functions. Keep your functions short and clear.

Functioning in C 207
If you alphabetized the same Hst each time, you could replicate this code
easily by using the copy facility in your editor. Most likely, however, each
situation would be slightly different. You might, for example, have to go in and
change the variable names, or the number of elements to be sorted, and so on.
At best, accomplishing 50 sorts in the program would require you to copy
something 50 times. Things are unlikely to be so simple, however. You will
probably have to change some proportion of those lines. Even if you had to
change only 30% of the lines, that would be 750 lines — lots of time, and lots of
opportunity for making mistakes.
if you had a function for alphabetizing lists, you could simply call the
function, give it the list you wanted alphabetized, and the list will be returned
in the desired order — you just hand over the job, then get it back when it's
done. The great thing about having specialists on call is that they're good at
doing their job, and they'll worry about the details of whatever needs to be
done.
You don't need to know the details of how a function does its job, only
how to ask it to do the work. Again, this is similar to using a specialist: you
really need to know just enough about the task to be able to specify correctly
what you want done. You also need to know what information you are going to
get back from the function. We'll look at both of these issues how to ask for a —
function and how to deal with what it gives you —
but first, let's look briefly at
what happens when you call a function in the program.
Flow of Control
When your program runs, it carries out one instruction after another. The
program carries out instructions in the order in which they occur in the source
code, unless you specify otherwise, with a selection or iterative construct. Let's
look at an example of program execution.
/• Program to write the values 1 .. B three times.

Program illustrates flow of control in program execution.
*/
main () /* function declarator */
{ /* start of function body */
printf ( "Hello, world. \n"); /• 1 •/
;
208 Using QuickC
prlntf "I'm going to count for you\n");

printf "y.d\n", 1);
printf "/id\n"
printf "Xd\n"
printf "Xd\n"
printf
printf "XnYou didn't catch that?\n")

printf
printf
printf
printf
printf
printf
printf
printf
printf
printf
printf
printf
printf
printf
; ; ,
When this program runs, it simply carries out the instructions one after
the other. That is, the sequence in which the program executes is from
statement 1 through statement 22.
Notice that the same set of five instructions appears three times in the
program (statements 3 through 7, 10 throughThe only
14, and 18 through 22).
real inconvenience this repetition caused was having to put statement numbers
on each occurrence. The actual statements were easy to copy with the editor.
As the entire program is only about 25 lines long, looking at the source
code is not very daunting, nor is the extra work required to number the lines.
But suppose we had displayed this information 100 or more times. We would
have a very boring program. At first glance, you might feel overwhelmed by
which would be well over ten pages long, even though
the source code listing,
the code would consist of the same lines repeated over and over again. You
might, justifiably, be reluctant to read such scintillating code; the prospect of
writing the 800 or so statements required is even less appealing.
The use of a function can help make the task easier. The following
example shows how, and will also let us explore the flow of control when
functions are called.
/* Program to write the values 1 6 three tliries. .
calling a function to do the writing.

Program Illustrates flow of control when function calls are involved.
•/
main ()
{
printf ( "Hello, world. \n"); /* 1 */
printf ( "I'm going to count for you\n"): /* 2 */
display ; /• 3 »/
/* 3a */
printf ( "\nYou didn't catch that?\n") /* 4 »/
printf ( "Oh. all right, I'll count again. \n"); /* 5 */
display () /* 6 */
/• 6a */
printf ( "\nYou STILL didn't catch that?\n"); /* 7 •/
printf ( "I'll do it one more time.\n"); /* 8 •/
printf ( "But please pay attention this time.Xn"); /• 9 */
display (); /• 10 »/
/* 10a */
display ()
printf ( "Xd\n". 1) /• 11 •/
printf ( "Xd\n", 2) /• 12 •/
printf ( "Xd\n". 3) /• 13 •/
printf ( "Xd\n". 4) /* 14 */
printf ( "Xd\n", 5) /* 15 »/
This program performs exactly the same task as the preceding one. The
210 Using QuickC
only difference is that the sequence of instructions to display the numbers has
been made into a function, which the main( ) function calls at the appropriate
times.
When this program runs, starts executing the instructions in sequence.
it
When the program gets to statement 3, however, programs behave differently

from the preview version. Essentially, the function name, display( ), serves as
an indicator that some instructions should be here namely, those in the body —
of the function. The program will behave as if the instructions (rather than the
function call) had been there, except that the actual instructions are not
physically present in the code.
When the program calls display( ), control is turned over to that function.
The instructions contained in the function body are loaded and executed in
succession.
As you already read in Chapter 4, there are differences between a prepro-
cessor macro call (which actually substituted the macro body into the code
when the macro call was encountered, before or during compilation) and a
function call (for which the code would be loaded when needed by the running
program). This loading process, and the time required to accomplish it, is what
the discussion there was about.
The flow of control in this program is: 1-3, 11-15. When the function is
finished executing, its environment is discarded from working memory, and

control returns to the statement immediately after the function call.Think of
the control as returning to the empty line, 3a. The rest of the program
statements execute in the following sequence: 4-6, 11-15, (6a), 7-10, 11-15,
(10a).
Notice that the last "control point" is 10a — the empty line right after the
final call to display(). Almost always, functions will return control to the
calling functions. Thus, it will almost always be the main program that ends
execution, even though it may have nothing more to do after the last statement,
if that's a function call.
This entire program is a sequence of function calls. C actually transfers

control back and forth between main() and printf(). Because printf() is a
library function, and therefore a black box as far as we're concerned, we can
think of its activities as a single statement from the point of view of the calling
function, main( ). A function call temporarily transfers control to the called
function. When the function is finished, C transfers control back to the
"calling routine."
;
Often, a function called by the main program will, in turn, call other
functions. The same process will be repeated at this inner level. That is,
function displayO will temporarily transfer control to another function,

printf(). When function printf() is done, it will transfer control back to
display( ). When display( ) is done, it will, in turn, transfer control back to the
main program. The following listing also illustrates nested function calls.
/* Program to write the values 1 .. 5 three times.

calling a function to do the writing.
The displayO function, in turn, calls another function.
Prograffl illustrates flow of control with nested function calls.
*/
main ()
{
printf ( "Hello, world. \n"); /• 1 */
prlntf ( "I'm going to count for you\n"): /* 2 */
display /• 3 */
/
:
/* 3a
printf ( "\nYou didn't catch that?\n"); /* 4 */ /
printf ( "Oh, all right. I'll count again. \n"); /* 5 •/ (
display () /* 6 */ t
/* 6a */ i
printf ( "\nYou STILL didn't catch that?\n"); /* 7 */
printf ( "I'll do it one more time.\n"); /* 8 */ II
printf ( "But please pay attention this time.\n"); /» 9 */

display (); /* 10 */
/* 10a •/
display ()
<
printf ( »%d\n". 1) /• 11 */
printf ( "Xd\n". 2) /* 12 */ I
printf ( ")id\n". 3). ....
/* 13 •/ „
5
interruption ;
/* 14 */ i
/* 14a */ :
print! ( "W\n». 4); /* IB */
printf ( "Xd\n". 6); / 16 •/
interruption ()
<
printf ( "We interrupt this display to announceAn") ; /* 17 */
printf ( "The display will continue now.Nn"); /• 18 */
}
This program displays the numbers, interrupted by two lines of te.xt each
time. The output is shown in the next listing:
Hello, world.
I'm going to count for you
212 Using QuickC
We Interrupt this display to aiuiouiice;

The display will continue now.
You didn't catch that?

Oh. all right. I'll count again.
3
We interrupt this display to announce:
You STILL didn't catch that?

I'll do it one nore time.
But please pay attention this tine.
We interrupt this display to announce:

The flow of control in this program is as follows: 1-3, 11-14, 17-18, (14a),
15-16, (3a), 4-6, 11-14, 17-18, (14a), 15-16, (6a), 7-10, 11-14, 17-18, (14a), 15-16,
(10a).
The interruption( ) function returns control to display( ), rather than to
main( ). This is because display( ) (and not inain( ) ) called interruption( ). In a
sense, the main program doesn't really know anything about interruption()
because main() has nothing directly to do with that function.
In keeping with the analogy of specialist, you can think of function calls
by functions as subcontracting to other specialists. The original contractor
need not know anything about these subcontracts, just as the calling function
doesn't know anything about the functions called by its specialists.
Function calls are just Hke other C statements, except that the function
call is likely to accomplish the work of several statements. Functions can be
used in conjunction with all C's constructs, including the selection and itera-
tion constructs. Let's look at a few examples.
#define MAX.DISPUY 5
display
{
printl ( "Hello\t");
>
main ()
{
int index;
for ( index - 0; index <- MAX.DISPLAY; index++)

displayO ;
:
This program writes iiello five times on a line. In the next example, C
functions are being used as alternative actions in an if construct.
#dellne MAX.SIZE 10
#deflne URGE CUT 1000.0
tdeflne FACTOR 1.0
nainO
<
double start • 2.0;
Int index:
for ( index - 1; index <- MAX.SIZE: lndex++)

{
il ( start < URGE.CUT)
small val():
else
large _val()
start •- FACTOR:
arge.val ()
printf ( "LARGE\n"):
mall.val
prlntl ( "SMALLSn");
In this program, the functions small _val() and large _val() just write
their size, depending on the value of start. Notice that the function calls
represent the alternative actions in the for loop.
Function Returns
As you've seen already, you can use C functions in two different ways: by
doing something with the value returned by the function or by having the
function perform some action, but discarding or ignoring the return value, if
any. So far, the functions we've defined (as opposed to some of the library
functions we've used) have all been of the second type — where the program is
not counting on any returned value from the function. For example, the
display( ) function in the "counting" programs above just does some work for
the calling function.

You will often need or want a function to return a value, for use by other
parts of the program. The following listing shows how to define such a
function.
; ; ; ;
214 Using QuickC
/* Program to compute ad many pseudorandom values as desired

between 0.0 and 1.0.
Program Illustrates use oi functions that return a value,
including syntax for defining and declaring such a function.
*/
/* Function to return a pseudorandom value between 0.0 and 1.0.

Note format of function heading;
<type Bpecifier> <function name> ()
*/
double zero one rand

<
#define MAX.VAL 32767.0 /* NOTE: defined as floating point type */
int rand () /* returns a pseudorandom integer */
int rand.result;
rand.result rand () /* get a pseudorandom integer */

;
return ( rand_result / HAX.VAL)
main ()
{
#define MAX.COUNT 15 /* maximum number of times through loop. •/
/• function declaration, so main can use it the function properly. */

double zero_one_rand ()
int c ount
/* main loop. Note how function call to zero_one_rand() is used. */
for count " 1; count <- MAX.COUNT; count**)

(
printf ( "X5d: random double -

'/,lf\n",
count, zero_one_rand ());
This program produces the following output. The particular values

returned will probably differ when you compile it, depending on the first call to
the rand( ) function.
random double -- 0.0012B1

random double -- 0.B6358B
random double -- 193304
—
.
random double 0.808741

random double " 0.479873
random double -- 0.350291
random double "- 0.746605
random double •• 0.710501
random double * 0.513535
random double " 0.303995
This program writes pseudorandom floating point values, between 0.0

15
and 1.0. The program works by calling a function, zero _ one _rand(), we've
defined for the purpose. This function returns a value of type double, as
indicated by the definition of the function and its declaration in niain().
Let's look at how the zero one _ rand( and return work.
) function call
When the arguments to printf() are evaluated, the program finds a call to
zero one rand() and transfers control to this function, which computes
and returns a double. The value returned is substituted for the placeholder in
the string argument to printf( ).
The function zero one rand() works in a manner similar to the
rand( ) library function we saw earlier. The library function returned a pseudo-
random integer between and 32767 (the largest integer in QuickC). The
zero _one rand( ) calls rand( ) for such an integer, and then "standardizes"
the integer returned by rand( ) to a double value between 0.0 and .0. The result 1
is then returned to the calling function.

The return statement mechanism by which the function result is
is the
passed to the calling function. The return effects an exit from the function,
possibly taking a value out with it. The return may include an expression
which should evaluate to a value of the type the function returns. The result of
the expression is the value returned by the function. Thus, in the example, the
return was made with the expression, rand result/ MAX VAL, which
evaluates to a value of type double.
The return statement has the same effect as the break statement we saw
earlier, for switch and loop constructs. Both types of statements effect an exit
from a block. In the case of break, this block is a loop or a switch statement; in
the case of return, the block is usually a function. If a function has no return
statement, or if the return statement lacks a value, then the function does not
return a value.
If there is no return, the function keeps executing until the last statement
in the function is done. Then, control reverts to the calling function. If the
function includes a return statement, but without an accompanying expres-
sion, control reverts to the calling function right after the return.
You can put return statements anywhere in a function. For example, you
might want to return different values, depending on the conditions that hold in
the function or the results of a computation. Control reverts back to the calling
function right after the first return statement is evaluated. The value of the
function — that is, the value returned by the function -is the result of the
expression for the return. C ignores any statements after a return in the
execution of the function.
The definition for zero _ one _ rand( ) is more elaborate than the defini-
tions we've seen in previous chapters. First, notice the function declarator for
zero _ one _ rand. The function name is preceded by a type specifier, double.
216 Using QuickC
This specifier indicates the type of value returned by the function. If the type
specifier is absent, the function is assumed to return an integer. Functions may
return values of any of the types we've seen so far, as well as types we haven't
yet covered.
^REMEMBER
• A return statement effects an exit from a function, and transfers control
to the next statement in the calling function.
• The return statement may include an expression that evaluates to the

value returned by the function.
• If a function includes no return statement, or includes a return state-

ment without an associated value, then the function does not return
a value.
Sometimes you will want to state explicitly that a function does not return
a value. There is a special type specifier, void, for this purpose. To indicate that
a function does not even return an int (the assumed default, if no return type is
specified), write void before the function name in the function heading. The
dispiay( ) function in the "counting" program would be defined as follows:
void display ()
{
printl (
The manifest constant, N4AX VAL, is replaced by a floating point

representation of the maximum integer value in QuickC: 32767. The reason
for this has to do with types and operator precedence. The value returned by
rand(), rand — result, is an int. Had we used the int version of 32767 in the
example, the result of doing an integer division would always be either or 1
because the only possible values for the numerator would be values between
and 32767, none of which is more than the twice 32767 needed to produce a
quotient greater than 1.
By dividing with a floating point type, the expression becomes one

involving such types, and the division produces a quotient complete with
fractional remainder, rather than the or 1 that would result from the integer
division.
Formal and Actual Parameters
Earlier, we looked at two versions of a program that counts to five and displays
the results on the screen. Suppose you wanted to count to different values each
time, again displaying the results. One way to accomplish this would be to go
back to the original program, and simply call printf( ) as often as desired at
each point. Again, that could become tedious to do. An ahernative would be to
modify the definition of the display( ) function to you specify how high it
let
should count each time you call it. This solution would use a parameter to
specify the target value each time you called the function.
Basically, a parameter is a slot through which you can pass information
when you actually call the function. This information will let you have some
control over how the function executes. Let's look at an example:
/* Program to write the values starting at 1 three times.

Program calls displayO to do the writing;
argument specifies how many values to write in that call.
Program Illustrates use ol parameters when defining and using functions.
•/
main ()
{
printf
:
218 Using QuickC
printf ( "\nYou CTILL didn't catch that?\n") /* 7 */

printf ( "I'll do it one more timeAn"); /* 8 */
printf ( "But please pay attention this timeAn"): /* 9 */
display (2); /» 10 */
display (how.often) /* how.often is a formal parameter. */

int how_often: /* declare parameter as an int. */
int count:
for ( count = 1: count <= how.often: count++) /• 11 */

printf ( "'/,d\n" count):
, /* 12 */
This program produces the following outputs:
Hello, world.
I'm going to count for you
You didn't catch that?

Oh, all right, I'll count again.
You STILL didn't catch that?

I'll do it one more time.
But please pay attention this time.
This program counts and displays the results in a manner similar to the earlier
programs. The difference is that the program counts to different values each
time displayO is The flow of control in this program, at least inside
called.
function display( ), also is somewhat different this time.
The calls to display( ) now include an argument, the value to which the
function is to count and display. The definition of function displayO also
differs from the functions we've seen so far. Corresponding to the argument,
or actual parameter, we pass when display( ) is called, the function definition

includes Si formal parameter, how_niany, in the function heading.
The formal parameter represents a slot through which a function call will
pass information into the function. The how _ often within parentheses in the
function declarator serves to reserve a slot and to provide a local name for that
slot. Having done that, you need to declare the formal parameters (in the
example, only one) for use in the function. To do this, you need to supply two
things: a name to use for the parameter in the function, and information about
the parameter's type.
Formal parameters are declared outside the main function body. The
storage and the names for the formal parameters exist only while the function
is in memory and running. Once the function has finished and is discarded, its
variables and parameter slots also disappear. You may use any valid identifier
for the formal parameter. This identifier will be the slot's name within the
context of the function.
The following illustration identifies the components of a function declar-
ator. The declarator has three main components: a return type, a function
name, and a formal parameter list. Each formal parameter included in the list
must also be declared as a variable.
Function return type
Function name
i
void display (how.olten)
int how.often;
h "t
Formal parameter list
Formal parameter declaration
When you call a function with an argument (an actual parameter), the
program copies argument value into the storage allocated for the corres-
the
ponding formal parameter. Thus, the function works with a copy of your
argument. This means that the function will not change the variables you pass
as arguments.
The information flow via the parameter list is one-directional, in what we
have seen so far. Because the function only gets a value, rather than an actual
variable, such parameter passing is known as passing by value. We'll look at
bidirectional information passing after we've discussed pointers. In a certain

sense, parameters allow functions to use data from the calling function, but
protect these data from the function.
To pass information out of a function, the function needs to return a value
or work with global variables. Using global variables allows the function to
bypass parameters and to work directly with variables. The major disadvan-
tage of functions working with global variables is that the function is usable
only in programs that include the global variables.
Parameters, on the other hand, set aside generic slots, into which you can
pass values from anywhere, provided the values are of the appropriate type.
The name you provide in the formal parameter list serves as a name only in the
function. The name is not known to the calling function, which means that you
; ;
220 Using QuickC
can use the same identifier in different contexts. The name you use for the
formal parameters need not be the same as the name of any variable in the
calling function or in the program. The name and the storage associated with it
disappear when the function finishes.

The following example illustrates the difference between using global
variables and using parameters.
int global. val;
void show.global.val ()
{
printf ( "Xd\n" , global.val)
>
void 8how_any_val ( int val_to_show)

{
printf ( "%d\n" , val_to_show)
>
The show global val() function can print only the current value of
global — val. When you want to use this function, you first need to store the
value you want to display in global — val, then call the function. This is
inconvenient at best, and could be a real problem. Suppose the function calling
show — global — val() needs to do something with the current value of
global val immediately after displaying some other value. To do this you
would need to store the current value of global — val somewhere, assign the
value to be displayed, call show — global _val(), then restore the value you
want to use.
With parameters, on the other hand, you can display the contents of
global val or any other integer variable, just by calling show any — val()
with the appropriate argument. Because the argument is passed by value, the
current value of the parameter variable in the calling function will not change.
Parameters offer both control and flexibility. We'll use them extensively in the
examples in this book.

The function body for display( ) also contains a local variable definition,
for count. This definition also associates a type and address with a particular
identifier. The storage and name allocated for local variables are known only
to the function in which the variable is defined. Both storage and name
disappear when the function ends. Local variables cannot directly influence
anything outside the function, whereas there are ways of making parameters
capable of transferring information back to the calling functions.
; ; ;
For now, think of formal parameters as a way of getting information into

a function from the caUing routine. Think of local variables as a way of storing
and manipulating things within the function. When the function is called, it is
called with one argument for every formal parameter in the function defini-
tion. These arguments are known as the actual parameters for the function.
The calling function, niain( ), calls display( ) with an actual parameter of 5.

This argument is passed in to tell display() how high to count. The local
variable, count, serves as the looping variable for the for construct.
The flow of control for the first part of the program is: 1-3, 11-12, 11-12,
11-12, 11-12, 11-12, 11, (3a), 4 ... Statements 11 and 12 are each called five
times, once for every value from 1 to how _ often. Notice also that statement
11 is executed one more time than 12. The last time, the continuation condition
is false, so the loop (that is, statement 12) is not carried out.
^REMEMBER In a function definition, the slots through which informa-

tion will be passed are known as formal parameters. In a function call, the
items of information passed into the function through these slots are called
arguments, or actual parameters.
Let's look at another example using parameters, to see how to declare

such a function when used in another function.
/* Program to compute reciprocals of values between -10.0 and 10.0.

Program Illustrates use ol parameters.
•/
•define INVALID.VAL -09999.909 / value to return when result is invalid */
/• Function to return the reciprocal of the argument passed in. */

double reciprocal ( val_to_invert)
double val.to.invert
{
if ( val.to.lnvert I" 0.0)
return ( 1 / val.to.invert)
return ( IHVALID.VAL)
>
main ()
{
•define MAX.COUHT 10
double reciprocal O, /' declare function, so main can use »/
double count;
for count - -10.0; count <• MAX COUNT; count**)

(
printf ( "XlO.aif: reciprocal %16.101f\n", "

count, reciprocal ( count));
222 Using QuickC
-10.00: reciprocal -- -0.1000000000

-9.00: reciprocal " -0.1111111111
-8.00: reciprocal - -0.1250000000
-7.00: reciprocal -• -0.1428671429
-6.00: reciprocal -- -0.1666666667
-5.00: reciprocal — -0.2000000000
-4.00: reciprocal — -0.2500000000
-3.00: reciprocal -- -0.3333333333
-2.00: reciprocal -- -0.5000000000
-1.00: reciprocal " -1.0000000000
0.00: reciprocal -- -99999.9990000000
1.00: reciprocal — 1.0000000000
2.00: reciprocal - 0.5000000000
3.00: reciprocal •- 0.3333333333
4.00: reciprocal «- 0.2500000000
5.00: reciprocal - 0.2000000000
6.00: reciprocal " 0.1666666667
7.00: reciprocal -= 0.1428571429
8.00: reciprocal " 0.1250000000
9.00: reciprocal =- 0.1111111111
10.00: reciprocal =- 0.1000000000
This program displays the reciprocals of values between — 10.0 and 10. The
main( ) function calls reciprocal( ) for this information.
Function reciprocal() has one formal parameter, val to_invert, and
returns a value of type double. To avoid division by zero, which produces a
floating point error, the function checks the actual parameter passed in — that
is, the value copied into val _ to — invert. If this value is 0.0, the function
returns a predefined value (INVALID —VAL), which indicates an error.
The definition for this function has the same format as the definition for
display( ) with a parameter. The major difference between the two functions is
that reciprocaI( ) returns a value, whereas display( ) does not.

Notice that the declaration for reciprocal ) inside function main() does
not provide information about the number and type of parameters that
reciprocal( ) uses. In this declaration format, which we've been using through-
out, the compiler just wants to know that you'll be calling a function and what
type of value the function is returning; the compiler doesn't require any
information about the number and type of parameters function calls should
include.
However, because the compiler has minimal information about the func-
tion and how it can be used, the compiler can't do any checking for you. For
example, the compiler won't tell you whether you've called the function with
thewrong number of arguments. If you make such an error, the behavior of the
function is undefined. This means you may get incorrect results without ever
getting any sort of error message.
; ; ; ;
The compiler also won't know if you've called the function with the wrong
type of parameters. Therefore, the compiler will make the substitutions you
request, which may cause type incompatibilities when the function being
called starts running.
Let's look at one more example, which will also let us see the differences
between the prefix and postfix form of the decrement operator.
/* Program to illustrate use of function parameters,

also shows some differences between prefix and postfix forms of the
operator.
*/
#define MIN.VAL 10
main {)
{
int pref post index
, , , argument
int leave_alone ();
int quadruple () , one_fourth (); /* for suggested exercise */
printf ( "Index\tPrefix\tPostfix\n\n")
for ( index • 20; index >= MIN_VAL; index--)
<
argument index;
pref » leave.alone ( --argument);
argument index; /
to make sure same value is passed */
post leave_alone ( argument--);
printf ( "y.3d\tX4d\tX4d\n" index, pref, post);,
/• Use this function in conjunction with one_fourth() */

int quadruple ( val)
int val;
{
return ( 4 * val)
}
/* Use this function in quadruple with one.fourthO */

int one_fourth ( val)
int val;
i
return ( val f, 4) ;
int leave_alone ( val)

int val;
{
return ( val)
>
Index Prefix Postfix

224 Using QuickC
The program writes a series of values and the corresponding value when
certain variants on the index are passed to a function that just returns the value
it was passed.
Notice that the prefix form of the decrement operator makes its change
before the value is passed to the function as an argument. The postfix form
makes its change after the value is passed.
This program would compile, but would run incorrectly, we passed a if
double into leave _ alone( ). The compiler has no way of knowing that the
argument to the function is of the wrong type, because the function declara-
tion did not provide any information about the parameters. Failure to check
for such mismatches can cause incorrect results.
CAUTION In the current C syntax, function declarations provide no

information to the compiler about parameters to the function declared. As a
consequence, the compiler is unable to check for function calls with the wrong
number or type of arguments.
In the next chapter, you'll find out about a concept designed to provide
the compiler with much better checking capabilities in such situations.
Summary
In this chapter we've discussed the fundamental properties and uses of func-
tions.You learned how to return a value from a function, and how to define
functions that return such values. You also learned how to use parameters to
make functions more flexible. The more flexible a function, the more widely it
can be used.
Functioning In C 225
Function libraries are built of functions that perform specific tasks in a

variety of contexts. As you program, it's a good idea to design your functions
with such uses in mind. As your collection of functions grows, group them in
function libraries, to draw on as you need them in other programs. In this
chapter, we've created several functions that can be used in your programs:
non «_ zero, safe _ division( ), and even zero _ one _ rand( ), for some purposes.
In the next chapter we'll look at function prototypes, a concept intro-
duced in the Draft Proposed ANSI Standard. Function prototypes are
designed to provide the compiler with the information it needs to do the kinds
of checking we mentioned in this chapter.
;
Function
Prototypes
Let's look at the program from the last chapter again. This time, let's see what
happens when we pass the functions bad arguments.
u
/* Program to illustrate consequences of incorrect use ol function parameters.
*/
define MIH.VAL 10
int pref post, index;

.
double argument;
int leave.alone ();
printf ( "Index\tPreflx\tPoBtfix\n\n")
lor ( index - 20; index >• HIN_VAL; index--)
{
argument index;
pref leave.alone ( --argument);
argument • index;
227
; ; ;
228 Using QuickC
post = leave_alone ( argument--)

prlntl ( "'/.3d\t'/,4d\t'/.4d\n" index, prel
. , post);
}
printf ( "\n\n\nIndex\tPrelix\tPostfix\n\n")
for ( index = 20; index >= MIN.VAL; index--)
{
argument = index;
prel = leave_alone ( --argument, index);
argument = index;
post = leave_alone ( index, argument--);
printf ( "X3d\t'/.4d\t'/.4d\n" index, pref post);
. ,
int leave_alone ( val)

int val
{
return ( val) ;
Index Prefix Postfix
index
;
Function Prototypes 229
In the second part, the call to leave alone() has the wrong number of
arguments. The compiler simply starts processing parameters in its accus-
tomed sequence, and stops as soon as it has the required number of arguments.
Because the arguments were passed in different sequences, the results are
different.
To avoid such difficulties, the compiler must do a more extensive check of

your program's function calls using the Draft Proposed ANSI Standard's
function prototype, which is essentially a more elaborate function declaration.
The function prototype includes information about the types the function
expects as arguments. In a sense, the function prototype provides the same
information as the function declarator, except that types rather than identifiers
are used to indicate the parameters. For example, the following would be a
prototype version of the declaration for reciprocal ) within main( ) in the
previous listing:
/* function prototype: lor use aB declaration in mainO, in earlier example.

Note the information regarding parameter type (and number) in declaration.
*/
double reciprocal ( double)
This prototype tells the compiler how many parameters reciprocal )
expects, as well as the parameters' type information. If you accidentally call
reciprocal ) with the wrong number of parameters, the compiler will warn
you.
In the preceding program, check what happens when you call the func-
tion reciprocal ) in main(), with two arguments. Now, modify main() by
including a function prototype instead of a simple function declaration for
reciprocaI( ). Then check the result of calling the function with two parame-
ters.
Using a prototype also makes the compiler better at dealing with mis-
matches between types of the argument and the corresponding formal
parameter. For example, if you call reciprocal ) with an int instead of a double,
you will get unpredictable results using a simple function declaration. If you
use a prototype, however, the compiler will convert the type of your argument
to the formal parameter's type, as long as this conversion would be valid in an
assignment statement.
Run the following program twice. The first time, run the program as is;
the second time, change the function prototype form to a simple declaration of
reciprocal( ). With the prototype, the compiler knows that the function is
: ; ;
230 Using QuickC
expecting a double, so it promotes your int argument to a double before

passing the value to reciprocal(). The second time, you will get garbage,
because the compiler does not do the required conversions. (Incidentally,
notice the use of the comma operator in the program.)
/* Program to compute reciprocals of values between -10.0 and 10.0.

Program uses an int as looping variable, though parameter is a double.
Can do this because function was declared using a function prototype.
Program illustrates advantage of using function prototype.
*/
#define INVALID.VAL -99999.999 /* value to return when result is invalid */
/* Function to return the reciprocal of the argument passed in. */

double reciprocal ( val_to_invert)
double val_to invert:
<
if ( val.to. invert != 0.0)
return C 1 / val_to_invert)
else
return ( INVALID.VAL)
main
C
#define MAX. COUNT 10
double reciprocal (double):
double count
int test:
/ Loop to call reciprocal with test, an INT, instead of the

double expected. Will produce garbage unless reciprocalO
is declared using a function prototype.
Note use of comma operator.
•/
for ( count = -10.0, test = -10: count <= MAX.COUNT: count++,
printf ( "y,10.21f: reciprocal == '/.IS. lOlf \n" ,
count, reciprocal C test));
To specify the prototype no parameters, tell the

for a function that takes
compiler explicitly that a function has no parameters by using the keyword,

void. For example, the following listing shows the non-prototype and the
prototype forms for declaring the parameter-less function, zero _ one _
rand( ), that we used earlier.
double zero.one.rand (); /* NON-prototype form of declaration */

double zero.one.rand (void): /* Prototype form of declaration */
When the compiler sees void in this context, it will know that the function
you've declared takes no parameters.

The fact that the compiler checks type and number on arguments when
you use prototypes should not encourage careless function calls. Rather, you
should use prototypes to take advantage of the kind of things compilers are
very good at —
catching inconsistencies —in order to weed out errors.
The Draft Proposed ANSI Standard is moving the C programming
environment toward prototype use. Currently, simple function declarations
are used almost exclusively. They are allowed in the Draft Proposed ANSI
Standard largely for the sake of existing programs, but are considered obso-
lescent by most programmers. Simple declarations are expected to disappear
from use eventually. In the remainder of this book, well use the function
prototype form.
Influence of Prototypes on Syntax

for Formal Parameters
Prior to discussing function prototypes, we looked at the syntax for defining

functions, noting that the function body is preceded by two other compo-
nents: a function declarator that contains identifiers within parentheses if the
function takes formal parameters, and declarations for each of the formal
parameters. If the function takes no parameters, the function declarator
contains empty parentheses, and the function declaration component is omit-
ted. This "non-prototype" syntax — with separate parameter declarations — is
currently used by most C programmers.

However, the Draft Proposed ANSI Standard has declared this syntax
only temporarily valid since it will eventually disappear to be replaced by the
syntax described in this section. In this new syntax, the function declarator has
more similarity to a function prototype.
The intent is become the standard way of
to have the following format
specifying the formal parameters in the interface between a function and the
outside world. The following program illustrates the new syntax, while provid-
ing more examples of function prototypes:
;; ; ; ; ;;; ; ;
232 Using QuickC
/* Program to compute ratios of successive pairs of pseudorandom values,

and to compute a mean.ratio when done.
Program illustrates use of prototype syntax for specifying formal
parameters.
*/
#define INVALID VAL -99999.999 /* value to return when result is invalid */

#define TOLERANCE l.Oe-12
#define TRUE 1
#define FALSE
/* Prototype syntax so no separate parameter declaration.

,
*/
int non_zero ( double val)
if C (( val - 0.0) > TOLERANCE) I I

((val - 0.0) < -TOLERANCE))
return ( TRUE)
else
return ( FALSE)
}
double safe_division ( double numer, double denom)

•C
int non_zero ( double)
if ( non.zero ( denom))
return ( numer / denom)
else
#define MAX.VAL 32767.0 /* NOTE: defined as floating point type */

int rand (void) ; /* returns a pseudorandom integer */
int rand_result:
rand.result = rand /* get a pseudorandom integer */;
return ( rand result / MAX_VAL)

}
main
double safe_division ( double, double):

double 2ero_one„rand ( void)
double vail, val2. ratio. running_sum = 00. mean.ratio;

int index. how_many;
printf ( "Compute how many ratios? ");

scanf ( "y,d" 4how_many)
, ;
for ( index = 1; index <= how.many ; index++)

<
vail » zero_one_rand ()
val2 = zero_one_rand ()
ratio = Eafe_division ( vail. val2)
running_sura += ratio;
printf ( "ratio 7,10. Blf; running_sum : : %10.51f\n"
ratio, running sum);
}
printf ( "after loop, index y,d\n" index); " ,
mean.ratlo » saf e_division ( running_sum. --index);

printf ( "running.sum — 7,10. 51f; mean ratio Xl0.51f\n", "
running_sum. mean.ratio)
This program, which was asked to compute ten ratios, produces the
following output for a sample run:
ratio
_
234 Using QuickC
The function zero one rand( ) lakes no parameters. When it was

declared in niain( ), the keyword, void, was included to indicate that the
declaration was a prototype. To understand why there is no void in the
function declarator line for zero one _ rand( ), we must remember that when
the compiler sees a function declarator at the top of a definition (that is, a
function declaration without a semicolon at the end), it knows that the
function takes as many parameters as are specified between the parentheses. If
nothing is specified between the parentheses, the compiler knows that the func-
tion takes no parameters; the compiler will not confuse this with an ordinary,
non-prototype declaration. That's why you don't need to put void here.
In fact, you cannot put void between the parentheses for such a function.
You will get a compiler error. Essentially, the compiler expects to see either a
non-keyword identifier or a type specifier/ identifier pair. If it finds just an
identifier, the compiler will treat your declarator as being of the non-prototype
sort.
^REMEMBER When using the prototype form of the syntax for specifying
formal parameters in the function declarator, a type specifier must be paired
with each formal parameter identifier, and multiple type specifier/ identifier
pairsmust be separated by commas. You may not use void in a function
heading to indicate that the function takes no parameters. You may use void to
indicate this when declaring the function for use in another function. (You may
also use void in a function heading to indicate that the function returns to no
values.)
Let's look at each of the functions and then work through the program's
execution. This will give us a chance to see how the program works and also to
raise some additional points about the code. We'll leave the discussion of the
non zero() function till last, because that function raises additional issues.
The safe division( ) function returns a quotient. The function first calls
non _ zero( ), to check whether the denominator is too close to zero to allow
division. If that is the case, the function returns a predefined error value,
INVALID_VAL.
Keep in mind that the zero _ one _ rand( ) function returns a pseudoran-
dom value between 0.0 and I.O.
The main() function does the bulk of the work -calling zero _ one
rand( ) and safe _ division( ) for its values. Notice the statement that assigns a
value to mean ratio. This assignment calls the safe division() function.
The first argument is a double; the second is an int. Because we've used a
function prototype to declare safe_division() inside main(), the compiler
makes the appropriate type conversion before passing the value of index into
the function. In addition, the decrement operator! ) isapplied to the value
of index before it is passed into the function — because we used the prefix form
of the operator. The value of index must be decreased by one because it is one
more than it should be (11 instead of 10).
The other function in the program, non zero( some noteworthy
), raises
issues when using floating point types in programs, especially in loops. The
function returns TRU E if the argument that was passed to differs from zero it
by more than TOLERANCE. Such a function can be useful when working

with floating point types. Because floating point types are subject to rounding
and representation inaccuracies, it is often more useful to check whether
two values are very close to each other, rather than whether the values are
identical — that is, whether their representations have the same bit patterns.
Such a "tolerance" test can be useful you have a loop where the
if
continuation condition tests strict equality of floating point types. For some
values, it's extremely unlikely that you will end up with identical bit patterns in
two floating point variables if you compute these values by different means.
Testing whether the variables are equal is, therefore, unlikely to produce
an affirmative response. The following program illustrates this. The first for
loop main program uses the non_zero( ) function to test for equality.
in the
This loop stops after three iterations. The next for loop looks for strict equality.
This version just keeps going.
_ val as the program
Use the QuickC Debugger to watch the value of test
executes, by setting debug to on in the compiler options before adding test _
val as a watch variable. The value is supposedly equal to that of VERY -TINY
at some point, but the loop keeps executing because the zero difference
reported was based on the precision you asked for, whereas the actual bit
patterns of the two values (that for test — val

and the value substituted for
VERY —TIN Y) are different. Thus, the loop passes the point at which it might
have been able to stop, and the program continues until you break out of it.
Notice two things about the way in which non_zero() is used in the
following program.
/* Program to compute values until two values are "identical."

Program illustrates dangers ot testing for exact equality when
using floating point types and shows advantages of using a
.
;; ; ; , ; ; ;
236 Using QuickC
function such as non.zeroO to test lor approximate equality.

•/
#deline VERY.TINY ,00000000027

#deline TOLERANCE l.Oe-12
#deline TRUE 1
#deiine FALSE
Int non.zero ( double val)
11 ( (( val - 0.0) > TOLERANCE) II ((val - 0.0) < -TOLERANCE))

return ( TRUE)
else
return ( FALSE)
>
main ()
{
double test.val;
double factor .03;
int non.zero ( double)
printf ( "Using non_zero\n")
for test.val - .00001; non.zero ( test.val - VERY. TINY)

*
(
test val factor)

printf ( "*/,20.161f; y.25.201f\n"
test.val. test.val - VERY.TINY)
printf ( "Testing for strict equality\n")
for ( test val - .00001; test val I- VERY.TINY; test.val *" fact
printf ( "%20.151f; '/.25.201f \n" ,
test val, test.val - VERY.TINY);
First, testing whether the value of test.val VERY TINY is non-zero is
mathematically equivalent to testing whether the two values differ from each
other by less than TOLERANCE. This means you don't need a separate
function to test for approximate equality of two arbitrary values.
The second point to notice about the use of the non zero( ) function is
its use in the for loop's continuation condition. Recall that non zero()
returns an integer: TRUE if the argument is non-zero, FALSE otherwise.
Recall also that the continuation condition is simply a true-false question. As
long as the program finds a true value when it tests the result of calling
non_zero( ), the loop continues. Once the difference between text val and
VERY_TINY becomes less than TOLERANCE, the function returns
FALSE and the loop stops.
Syntax: Old and New

If you look at existing C programs you will find that the non-prototype syntax
is used almost exclusively. It is useful to be familiar with this syntax, because
you may very well find yourself reading or revising existing programs.
If you have programmed in C, you are already familiar with this syntax;
switching over may be largely a matter of changing your habits. You'll need to
decide how quickly, and to what extent, you want to make the switch; 1 would
suggest you at least use prototypes and the corresponding function declarator
forms when you work with the programs in this book, to enable you to develop
the habit of programming effectively with the new syntax.
Those just learning C should use the prototype syntax right from the
start. Compilers that conform to the Draft Proposed ANSI Standard also
encourage the use of this syntax, as evidenced by the documentation for
QuickC and Microsoft C 5.0.

The prototype form also allows the compiler to do more checking of your
program, to catch errors such as incorrect function calls that might otherwise
go undetected.
Functions: Miscellaneous Points
If you are used to programming in a language such as Pascal, you may have
noticed that we haven't nested any functions inside of others —a practice
common among Pascal programmers. There no nesting of function defini-
is
tions in C. All functions are at the same "level." The most common ways for
functions to communicate with each other is by means of
• Function calls (possibly with no arguments)
• Parameters, which we've used only to pass information into a function

238 Using QuickC
• Global variables (kuown and modifiable by the entire program), which

allow information to move in or out
• return statements, which only allow information to be passed out of the

function
Our examples and discussion have been concerned only with int and
double variables, although C functions can also return other types, which will
be discussed after we've covered some requisite material.
Summary
in this chapter, we looked at the function prototype, a mechanism provided in
the Draft Proposed ANSI Standard. Function prototypes are essentially
elaborate function declarations that contain explicit information about
number and type of parameters, while specifying a return type or void.
By using function prototypes, the compiler is provided with the informa-
tion it needs to do much more extensive program checking than current
compilers provide. The concept of a function prototype is new to C, but it is
expected to become the standard style. We'll use the prototype form through-
out the rest of this book.
Scope, Lifetime;
and Storage Class 'I
3«
In this chapter you'll learn about the rules that determine when and how you Vii'
can use identifiers to refer to particular objects (memory locations) or func-

tions. You'll also learn something about what happens to values stored in a
variable when the program moves to a new context, such as a call to a different
function.
Scope and Visibility
Crecognizes identifiers (such as those for variables, functions, and macros) as

valid only in certain parts of a program. Similarly, a memory location may be
accessible only in certain functions. The next listing should help raise several
key issues as well as provide an introduction to some new terms. Although it's
239
. ;
; , ; ; ;
240 Using QuickC
long, the program does little but display a lot of information. Work your way
through it, pay attention to the names being used (identifiers) and the values
being displayed, along with the location of each variable definition. Notice
what happens to int val in different parts of the program. Compare this with
what happens to int_val2 in the same program portions.
/* Program to print values of several variables at different points in

the program
Program illustrates issues related to scope and visibility.
*/
int int.val = 10; /* global definition */

int int_val2; /* global definition •/
main ()
int result; /* local definition */

int inner_fn ( void); /» function declaration */
void outer_fn ( void) ; /* function declaration */
int_val2 =20; /* assignment to global */
printf ( "in mainO, before inner.fnO : int.val == '/.d\n" int. val)

. ;
printf ( "in mainO before inner.fnO:

. int_val2 == "/.dVn" int.val2)
.
result = inner.fn (); /* should see changes in int_val2 */
printf ( "\in mainO , after inner.fnO: result == '/.d\n" result);

,
printf ( "in mainO , after inner.fnO: int.val == XdNn" int.val)

,
printf ( "in mainO , after inner.fnO: int.val2 == '/.dVn" int_val2)

,
outer. fn O; /* should see changes in both globals */
printf ( "\in mainO after outer.fnO

. int.val == : */.d\n" , int.val);
printf ( "in mainC) after outer.fnO: int.val2 ==
. '/,d\n". int_val2)
/* show consequences of using same identifier both globally and locally.

Function name comes from fact that the function uses a local (inner),
rather than global (outer) object.
•/
int inner.fn O
{
int int.val = 5; /• local definition; hides global name */
printf "\n*** in inner.fnO. (local) int.val •- XdNn"

( int.val): ,
printf "*** in inner.fnO, before assignment, int.val2 -- '/.dNn",

(
int.val2)
int.val2 = int.val; /* global gets value of local */
printf ( "*** in inner.fnO, after assignment, int_val2 =» '/.dXn"
int.val2)
return ( int.val)
, ; . , , ,
Scope, Lifetime, and Storage Class 241
/• Function name comes from fact that the function uses global (outer),
rather than local (inner) objects.
•/
void outer_fn
<
printf "\n*** in outer.lnO before assignment. int_val == '/,d\n"
( .
int.val) ;
printf ( "*»* in outer_fn() before assignment, int.val2 == '/.dXn"

,
int_val2) ;
int.val « 30; /• global variable being changed »/

int_val2 * 60; /* global variable being changed */
printf ( "*** in outer_fn() after assignment, int_val == '/.dXn"
,
int_val) :
printf ( "••* in outer.fnO , after assignment. int_val2 == '/.dXn"
int.val2)
in mainO. before inner_fn(): int_val == 10

in mainO. before inner_fn(): int.val2 == 20
** in inner_fn() (local) int_val == 5

.
in inner_fn() before assignment. int_val2 == 20

"
.
*** in inner.fnO. after assignment. int_val2 5
in mainO, after inner_fn() : result

in mainO, after im>er_fn() int.val == 10
in mainO after inner_fn()
, int_val2 == 5
*•* in outer.fnO. before assignment, int_val =- 10
*** in outer_fn() before assignment, int_val2 == 5
*** in outer_fn() after assignment, int_val 30 =
*** in outer_fn(), after assignment, int_val2 == 60
in mainO, after outer.fnO : int.val == 30

in mainO, after outer_fn() : int_val2 == 60
The program involves four different variables, but only three variable
identifiers, because one name (int_ val) is used for variables in two different
places. To distinguish between each use, we need to look at the scope and
visibility of the variables. The scope of a variable is the range of contexts in
which the variable can be used. The visibility of an identifier is the range of
contexts over which the identifier is valid and refers to the same object.
Let's look at the variable result first. This local variable is declared in the
function body of main( ). (Local variables are those defined within a function
or block, as opposed to the global variables defined outside any function.)
Within this block, the identifier result refers to a particular object, or area of
memory. The and its associated area of memory are unknown
identifier
elsewhere in the program such as within function inner fn( ). Thus, if you
tried to use result in inner fn( ), you would get an error message about an
unidentified variable.
242 Using QuickC
•'REMEMBER The scope of a local variable (that is, one defined within a
function or block) is from the declaration point to the end of the function or
block.
The variable int vaI2 has a different scope. This variable is defined
globally, that is, outside of any function. Both inain() and inner fn() can
refer to int val2 and can use the value stored in this variable. In fact, both
functions change the variable's value.
The scope of a global variable (that is, one defined outside any function)
extends from the declaration point to the end of the source file. In this
instance, source file refers to both the actual file containing the definition and
any files that C reads because of an #include preprocessor directive after the
variable definition.
Now, let's look at the variable int val defined inside inner fn()— a
local variable, according to syntax. By our first rule of scope, this variable
should be accessible only within function inner fn(). This seems to be the
case, since the value of 5 for int val occurs only inside that function.
What about the global int val — that is, the variable defined at the top of
the program? According to our scope rules, this variable should be known
throughout the program. A look at main() and outer fn() supports this
conclusion.
But what happens to the global int _ val in inner fn( )? We just saw that
the local int val rules here. Does this mean the global int val does not have
any scope here? If so, this would violate our second rule.
As it turns out, both int vals have scope here. However, the two vari-
ables differ in visibility. The local int val has greater visibility, meaning that
the identifier in inner fnl is interpreted as referring to the memory location
associated with the local variable. Because of this, the local variable's identifier
is said to hide the outer identifier. This is why the memory location corres-
ponding to the local int val, rather than the location of the global int val,
gets changed in the function.
Let's look at an example in a different context. Suppose your name is

Dennis Ritchie. If I were to ask one of your friends, "What language is Dennis
Ritchie working on?" they might tell me "English," or "French," or "Latin."
Your friends would probably not refer to the Dennis Ritchie who developed C,
unless asked explicitly about that Dennis Ritchie.
On the other hand, if I were to ask, "What language is the guy who
invented C working on?" they might tell me. "D." Both you and the "guy who
invented C" have the same name, and can get information about both of you.
I
Both you and the other Dennis Ritchie fall within the scope of my conversa-
tion. Locally, among your friends (in your block, so to speak), you have greater
visibility, so that when I use the name Dennis Ritchie, people assume I'm
asking about you.
I were to ask about Dennis Ritchie's new lan-
Suppose, however, that
guage at AT&T 1 would almost certainly get an answer about the
Bell Labs,
Dennis Ritchie who invented C. At AT&T Bell Labs, that Dennis Ritchie has
greater visibility than you do. In fact, your scope may not even extend to the
labs. Very possibly, people would not recognize my references to you
at the labs
when I asked about your new language. Thus, at AT&T Bell Labs, the Dennis
Ritchie who invented C has greater scope and visibility than you.
In the program example, both int val variables have scope in function
inner fn( ), but only the identifier for the local variable has visibility. If you
could find a different way of referring to the object associated with the global
name int _ val, you might be able to manipulate its value in function
inner _val().
Parameters and Scope

You've already learned the mechanism for doing this, although we haven't
discussed it in these terms. Parameters, as we've seen, provide slots for passing
information into a function.
When you specify a formal parameter for a function, the program allo-
cates storage for a value of the specified type, and associates the name you
provide with this storage. When you call the function with an actual parame-
ter, program takes the value you pass (or the value associated with the
the
variable you specify as the argument) and stores this value in the memory
allocated for the corresponding formal parameter. Let's look at an example:
/* Program to Illustrate scope of variables.

and also to illustrate how to get information from a variable
function by means of parameter values.
*/
main ()
<
void inner_fn ( int);
lnt.val2 - 20;
printf ( "at start of mainO . int. val (at V.u) -= '/,d\n"
ftlnt.val. int_val) ;
; ;
; , .
244 Using QuickC
printf ( "at start of mainO, int_val2 (at '/,u) == '/.d\7i"

ftint_val2, int_val2)
inner.f n ( int.val) ; /* should get changes in int_val2 */
printi "\nin mainO after inner.fnO: int.val (at '/.u) == '/.dVn"

( ,
4int_val, int_val)
printf ( "in mainO, after inner.fnO: int_val2 (at '/.u) == '/.d\n"
tint.val2, int.val2)
/* change one global and one local variable. »/

void inner. fn (int param val)
{
int int.val = 5;
printf ( "\n*** in inner.fnO, param.val (at 7.u) == 7,d\n",

ftparam.val, param.val);
printf ( "*** in inner.fnO, int.val (at '/.u) == '/,d\n",
ftint.val, int.val):
This program produces the following output, including address locations for
the variables in the program.
at start of mainO, int.val (at 218) == 10

at start of mainO int.val2 (at 1680) -= 20
,
*•* in inner.fnO, param.val (at 4226) == 10

•*• in inner.fnO. int.val (at 4220) == 5
in mainO, after inner.fnO: int.val (at 218) =" 10

in mainO, after inner.fnO: int.val2 (at 1680) == 20
The program is similar to the preceding one in that it prints the values of
several variables to illustrate points about scope and visibility. In addition, the
program prints the addresses of the variables involved, to make it easier to see
the relationships among value, memory locations, and names.
Notice the value stored inparam __ val, the object associated with the
formal parameter of that name. It is the same value as that stored in the global
variable, int _ val. When inner _fn( ) is called with an actual parameter, the
actual parameter passed by value. When main() called inner_fn(), with
is
int — val as argument, the program passed the value stored at memory loca-
tion 218 (in our program run) into the storage area set aside for param _ val
(location 4226, in our run). Because of this call by value, the actual contents of
the global int_val are not changed in any way by this function call.
We've passed the information contained in int _ val into the function
inner — fn() through the slot created for this purpose. As such, we've taken
advantage of the fact that inner _fn( ) is within the scope of a global variable
in order to get information from this variable into the function. Once the value
has been passed inside, the function can do what it wants with the value,
without the calling routine knowing about it or being affected by it. The same
value is now contained
two different objects, as you can see by the addresses
in
of the two objects (218 and 4226, for actual and formal parameters, respec-
tively). Thus, the use of formal parameters is a means of getting around
visibility restrictions, at least in one direction.

you try to use param_val in main(), you will get an error message
If
about an undefined variable. This is because the scope of the formal parameter
does not extend to other functions.
^REMEMBER The scope of a formal parameter declaration is from the

declaration point to the end of the function's body.
Note also that the global and the local int_val identifiers refer to two
different memory locations. In the previous program, we saw how visibility
influences the use of identifiers when referring to objects. This program

provides more information on what is happening, namely, the use of different
addresses for different objects having the same name.
Macro names and manifest constant identifiers, both associated with the
preprocessor, also have a scope and visibility rule associated with them. These
identifiers are active from their declaration point until the end of the source
file, or until they are #undefd.
^REMEMBER The scope of a preprocessor identifier (manifest constant or

macro name) from the point of declaration to either the end of the source
is file
or the appearance of an #undef instruction for the identifier.
Defining Variables
Within Blocl(S
So far, we've defined variables globally or at the beginning of a function.

Recall that the function body is essentially a compound statement, or block. In
C, you can actually define a variable at the beginning of any block. The scope
of such variables is from their declaration until the end of the block in which
; ; ; ;; ; ;
246 Using QuickC
they were declared. The following listing illustrates this, and displays the
values of the variables at each level of the program:
/» Program to illustrate definitions within arbitrary blocks;

program also illustrates visibility of identifiers.
Note that each call to printfC) is numbered.
This will make it easier to compare the output with the printfO calls.
int val =0; /* global definition */

int val2 = 0; /* global definition */
main
<
int val =1; /* local to main () */
void other_f n ( void)
printf ( "1: val == '/.d; val2 = y.d\n". val. val2) ;
other_fn()
printf ( "6: val == Xd; val2 - '/.d\n", val. val2) ;
void other fn ()
{
int val2 - 2; /* local to other.fn () */
void yet_another_fn ( void)
printf ( " 2: val == '/,d; val2 = */,d\n" , val, val2)
{ /* arbitrarily defined block */

int val -3; /* local to block inside other_fn() */
printf ( " 3: val == '/.d; val2 = '/.d\n" val, val2)
.
yet_another_fn ;
} /* end arbitrarily defined block */
printf ( " 5: val " '/.d; val2 = '/.dXn" , val, val2)

> /• END of other.fnO */
void yet another fn ()

{
printf ( " 4: val == '/.d; val2 = */.d\n", val, val2)
1: val == 1: val2 -
val »- 0; val2 = 2
2:
3: val =• 3; val2 = 2
4: val "
0: val2 -
5: val —
0; val2 = 2
6: val —' 1; val2
This program simply displays the values stored in the variables val and val2.
The different values are due to the scope and visibility rules that apply when
printf( ) is called. The indentation in the program indicates the "depth" of the
call, while the number at the start of each line indicates the source code Hne.
There are two cases to look at: what happens with identifiers within
functions, and what happens with identifiers across functions. Let's look at the
situation in other fn( ) first.
This function includes a local variable, val2, whose scope is from the
definition to the end of the function. Any reference to val2 inside other fn( )
is a reference to the storage allocated for the local variable. This is why calls 2,
3, and 5 to printf( ) all have the same value for val2. Notice the reference to this
variable in call 3 to printf( ). This call is just an ordinary statement inside the
function, as far as references to val2 are concerned.
The situation is somewhat different for references to val. An arbitrarily
defined block inside function other fn() includes a local definition of val.
The scope of this variable extends from its definition to the end of the
block —right after call 3 to printf(). The three calls to printf() in function
other fn() behave differently, because the identifier val has two different
visibilities in this function.
An identifier, such as val, applies within a function, unless a new variable

with the same name is defined, in which case the original variable would be
hidden by the new one. Thus, in other _fn( ), the global val has both scope and
visibility in calls 2 and 5 —that is, before and after the arbitrarily defined
block. Within the block, however, the greater visibility of the local val hides the
global name.
Notice that call 4 (in yet — another _fn( )) uses the global values for both
val and val2. There are no local variables defined in yet another — fn().
Therefore, when this function is called, it looks for any global objects that
might correspond to identifiers used in the function. Even when called by
other _fn(), yet_another_fn( ) does not use the calling function's objects,
because the scope of those objects does not extend into other functions. Only
global variables can be used directly across functions, although we have seen
that passing parameters by value provides a mechanism for using the values of
local variables across functions.
Using Debug
A big advantage of QuickC's environment is that you can do many different
things with yourprogram file. You can use QuickC's debugging facility to step
through the preceding program slowly, in order to study the source code as the
program produces its output. QuickC's debugger allows you to look at more
than just your selected watch variables. You can, in addition, use this capability
248 Using QuickC
to distinguish the different versions of val and val2 — by looking at the values
stored immediately after the watch variables. This should work since it's
unlikely that two different variables will be followed by the same values. To do
this,
1. Call QuickC with the program file.
2. Type CTRL-D, then C, to clear any breakpoints you might have set in
the program.
3. Type CTRL-D, then L, to clear any watch variables you might have
specified in the program.
4. Type CTRL-R, then C, to get the compiler options.
5. Select the Debug option, if you haven't already done so. Then press
RETURN to compile the program with the debugging option on.
6. Type CTRL-D then RETURN

, , to add a watch variable. Enter val,d2d as
the variable to watch. This says to display the value of val in decimal
format, and also to display the contents of the four bytes following val,
as int values.
7. Type CTRL-D , then RETURN , to add another watch variable. Enter

val2,d2d as the second variable to watch.
8. Use the CTRL-D, B sequence to set breakpoints at each of the calls to
printf( The cursor must be on the line where you want to set the
).
breakpoint when you select this compiler option. You will set si.x such
breakpoints in all.
9. Type CTRL-R, then RETURN, to start the program.
10. Use the F5 key to move to the next breakpoint when you're ready.
Study the changes to val and val2 in relation to the breakpoint's
location in the program.
On a sample run, this produced the information in the following illustra-

tion, which shows the values of val and val2 as well as the values stored in the
four bytes following each of these variables.

)
printf (
: ;
250 Using QuickC
^REMEMBER Local variables have automatic storage duration, unless you

specify otherwise. Formal parameters always have automatic storage duration.
For variables with automatic storage duration, a new area of memory is

allocated each time the variable is defined (when the function is called, for
example), and this object is discarded after the block ends in any way, whether
normally or after a break or return, for example.
Variables with static storage duration are defined and initialized once
(essentially, when the program begins executing), and such variables retain
their values (unless changed explicitly) while the program is executing. Global
variables have static storage duration. Functions (but not necessarily their
variables) are also said to have static duration storage, since the information
needed to execute a function is always available in a program.
^REMEMBER Global variables and functions have static storage duration.
Don't confuse storage duration and scope. Scope determines when you
can refer to a variable; scope says nothing about whether there is anything
stored in the object. Duration determines how long a value will be stored;
duration says nothing about whether the variable can be called at a particular
point in the program. If a variable has a static lifetime, then, at any point in the
program, the memory location allocated for the variable will contain the last
value assigned to the variable. You will only be able to access this information if
the variable's scope extends to the program portion where you want to access
it.
In the following listing, try to determine the identifiers with automatic

storage duration and those with static duration.
/* Program in which to count the number of local and global identifiers. */
int gl, g2. g3;
main ()
{
int gl, g2, g3, g4;
printf ( "hello\n")
}
another ( int pi, int p2) /* Prototype form of declarator. */
int gl, g2;
printf ( "another helloNn")

}
You should have come up with five identifiers (gl, g2, g3, main, and
another) with static storage duration, and seven (including pi and p2) with
automatic storage duration. The three global int variables have the static
duration. Remember, functions have static duration and parameters have
automatic duration. The fact that the same identifers (for example, gl) are
used in several places doesn't have any influence on the storage duration.
Using the same identifier will only affect the visibility of the identifier.
Storage Class
The lifetime of a variable specifies how long the variable's value will be around.
Ordinarily, the values for local variables will simply disappear after the func-
tion is done. Sometimes, however, it can be useful to keep a value around for
use the next time the function is called. In terms of our discussion so far, such a
variable has a somewhat ambiguous status. On the one hand, you want the
identifier's scope to be local, which implies an automatic storage duration. On
the other hand, you want the variable to retain its value for use the next time
around. Thus, you want a local variable with static storage duration.
Another situation that may arise is when a particular variable is used very
often (in a loop, for example). If the variable is stored in ordinary memory, it
can be time consuming for the program to access the variable each time. C
provides a means of suggesting that frequently used variables be put in special
registers, for faster access.
C's storage class specifiers gives you influence over how and where a
variable is to be stored when the program is executing. In this section, we'll
look at the storage class specifiers available in C, and you'll learn about some
of their properties.
Static
The static storage class specifier makes it possible to define a local variable
whose value continues to exist after the function has finished —so that the
most recent value of the variable can be reused the next time the function is
called. The following listing shows the syntax for such a specifier:
/* Program to count by 2 irom 2 to 40.

Program illustrates use of static storage class speciiier to keep
; ;
252 Using QuickC
a value around even while the function is not active.

*/
/* this function does the actual counting. */

void count_by two ()
{
/* NOTE: The static variable il is automatically initialized to */
static int il; /* keep this value around, use next time +/
/* line */
/* get next value when counting by 2 /
il += 2; /* line 1 */
if ( il % 10 == 0) /* to format output, 5 values per line */
printf ( "'/.SdVn", il) ;
/* line 2 */
else
printf ( "'/.5d", il); /* line 3 */
}
main ()
{
#deline MAX_COUNT 20
int c ount
void count_by_two ( void);
/* each call to count_by_two() gets the next even number */

for ( count = 1; count <= MAX.COUNT; count++)
count_by_two () /* line 4 */
22 24 26 28 30
32 34 36 38 40
This program prints the even numbers from 2 through 40, five numbers per
line. The main program loop is in inain( ), but the value being written is local to
count _ by _ two( ).
The following illustration shows the state of the various program vari-
ables during the first few iterations through the loop in inain( ).
After iine il if statement
(0) (???)
true
2 false
2 false
(2) (???)
2 false
4 false
4 false
(4) (???)
4 false
6 false
6 false
After line
254 Using QuickC
with storage class static. You can also use the static storage class specifier with
global variables. Global variables already have static lifetime and global scope,
so why would you want to use the static specifier? To answer this question let's
first consider the ways in which you can incorporate variables and functions
into your C programs.
First, you can put an#include preprocessor instruction into the program
source file and have the compiler read the contents of the file to be included
during the compilation process. The other way is to link a precompiled file
with your compiled program file, in the process of creating your executable
file. You might do this by linking in a function library that you have developed
or acquired elsewhere (without source).
When the compiler reads an included file, it makes any functions and
needed global variables in that file available throughout the rest of the pro-
gram. Because you are working with source files, you can easily check whether
a global identifier you want to use is also used in the included file —to avoid a
duplicate definition error.
When you link a precompiled file into your compiled you also make
file,
any functions and global variables in the linked file available to the program,
in this case, however, you may not be able to check what identifiers are used in
the linked file. Since you don't have the source, if your program and the linked
file each use the same name for a global variable, you will get a linker error.
To avoid this problem, you must use the static storage class specifier with
the global variables in the linked file. By defining these variables as having a
static storage class, you make them inaccessible to the linker. This means the
variables become "local" to the linked file. Whenever functions from the
linked file are called, they use the values specified in their file for these
variables; whenever your functions are called, they use the values specified for
your global variables.
For example, suppose I have two files, and prog.c. The main
utils.c
program and the functions unique to a particular program are in prog.c. The
file utils.c contains general utility functions that may be used by various
programs.
Suppose I have the following definition at the top of utils.c:
int test_count = 300.
Similarly, suppose 1 have the following definition at the top of prog.c:
inL test_count = 10;

If the compiler reads the contents of utils.c while compiling prog.c, the
duplicate definition causes a compiler error — regardless of whether either
definition was specified as having static storage class.
If I compile utils.c to an object file, and then try to link this with the
prog.obj object file to create an executable file, the linker will report the
redefinition as an error. On the other hand, if I give the definition of test
count in utils.c static storage, and then create a utils.obj object file, the linker
will not report an error.
You can also use the static storage class specifier to modify a function
declarator. By specifying that a function definition has static storage class, you
are making the function inacessible to the linker. This means your programs
cannot use the function directly, but functions in the file containing the
function definition can use it. This capability is very useful for making libraries
more modular in a process often referred to as information hiding. Your
program is aware only of the library routine it needs to access, rather than of
each of the smaller functions the library routine uses to perform the task. In
this way, you can concentrate on what the library routine does, rather than on
how it does it.
auto storage class

Just as the static specifier allowed you to make the lifetime of a local variable
static, the auto storage class specifier lets you make it automatic. This specifier
can only be used in definitions at the top of a block. Thus, you can't specify a
global variable with auto storage.
you don't include a storage class specifier for a local variable, the
If
compiler assumes auto storage by default. For this reason, you will rarely see
the auto specifier used explicitly. You might use this specifier when you are
deliberately using the same identifier as a global variable, and want to call
attention to this fact.
^REMEMBER In the absence of a storage class specifier for a local variable,

the compiler gives the variable automatic storage. Variables with auto storage
class are not initialized automatically.
register storage class
The register storage class specifier also specifies an automatic storage dura-
;: :
256 Using QuickC
tion; in addition, this specifier suggests to the compiler that the variable be
stored in machine registers for faster access.
Generally, only integer type variables, such as char and int, can be given
register storage. The number of registers and the types that can be given any
available register storage will depend on your implementation. QuickC and
Microsoft C 5.0 will give a variable register storage, if there is a register
available and if the variable is of the appropriate type, int.
The register storage class is only a request, not a command. If the

compiler is unable to comply with the register storage request, the variable
becomes an auto. Register variables are not initialized automatically. Because
there is no way of knowing whether the compiler can give the variable register
storage, you cannot use the address operator (&) with variables you want
stored in registers.
^REMEMBER You may not use the address operator (&) with register
variables.
The following listing illustrates the syntax for the register storage class:
/* Program to test relative speed ol functions defined with

or without the register storage class specifier.
Program illustrates syntax for register storage class specifier.
main ()
void countl ( void) . count2 ( void) ; /* prototype declaration */
countl ;
counts ();
/ No register variables. */
int r_sura
int index
while ( index++ <= 20000)

r_Buni +« 1
void count2 () /* Uses register values. */

<
register int r_sum = 0; /* ask for fast-access storage */
register int index 1 /* ask for fast-access storage */
while ( index++ <= 20000)

r_sum +
1
The two functions perform the same task, but one of them uses register
variables. When these two functions were timed, count2( ) took between one
third and two thirds as long as countl() to perform the same task. The
differences were due to the faster access to values stored in register variables.
You can also suggest formal parameters for register storage. To do this,
simply put the keyword register before the type specifier in the function
declarator. The following function declarator illustrates the use of register
storage class specifier with formal parameters:
double timing ( register double val , register int how_many)
This declarator asks the compiler to store both formal parameters in
registers. As with other local variables, the compiler may or may not comply
with your request.
extern storage class
When you define a global variable, its storage class is extern. This means the
identifier and its associated object are accessible to any functions after the
declaration, in the same file or in any files read because of an înclude
instruction. Global variables have static storage duration. Such variables are
also accessible to the linker, unless you hide them by using the static storage
class specifier.
You may want to use a global variable — defined in one file — in a func-
tion defined in another. If the second file is read after the file in which the
global variable is no problem. If, however, you want to use a
defined, there is
variable before it has been defined, you need to warn the compiler that a global
definition will be available somewhere else. If the variable has not been
defined, and you have not declared it, the compiler will complain about an
undefined variable.
To avoid such an error, use the extern storage class specifier The follow-
ing listing illustrates this. (Note that this example is not a good one to follow
for your own programs. It's generally a bad idea to define your global variables
somewhere in the interior of a file. You're much better off, in most cases, just
putting the variable definitions before the variable is used.)
/* Program to illustrate use of extern storage class specifier to

"predeclare" a variable. After it sees the extern ... declaration, the
compiler knows that a definition of the variable will be forthcoming.
Program sequence is used merely to illustrate the consequences of
not declaring an external variable that hasn't been define.
It is generally bad programming practice to put global definitions in
258 Using QuickC
the middle or at the end of a source file.

*/
main ()
{
extern int val; /* extern needed because val not yet defined */
printf ( "%d\n*' , val) ;
int val =12; /* global definition of val */
In this program, the variable val is declared at the end of the source file,
but is used earlier, by the function main( The first statement in inain( ) is a
).
variable declaration, not a definition. The compiler does not allocate any
when the compiler sees this line.
storage for val Rather, the compiler warned
that somewhere else there is a definition that allocates storage for an int
variable named val.
If inain( had consisted only of the printf( ) statement, with no declara-
)
tions, the compiler would have generated an undefined variable error. On the
other hand, if the keyword, extern, were not included in the declaration, the
compiler would have treated the line as a local variable definition, and val
would have been uninitialized.
It is sometimes a good idea to declare global variables at the top of
functions that use the variables. The extern storage class specifier makes this
possible. The explicit declaration is a safeguard, rather than a necessity, if the
function falls within the scope of the global variable. The declaration indicates
that a global variable is being used and is, therefore, a form of documentation
for your code.
Use the extern storage specifier if you are using include files that share
global variables. Many programmers define the global variables at the top of
the main source file, and then declare the variables at the top of each included
file —using the extern storage class specifier in each of these declarations. The
extern specifier prevents the compiler from allocating a second set of storage
locations for the variables, and also avoids a duplicate definition error. By
declaring the global variables in this way, you again provide a certain amount
of documentation by making explicit the fact that your code uses variables
defined elsewhere.
Default Storage Classes

and Storage Durations
Ifyou don't specify a storage class for an identifier, the compiler makes default
decisions depending on where the variable is defined. There is a general
correspondence between storage class and default storage duration. Certain
storage classes are also restricted in the scope they can have.
Local variables and formal parameters are, by default, assumed to have
storage class auto, and automatic storage duration. You can give local vari-
ables (but not formal parameters) static storage duration by using the static
storage class specifier. Global variables and all functions are assumed to have
storage class extern and static storage duration. Functions cannot have an
automatic storage.
Variables with register or auto storage classes always have automatic
lifetimes. Such variables are always local to a function or to a block within a
function. Variables with static and extern storage classes have static storage
durations. Variables with extern storage class are always global. Variables with
static storage class may be global or local.
Table 9. 1 summarizes the relationships among storage class, lifetime, and
scope of a variable.
Table 9-1. Storage Class, Lifetime, and Scope of a Variable
Storage Class
260 Using QuickC
The typedef Storage Class

The typedef specifier differs from the other storage class specifiers in that it
does not explicitly specify a storage class. Instead it is grouped with the storage
class specifiers largely for syntactic convenience, according to the Draft Pro-
posed ANSI Standard.
Also the typedef specifier does not actually define a new information type,
as its name might suggest. No storage is allocated when you create a typedef.
Rather, the specifier lets you provide a synonym for an existing type identifier.
This can be useful when you're writing programs for specific applications,
where specific vocabulary may make things clearer. The following examples
illustrate the use of the typedef specifier:
/* Examples of typedef specifications.

In no case is a completely new type actually defined.
*/
typedef double distance; /* make distance synonymous with double */

typedef double profit; /* make z_score synonymous with double */
typedef int whole_nr, integer; /* make these synonymous with int •/
To create a synonym for an existing type, you need to preface the defini-
tion with the keyword typedef, then the type you want your new type to
represent (for example, double), and finally the new type identifier (for exam-
ple, progit). Note that the typedef simply associates a type identifier with an
existing type. You can use typedef to create either global or local types.
The first of these typedef specifications defines distance as a synonym for
double. Once you've specified the new type identifier, you may use it in variable
definitions such as the following:
/* Example variable definitions,

once new type identifier has been specified.
*/
distance nr_miles. nr_kilometers; /* declare 2 variables of type distance */

static distance miles_E0_f ar; /* static variable of type distance */
distance km_per_tank ; /• function returning distance */
The compiler will allocate storage when it sees these definitions. The amount
of storage allocated will be the same amount as would be allocated for a
variable of the underlying or base type.
Notice that once you have defined a new type identifier, you can use the
other storage class specifiers in conjunction with your new type identifier, as in
the example declaring a static distance, miles so far. You can even define
or declare functions that return a value of the specified type, as in the function
declaration, km per tank, given above.
Thus, the typedef specifier allows you to specify new names for existing
data types. These names can help make programs easier to understand, by
making the program's language fit the content area, rather than imposing the
C language's vocabulary on your content.
Although our typedef examples so far have involved simple types, you can
use typedef to create synonyms for more complex types as well, including
arrays (groups consisting of elements that are logically related) and other
structures. In fact, some of the types that we'll be using later, such as the FILE
type, are actually names for more abstract types.
Summary
and status of
In this chapter, you learned about the concepts related to the use
C variables and functions, in particular, you found that scope and visibility
rules concern the range of program contexts over which an object or an
identifier has meaning. You also learned about the concept of storage dura-
tion, which determines the lifetime of a variable value in a program. Finally,
you looked at the storage class specifiers C provides, allowing you to influence
the lifetime and scope of variables and functions. One of these, the typedef
specifier, permits you to create identifiers that are synonymous with existing
types.
In the next chapter, you'll move into the use of pointers, which are, in
many ways, the real core of the C language.
; ;
Pointers
So far, we've referred to variables directly by name. We've used the variable's
identifier to refer to information stored at a particular memory location — the
location associated with that variable name. The location and the value of a
variable are not the same, as shown in the following program:
^'i
/* Program to display values and addresses of variables. */ ;
| Uj
main ()
{
int 11 - 100. 12 - 101;
double dl - 100.0. d2 = 101.0;
float fl = 100.0. f2 = 101.0;
printf ( "Narae\t Value\t\tAddress\n\n")
/* display information about int variables */

printf ( "il\f/,10d\t\f/.7u\n». il. til);
printf ( "i2\ty.lOd\t\t'/.7u\n\n\n". 12. 412):
/* display information about float variables •/

printf ( "fl\ty.l0.51f\t\t%7u\n", fl. if 1) ;
printf ( "f2\t'/.10.5f\t\ty,7u\n\n\n". f2, tf 2) ;
/* display information about double variables */

printf ( "dl\t'/.10.51f\t\ty.7u\n". dl 4dl);
,
printf ( "d2\ty.l0.51f\t\ty.7u\n\n\n". d2. td2)

}
263
264 Using QuickC
When compiled and run, this program produces the following output on
one system:
Hams
Pointers 265
In this section, we'll look at the difference between these two aspects of an
object. Let's look at an example where we have statements that use both the
location and contents of objects.
/* Program to provide examples for discussing difference between a

variable location and its value.
*/
main
<
unsigned int il • 500, i2 = 300;
il - 100; /« 1 •/
12 - il; /* 2 */
printl ( "il - y.5u; 12 = y,5u\n" , il, 12); /» 3 */
12 - 11 + 2; /* 4 •/
il++; /• 5 •/
prlntf ( "11 - '/.5u; 12 - y.5u\n" , il, 12); /* 6 »/
>
In the first assignment statement, 1 , we are assigning the value 100 to the
int variable, il. In this instance, we want the location of il, not its value. It
doesn't make sense to say that, "500 is assigned the value 100." It does,
however, make sense to say, "The value 100 is assigned to (the location of)
variable il."
Let's look at statement 2, which has two variables. Again, at least i2 must
be interpreted as referring to the variable's location, rather than to the value
stored in the variable. In this case, it's meaningless to say, "300 is assigned the
value 100."
It makes more sense to say, "The value 100 is assigned to (the location oO
variable i2," just as in our earlier example. Notice that C treats il as a value.
But this means we're treating il and i2 differently in this statement.

The difference between the two variables in statement 2 is due to the way
in which the assignment operator does its work. Essentially, this operator
carries out the following actions:
1. Determines the value of the right operand (the right side of the
assignment statement). This may be an expression, including a

variable.
2. Goes to the location of the left operand ( because something is going to

be assigned to that location).
3. Stores the value of the right operand in the location of the left
operand.
266 Using QuickC
The left operand

in statements 2 and 3 must be a location, because of the
assignment operator. The right operand, on the other hand, must be a value,
since that's what the assignment operator needs to put into the left operand.
Variables whose locations are needed, in order to do something at those
locations, are known as lvalues. Historically, the "1" referred to "left," because
lvalues often appear on the left side of assignment statements. By the same line
of reasoning, the right operand of the assignment statement whose value, —
rather than location, was of interest —
is sometimes called an rvalue. The
Draft Proposed ANSI Standard suggests "locator value," instead of "left

value" as an elaboration of "lvalue." In the proposal, the right operand of an
assignment statement is just referred to as the "value of the expression."
Statement 4 is similar to statement 2, except for the constant being added
to the value of il before assigning the sum to i2.
What about statement 5? There isn't really a left and right operand here
because the increment operator only takes one argument. The il in the
expression is still an lvalue, however, because the operator eventually changes
the contents of some location (the location of il). This may be clearer if you
think of the increment operator as equivalent to the following assignment
being made at the proper time (depending on whether the operator is prefix or
postfix). In this form, the need for an lvalue is clear.
The address operator also needs an lvalue as its operand. When the
address operator is applied, it essentially does the following:
1. Goes to the "home" of its operand
2. Determines the address of this home

3. Returns this information
While it makes sense to ask about the address of a variable's location,

asking for the address of, for example, 100, is meaningless.
Thus, there are three places where lvalues are required: left operand to
the assignment operator, operand to the increment and decrement operators,
and operand to the address operator.
; ;
Pointers 267
^REMEMBER An means that the

lvalue refers to a "locator value." This
location of the object, rather than its value, is of interest. The simple and
compound assignment operators require an lvalue as the left operand. The
increment and decrement operators, and the address operator, also require
lvalues as their operands.
Pointers
A.pointer is a variable whose value is an address. There, a pointer is a variable

that refers indirectly, or points, to another variable. The pointer's "target
variable" is the variable at the address stored in the pointer. Let's look at an
example. The following listing introduces some notation and syntax, and the
diagram after shows conceptually what the relationship
it is among pointer
and target variables, and the values stored in each.
/* Program to illustrate pointers, target variables, and contents of each */
main ()
int target; /* variable of type int •/

int *ptr; /• pointer to variable of type int */
target "23; /* store arbitrary value in target */

ptr " ttarget; /* store address of target in ptr. •/
printf ( "address of target 51u; contents of target %d\n".
ttarget, target);
printf ( "address of ptr y,u; contents of ptr y,u\n",
tptr, ptr)
printf ( "contents of variable to which pointer is pointing '/,d\n"
•ptr)
This program produces an output similar to the following depending on the

system on which the program is run:
address of target 4094; contents of target - 23

address of ptr 4096; contents of ptr » 4094
contents of variable to which ptr is pointing 23
Before we discuss the summarize the program's

notation and syntax, let's
actions, and then look at a diagram of what's going on. The program involves
two assignments and three calls to printf( ). The first assignment, target = 23, is
268 Using QuickC
just like the other assignments we've seen. On the surface, the second assign-
ment, ptr = &target, also looks equivalent. The mechanics of the assignment
do, in fact, work like the other assignments we've seen. The result is that the
address corresponding to target is stored in ptr. There are important differen-
ces, however, as we'll see.
The following diagram shows the state of memory after each assignment,
and then matches the arguments to the printf( ) calls with the appropriate
component in memory.
(a)
Pointers 269
Part (e) is different, however. As from the output, the value

you'll notice
that is written is 23; this is also the value of target. The call to printf() says,
essentially, "Write the message, then write the contents of the variable pointed
to by ptr." Think of the evaluation process for this display as going through
steps such as the following:
1. Get to the location of ptr (4096, in our case).
2. Determine the contents of this variable (4094, in our case), and

interpret those contents as an address.
3. Get to the location specified by this address — that is, to the variable to
which ptr is pointing.
4. Determine the contents of this variable (23, in our case), and write
them.
In the preceding diagram, notice that target has two names after assigning
the address of target to ptr. Until now, all the references to variables that we
wanted to display have been direct references, in which the variable was
referred to by name. The variable represented as *ptr is an indirect reference to
a particular value. *ptr is "the value referred to, or pointed to, by ptr." Because
it's awkward to speak of "the value pointed to by the pointer"all the time, we'll
use "the pointer's target value" to refer to such values.
You can think of a pointer as an address. When you think of ptr as an
address, *ptr refers to the value associated with that address, or to the contents
stored at the specific memory location.
The in *ptr is C's indirection operator. This operator takes a single
operand, which must be a pointer, that is, an address. The indirection operator
returns a value, namely, the value stored at the address referred to by the
pointer. In the call to printf( ), the address referred to by the pointer is 4094,
and the value stored there (23) is displayed.
The indirection operator is a unary operator. As such, it has very high
precedence, the same level as the other unary operators we've seen so far
(including the address operator).
Before we look at another example, let's look more carefully at the syntax
in the previous listing. The definition of the pointer variable occurs in the
statement:
int *ptr;
270 Using QuickC
This statement defines the variable ptr as a pointer to an int. The * after the
type identifier (or before the variable name) indicates that the variable being
defined is a pointer to an int, rather than just an int variable. Strictly speaking,
pointers are a separate type, pointer to. For our purposes, you can just think of
a pointer definition as a way of telling the compiler that it should only expect
to find addresses stored in the variable ptr.
^REMEMBER When defining or declaring a pointer variable, put * before

the variable name.
Once you've defined a pointer variable in a program, you can refer either
to the pointer variable itself (a direct reference) or to the pointer's "target"
value (an indirect reference). When you refer directly to the pointer in your
program, do not include the*. In the previous listing, the first reference to the
pointer variable is direct, so only its name is used.
In the following assignment, we store an address in the pointer variable,
changing the contents of the pointer variable itself, not of the target value.
ptr " itarget
This assignment looks and happens just any other assignment. The only
like
difference is that the compiler will check more closely whether you are putting
the appropriate kind of information into the variable. Had we tried to put an
arbitrary int value in here, the compiler would have warned us.
^REMEMBER When referring directly to the pointer variable's value, do

not use the * before the pointer's name.
When you want to refer to the pointer's target value, you need to use the
indirection operator (*) — to want the value to which the
indicate that you
pointer is pointing. In the previous program listing, the argument to printf( )
illustrates this use.
When referring to the pointer's target value, use the indirection operator,
*, before the pointer's name.
:; ; ,
. ,
.
Pointers 271
It may be confusing at first to see the * used in two different ways in

relation to pointers — as part of the pointer definition and to specify the
pointer's target variable. In program statements, the * is an operator. In
definitions or declarations, think of it as telling the compiler that the variable is
of type pointer to some specified type, and that the compiler should therefore
expect to find only addresses stored in the variable.
Let's look at another example, this time using pointers to a different type:
/* Program to provide more examples ol pointers and their use. •/
main ()
double dbl.target, dbl.other; /• variables ol type double */

double *dbl_ptr; /* pointer to variable of type double »/
dbl.target -23.0; /* store arbitrary value in dbl.target */

dbl_ptr » tdbl_target; /• store address of dbl.target in dbl.ptr. */
printf ("address of dbl_target » '/,u; contents of dbl.target » %lf \n"

idbl.target, dbl.target);
printf ( "address of dbl_ptr = V,u; contents of dbl_ptr %u\n"
tdbl.ptr, dbl.ptr)
printf ( "contents of location to which dbl.ptr is pointing = Xlf \n"
dbl.ptr)
dbl.other - 46.0;
•dbl.ptr dbl.other; /• assign 46.0 to dbl.ptr 's target value */
printf ("\naddress of dbl.other = '/.u; contents of dbl.other = Xlf \n"

tdbl.other. dbl.other);
printf ("address of dbl.target %u; contents of dbl.target = */.lf \n"
Jtdbl. target dbl.target);
,
printf ( "address of dbl.ptr = '/.u; contents of dbl.ptr » XuXn"

tdbl.ptr. dbl.ptr);
printf ("contents of location to which dbl.ptr is pointing • Xlf\n".
dbl.ptr)
address of dbl.target » 5056; contents of dbl.target = 23.000000

address of dbl.ptr • 5064; contents of dbl.ptr - 5056
contents of location to which dbl.ptr is pointing - 23.000000
address of dbl.other - 5066; contents of dbl.other = 46.000000

address of dbl.target " 5056; contents of dbl.target - 46.000000
address of dbl.ptr - 5064; contents of dbl.ptr » 5056
contents of location to which dbl.ptr is pointing - 46.000000
A diagram similar to one we used earlier should make some points easier
;
272 Using QuickC
to understand:
(a) (b)
Alter Alter
dbl.target - 23.0; dbl_ptr = idbl.target
Value Address Name Value Address Name

23.0 5066 dbl target 23.0 5056 dbl_target/*dbl_ptr
??? 5064 dbl ptr 5056 5064 dbl.ptr
??? 5066 dbl.other ??? 5066 dbl_other
(c) (d)
Alter Alter
dbl.other - 46.0; *dbl_ptr - dbl.other;
Value Address Name Value Address Name

23.0 5066 dbl.target/dbl.ptr 46.0 5056 dbl.target/«dbl.ptr
5056 5064 dbl.ptr 5056 5064 dbl.ptr
46.0 6066 dbl.other 46.0 5066 dbl.other
The first part of this program is just Hke the previous program, except
that this time the statements involve variables of type double and pointer to
double. The storage allocated to the double variables is 8 bytes instead of the 2
bytes allocated for an int.
The pointer variable, dbl _ ptr, is still allocated only two bytes, however.
Remember, a pointer contains an address, not an ordinary value. The only
difference between a pointer to in! and a pointer to double is that the program
expects to find a whole number stored at the in! pointer's target variable, and a
floating point value at the double pointer's target variable. QuickC always
allocates 2 bytes to an ordinary pointer.
Notice that when the contents of the pointer variable are displayed, the
information is written as an unsigned int, even though we never declared such
a value.The output takes this form because an unsigned int takes on the range
of values possible when using two bytes. This data type is, therefore, useful for
displaying possible address values.
The fourth assignment statement (*dbl_ptr = dbl__other) is a construct
we haven't seen yet — this
an assignment involving two variables of type
is
double: *dbl_ptr refers to the target value of dbl_ptr. Because it is being

used as an lvalue (as required for the left operand of an assignment), the
assignment stores the value of dbl_other (46.0) at the memory location
referenced by the pointer. In our example, this location corresponds to the
address of the variable dbl_target, as you can see by looking at the output and
at part (d) of the diagram.
^REMEMBER ptr_var is a pointer to a variable of a particular type

If
(such as double), then *ptr_var refers to a value of that target type (double).
Thus, ptr var and *ptr_type reference different types.
;
Pointers 273
Pointers and Addresses
We've seen that address operators return a location, and that indirection
operators return the value associated with a particular address. In a sense,
these two operators are inverses of each other. The following listing illustrates
this,and gives you more exposure to pointers. Essentially, the program shows
four ways of assigning the value of one variable to another:
/* Program to assign variables in 4 different ways.

Program illustrates pointer use and relationship between address
and indirection operators.
*/
main (}
{
doable dl - 3.14. d2, d3, d4;
double 'd.ptr;
d.ptr tdl : /• assign an address to the pointer variable */

d2 • dl /• assign the value of dl to variable d2 •/
/
:
d3 " *d.ptr; /• assign value of d_ptr's target value to d3

d4 *<td2; /*
»/
assign
by td2 -- i.e.. value of d2 —
value stored at the location returned
to variable d4.
prlntf ( »dl - Xlf; d2 - Xlf; d3 - Xlf; d4 - Xlf\n". dl. d2. d3. d4)
dl - 3.140000; d2 - 3.140000; d3 - 3.140000; d4 • 3.140000
The first two assignments are straightforward. The third assignment

involves the indirection operator, but should be fairly easy to decipher. Just
remember that if d ptr is a pointer to double, then d—ptr is a value of type
double. The last assignment in the program is the most difficult, and it raises
several issues regarding pointers and unary operators.
Earlier, we said that the address operator returns an address. Strictly
speaking, the operator returns a pointer which, we've seen, has an address as
its value. This means &d2 returns a pointer whose value is the location of d2.
The indirection operator, in turn, returns the value located at the address
stored in the pointer. In this case, the variable is id2. The end result is that you
assign the value of d2 to variable d4, but in a very roundabout manner.
The mechanics of evaluating the right operand, '•&d2, illustrate an impor-
tant difference between the unary operators and most of the other operators.
So far we've worked on the assumption that operators were applied in order of
precedence, and from left to right when two operators had equal precedence.
This is the way things work with the arithmetic and logical operators.
274 Using QuickC
The unary operators, however, are evaluated from right to left when
several operators with the same precedence occur in succession. The address
operator is applied first, then the indirection operator is applied to the result
from the address operator. (The other set of operators that associate from right
to left are the simple and compound assignment operators. For example, in an
assignment statement, the right operand is evaluated first, then the result is
assigned to the left operand.)
Why Pointers?
Pointers operate differently from ordinary assignment and variable definitions

because everything is done in an indirect manner. The referents (targets) of an
action are often named only in relation to another variable. For example,
suppose Pat Smith lives at 79 East 79th Street. You could refer to Pat Smith
directly, or you could refer indirectly to Pat Smith as "the person living at the
address 1 have written on my address pad."
Although pointers may sound like a lot of work just to make oblique
references to variables, there are several contexts in which pointers are indis-
pensable. First, you will need pointers when working with certain data struc-
tures, such as a list whose length is not known in advance. With pointers you
can create and manipulate such lists.
A second use of pointers is for manipulating strings. In the next chapter,

we'll see that the arrays used to represent strings have a great deal in common
with pointers, and that most string manipulations involve pointer operations.
The third major use of pointers is as parameters in function calls, as
discussed in the next section.
Pointers as Function Parameters
In Chapter 7, we saw how to get context-specific information into a function,

by means of arguments passed in when the function was called. In that
discussion, we found that this communication was one-directional — in-
formation could get in via parameters, but could not get out that way. So far,
the only methods we've seen for passing information out of a function are
global variables and the function's return value. In this section, you'll see how
to use pointers to get information out of a function.
; ; ,
Pointers 275
Suppose you wanted to exchange the values of two variables. The follow-
ing listing accomplishes this without using pointers. Study the listing to
become comfortable with the strategy for swapping, so you'll be able to
concentrate on the use of pointers in the next version. Here is the listing:
/* Program to swap two values. No pointers used */
main ()
double vail - 1.0. val2 "2.0, temp;
temp • vail; /* store val 1 temporarily */

vail " val2; /• move val2 to vail */
val2 temp; /• put the original vail into val2 */
This is a straightforward process, and is something done fairly often in certain
types of functions, such as sorting routines for ordering data. To swap two
values, you need three assignment statements and one temporary variable of
the same type as the values you want to swap. The main strategy is to store the
value of the first variable (vail), then move the second value into the first
variable (store value of val2 in vail). Finally, move the original value of the
first variablefrom temporary storage into the second variable (move the
contents of temp to val2).
Now let's look at a program that includes a function to perform this swap.
Don't get intimidated by the swap_dbl( ) function. The actual swapping takes
place in just three statements. The rest of the function's statements are calls to
printf( ), to show you the addresses and contents of the variables involved in
the swapping.
/* Program to swap two values.

Program illustrates use oi pointers to pass paremeters by reference.
»/
/• Function to actually swap two values. Uses pointer parameters. •/

void Bwap.dbl ( double »lir8t, double tsecond)
double temp; /* to store one ol the values during swap •/
/• show ADDRESSES ol POINTER variables »/

printf ( "address ol lirst - Xu; address ol second Xu\n"
tllrst, ^second)
/» show CONTENTS ol POINTER variables •/
printl ( "contents ol lirst • Xu; contents ol second - Xu\n",
first, second)
/» show ADDRESS ol pointer's TARGET values */
printl ( "address ol 'lirst - Xu; address ol »second - Xu\n".
• Wirst, *tsecond) ;
/• show CONTENTS ol pointer's TARGET values */

printl ( "contents ol •lirst - Xll contents ol »second - Xll\n\n"
;
•lirst, •second);
; ; ; ;
276 Using QuickC
/* the next 3 statements are the actual swap routine */

temp •first; /* store 'first in safe place, refrigerated */
•first • *secon<i; /• move *second */
•second temp; /• restore first to new location •/
printf ( "address of •first " Xu; address of *second - XuVn".

*«irst, •tsecond)
printf ( "contents of •first - %lf; contents of •second - 511f\n\n",
•first, •second);
main ()
<
double dl • 12.3, d3 • 39.5;
void swap.dbl ( double •, double •);
printf ( "address of dl • Xu; address of d2 • y.u\n" , ftdl. td2)

printf ( "dl - Xlf; d2 - Xlf \n\n" dl d2) , ,
swap.dbl ( tdl, td2) ; /• notice use of address operators. */
printf ( "dl - Xlf ; d2 - Xlf\n". dl. d2)
address of dl - 6066; address of d2 • 60E8

dl - 12.300000; d2 - 39.500000
address of first - 5064; address of second • 6056

contents of first • 6066; contents of second " 5058
address of •first - 6066; address of *second » 6058
contents of *first - 12.300000; contents of *second - 39.500000
address of *first • 5066; address of ^second • 6058

contents of 'first - 39.500000; contents of *second - 12.300000
dl - 39.500000; d2 • 12.300000
Let's look at main( ) first. This function calls dbl_swap( ) to swap the
values in the two variables. Rather than passing the values themselves as
arguments, main( ) calls dbl_swap( ) with the addresses of the two variables as
the actual parameters.
Before we see how dbl_swap( ) works, look at the prototype declaration
for the function in main(). The double * indicates that the argument is a
pointer to double, rather than just a double. To indicate a pointer type in a
definition or a declaration, you need to include the *, as described above.
Generally, this will be immediately before the pointer name; however, for a
parameter in a prototype, when you don't need to include an identifier, the
indirection indicator is used to specify that the argument is a pointer type.
Pointers 277
To see how dbl swap( ) works, study the following diagram, which
shows the program's memory layout after each assignment in dbl_swap().
The identifiers in parentheses are the names associated with particular loca-
tions inside the function dbl_swap( ). The other names (dl and d2) are the
names associated with the same locations in the main( ) function.
(a)
; ; ;
278 Using QuickC
You can see this in part (d) of the illustration. When control returns to
main( ), dbl_swap( ), the storage allocated for niain( ) is still
after the call to
around. Thus, the contents of dl and d2 are still defined; these contents have
been changed by the call to dbl_s>vap( ). Notice, however, that the locations
that had been allocated two formal parameters to dbl swap( ) are no
for the
longer accessible. Those variables had local scope and automatic storage
duration, so their storage disappeared when the function ended.
Earlier, we learned that parameters to functions could be passed by value.
In that case, the program passed the value of the argument into the function,
and this value was stored in the location allocated for the formal parameter.
The function worked with a copy of the argument's information.
We've seen one way of passing parameters. Rather than passing the value
stored in a particular variable, we pass a reference to the variable itself, in the
form of a pointer to the variable's location. This form is known as passing by
reference. Parameters passed by reference can be changed inside the function;
parameters passed by value cannot.
^REMEMBER To pass a parameter by reference, pass the address of the

variable as an argument; inside the function, declare the formal parameter as a
pointer to the type of the argument variable.
Let's look at a few more examples of passing parameters by reference.

The next program converts a lowercase character to an uppercase one, and
converts an uppercase character to a lowercase one.
Notice that the parameter used is a pointer to int, rather than a pointer to
char. You'll see this often in C programs — to avoid unpleasant errors when
transporting the program. One reason for this concerns the fact that the high
order (leftmost) bit in a character may be handled differently in various
implementations. Here is the program:
•Include <stdio.h>
main ()
{
int cl;
void switch.case ( int «)
printf ( "? ");

cl getchar ()
printf ( "Before : y,c\n", cl)
Bwitch.cBse ( £cl):
printf ( "After : %c\n". cl);

; ;; ; ; ;
Pointers 279
/* convert lowercase character to uppercase, and

uppercase character to lowercase.
•/
void switch case ( int *ch)
{
•define ASCII.OFFSET 32 /* difference between upper and lowercase */
/* if lowercase, switch to uppercase */

if ( ( *ch >- 'a') 4ft ( •ch <= 'z'))
*ch —
ASCII.DFFSET;
else /• if uppercase, switch to lowercase •/
if ( ( •ch >- 'A') ftft ( *ch <- -Z'))
*eh +- ASCII.DFFSET;
>
This program reads a character, then calls switch_case( ) to convert upper-

case characters to lowercase and lowercase characters to uppercase. Other
characters are left alone.
The switch__case( ) function works directly with the value stored at the
memory location to which ch points. If the function does anything to this

value, the change will be permanent because the value is the original and not a
copy.
The next example includes a function with two parameters, one a pointer
and one a regular variable. This function updates a balance by the amount
specified in the non-pointer argument.
•include <8tdio.h>
main ()
double bal - 1000.0, amtl - 200.0. anit2 - -600.0;

void update.balance ( double *, double);
printf ( "Starting conditions\n")

printf ( "balance » 5110. 21f; amtl - %10.21f; amt2 ' 5il0.21f\n"
bal amtl
, amt2) ,
update.balance ( ftbal. amtl);

printf ( "\n\nAfter adding amtl\n");
printf ( "balance - 5110. 21f; amtl - 5110. 21f; amt2 - %10.21f\n"
bal , amtl , amt2)
update.balance ( ftbal, amt2)

printf ( "\n\nAfter adding amt2\n")
printf ( "balance = 5110. 21f; amtl - 5110. 21f; amt2 - 5110.21f\n"
bal. amtl , amt2)
void update balance ( double *current, double amt)

{
•current + amt
amt 0.0; /* not needed; just to show scope boundary •/
>

; ;;
280 Using QuickC
starting conditions
balance - 1000.00; amtl - 200.00; amt2 - -600.00
After adding amtl

balance - 1200.00; amtl 200.00; amt2 - -600.00
After adding amt2

balance - 600.00; amtl - 200.00; amt2 -600.00
This program changes the value of bal by the amount specified in either
amtl or amt2. then displays the result. Notice that the value of bal always
comes back changed by the appropriate amount after a call to update.
baiance( ). what passing a parameter by reference accomplishes.
This is
The second arguments are unchanged, however, despite the fact that this
parameter is explicitly changed in function update_balance( ). This is because
the contents of parameters passed by value are only copied, not used directly.
Pointer Arithmetic
One of the most unusual features of pointers in C is the ability to do arithmetic

with pointers. Let's look at an example to see what pointer arithmetic might
be.
/* Program to illustrate pointer arithmetic */
main ()
<
int il - 111, i2 = 222;
int *i_ptr;
printf ( "1) il - Xd; til - r.u\n", il. ftil);

printf ( "2) 12 - 'U; fti2 - y.u\n\n" . 12. 412);
i_ptr fci2; /* assign an address to the pointer /

printf ( "3) i_ptr = y.u; •i_ptr • XdXnXn". i.ptr. *i_ptr)
l.ptr - i.ptr +1; /* add 1 to contents of the POINTER variable */

printf ( "Adding 1 to POINTER varlable\n")
printf ( "4) i.ptr - Xu; *l.ptr - y,d\n\n" i.ptr, *i.ptr); ,
*l.ptr - *i_ptr +1; /

add 1 to contents of the TARGET variable */
printf ( "Adding 1 to TARGET value \n");
printf ( "5) i.ptr - Xu; *l.ptr - Xd\n\n" i.ptr. *i.ptr) .
Pointers 281
This program produces the following output in a specific environment:
1) il - 111; *il - 4064

2) 13 - 222: Jti2 - 4062
3) l.ptr - 4062; 'Lptr - 222
Adding 1 to POINTER varlsble

4) i.ptr - 4064; *i_ptr - 111
Adding 1 to TARGET value

5) i.ptr - 4064; 'i.ptr - 112
This program shows what happens when changes are made to values in
the pointer variable (that is, addresses stored in the pointer are altered) or to
the values stored in the pointer's target variable.
The first two calls to printf() display the addresses and values of the
non-pointer variables used in the program. The third call displays information
about i ptr and its target value, after assigning the address of i2 to i_ptr —
that is, making
after i ptr point to i2.
Call 4 shows the results after adding 1 to i_ptr. Let's see how this
addition works. First, note that the variable involved in the assignment
statement (i_ptr = i_ptr + 1) is a pointer, not a target variable. This means
that, in the right operand, the program first adds 1 to an address, then assigns
the resulting address to i_ptr.
It turns out that adding 1 to an address is different from ordinary
addition. Adding 1 to the value stored in a pointer variable effectively sets the
value to the next valid address value. Think of this as adding 1 address unit to
the current address. The size of an address unit depends on the type of the
target variable, as Table 10-1 shows.
For example, an two bytes of memory, so an address unit for int
int takes
also equals two bytes. If you check the values for i_ptr in calls 3 and 4 (that is,
before and after the assignment under discussion), you'll see that the two
addresses differ by two. So, in this case, adding to a pointer value meant 1
increasing the contents of i_ptr by two memory locations.
Similarly, suppose you had a pointer to double, and the current value of
the pointer variable was 4000. Adding 1 to this pointer value (that is, to the
address stored there) would give the pointer a new value of 4008 — because
you're actually adding one address unit, or eight bytes. Subtracting 3 from this
282 Using QuickC
Table 10-1. Address Unit Sizes in QuickC
Type Size of Address Unit
char 1
int 2
float 4
double 8
address value would store the address 3984 because 4008 —(3*8)= 3984.
Contrast this with the effects of the assignments between calls 4 and 5.
This assignment involves target variables. There are no changes in address

values because only int (rather than pointer) variables were involved. There-
fore, this is an ordinary arithmetic expression. The value stored in the target
variable is increased by the specified amount (here, 1). The resulting value is
assigned to *i ptr.
The compiler automatically determines the size of an address unit asso-

ciated with a particular pointer variable, based on your definition of the
pointer variable. This means that you can use pointer arithmetic to move from
one integer address to the next without knowing the amount of space allocated
for integers. This comes in handy for moving around in strings and other types
of arrays.
The ability to do pointer arithmetic without taking into account the
amount of storage allocated for a type is very helpful for transporting pro-
grams. To move a program from an implementation that allocates two bytes
for int variables to a compiler that allocates four bytes, you just need to
recompile the program. There is no need to change any expressions involving
pointer arithmetic.
'REMEMBER The size of an address unit in pointer arithmetic depends on

the type of the target variable; the size is the same as the amount of space
allocated to a variable of the target type.
— ;; .
Pointers 283
The flexibility of pointer arithmetic also comes with a price, however. It's
your responsibility to make sure the pointers point to the correct type of
variable, and that the correct type is actually stored at the location you've put
into the pointer variable using pointer arithmetic.
Make sure you move only to memory locations allocated for the function
or program in which you're doing the pointer arithmetic. Also, make sure that
when you try to read the contents of the target variable, the bit pattern will
actually represent the type of value your program is expecting. For example,
you don't want your program to read the first two bytes of a double stored at a
location, expecting to find an int there.
Addition and subtraction are the only pointer arithmetic operations; no

pointer multiplication or division is possible. Furthermore, you can only add
whole number values to an address, or subtract a whole number from an
address. Thus, you cannot increase an address by .5 address units. Finally, the
numbers you add to an address should be "pure" numbers — that is, they
should not be addresses.
• REMEMBER The only valid pointer arithmetic operations are addition or

subtraction of whole numbers to and from an address.
Study and modify the following program, which includes additional

examples of pointer arithmetic and ordinary arithmetic involving target vari-
ables. Notice the use of parentheses in the increment before printf( ) call
5 (*d_ptrl)-l—1-. Consider what would happen if the parentheses were left
off:
/* Program to illustrate pointer arithmetic •/
main
<
double dl - 111.11, d2 • 222.22, d3 333.33;
double *d_ptrl, *d.ptr2:
printf ( "1) tdl - Xu; td2 - Xu; td3 - XuXn", tdl td2. td3)
,
printf ( "2) dl - Hlf; d2 - Xll; tdS - Xlf\n\n", dl. d2, d3)
d.ptrl - td2;
printf ( "3) d.ptrl - td2 \t :: d.ptrl - Xu: •d.ptrl - Xll\n\n"
d.ptrl, •d.ptrl);
d_ptrl++: /* increment POINTER value */

printf ( "Incrementing the POINTER by l\n");
printf ( "4) d.ptrl++ \t\t :: d.ptrl - Xu; *d.ptrl - Xlf\n\n",
d.ptrl, 'd.ptrl);
;
; ; ,
284 Using QuickC
(•d_ptrl)++; /» increment TARGET value */

prlntf ( "Incrementing the TARGET by l\n");
printf ( "6) (*d.ptrl)++ \t\t :: d.ptrl - Xu; *d_ptrl - Ml\n\n"
d.ptrl, *d_ptrl);
d.ptr2 • --d.ptrl - 1; /* decrement one Ivale POINTER (d.ptrl),

then decrement resulting rvalue by 1,
then assign resulting address to lvalue
•/
printf "Decrementing one POINTER by 2 and other POINTER by l\n");
(
printl ( "6) d.ptr2 • --d.ptrl - 1 :: d.ptrl - Xu; *d.ptrl %lf\n",
d.ptrl, *d.ptrl);
printl ( "7) d.ptr2 • --d.ptrl - 1 :: d.ptr2 - Xu; *d.ptr2 - Xlf\n",
d.ptr2, *d.ptr2)
•d.ptr2 - *d.ptrl + 7; /» add 7 to TARGET value, assign to lvalue */

printf ( "\nAddlng 7 to TARGET then assigning to other TARGET\n");
printf ( "8) d.ptr2 - 'd.ptrl + 7 :: d.ptrl • Xu; *d.ptrl - Xlf\n",
d.ptrl, *d.ptrl);
printf ("9) •d.ptr2 - 'd.ptrl + 7 :: d.ptr2 - Xu; *d.ptr2 - Xlf\n\n".
d_ptr2, •d.ptr2)
printf ( "10) dl - Xlf; d2 - Xlf; td3 - Xlf\n\n", dl. d2, d3)
You can use the following output from the program to check your conclusions:
1) fedl 6354; itd2 6346; £d3 - 6338

2) dl - 111.110000; d2 - 222.220000; 4d3 • 333.330000
3) d.ptrl • td2 :: d.ptrl - 6346; *d.ptrl - 222.220000
Incrementing the POINTER by 1

4) d.ptrl++ :: d.ptrl - 6364; *d.ptrl - 111.110000
Incrementing the TARGET by 1

6) (*d.ptrl)++ :; d.ptrl - 5364; 'd.ptrl - 112.110000
Decrementing one POINTER by 2 and other POINTER by 1

6) d.ptr2 • --d.ptrl - 1 :; d.ptrl - 5346; 'd.ptrl - 222.220000
7) d.ptr2 - --d.ptrl - 1 :: d.ptr2 - 6338: *d.ptr2 - 333.330000
Adding 7 to TARGET then assigning to other TARGET

8) •d.ptr2 - 'd.ptrl + 7 :: d.ptrl - 6346; 'd.ptrl • 222.220000
0) *d.ptr2 - 'd.ptrl * 7 d.ptr2 - 6338; 'd.ptr2
: : - 229.220000
10) dl • 112.110000; d2 • 222.220000; td3 - 229.220000
Miscellaneous Points
Pointers contain addresses. There is one special address, 0, that is used to

Pointers 285
indicate that the pointer is not pointing anywhere. QuickC and Microsoft C
5.0 both define the manifest constant NULL to represent this value.
This value is particularly handy for determining whether you are at the
end of a list — that is, whether the last list pointer is not pointing anywhere.
You can also use it to make sure a pointer has a valid target variable before
doing something with this target. For example, the following test can be useful
for avoiding unpredictable errors:
/• Program to test whether a pointer has a valid target to point to.

Program Illustrates use of NULL and of pointer values In logic tests
•/
*include <stdio.h> /* contains definition of NULL */
main ()
;
286 Using QuickC
Pointer Aliases
Pointers refer indirectly to variables. When you read statements involving

pointers, you won't necessarily know what they're referencing. This can make
it difficult to determine exactly what's being changed in a program.
One common error that can be very difficult to track down arises if you
have more than one way of accessing a particular memory location. Let's look
at an example:
/• Program to illustrate aliasing and its effects. •/
main ()
<
int il - 11;
int *i_ptrl. *i_ptr2;
printf ( "address of 11 '/,u; contents of 11 " '/.dVnXn" 411, 11); ,
i.ptrl " til; /* make i.ptrl point to 11 */

i_ptr2 i.ptrl /* make i_ptr2 point to same place as i.ptrl •/
;
*l.ptr2 "37; /* change value of l_ptr2's target value */

printf ( "address of 11 - y,u; contents of 11 - y,d\n" til, 11); .
printf ( "contents of i_ptrl • Xu; contents of i_ptr2 Xu\n",

i.ptrl i_ptr2)
,
This program produces the following output. Notice the contents of the two
pointer variables, and compare this to the location of i2.
address of 11 4078; contents of il " 11
address of 11 4078; contents of 11 < 37

contents of i.ptrl - 4078; contents of i_ptr2 = 4078
Notice that the value of il is changed without any assignments involving

il as the left operand. The reason is that the storage allocated for il actually
has three names in the program. It is the target location for i__ptrl for i_ptr2,
,
and the location also goes under the direct name, il When a memory location .
has several names, these are aliases of each other.

Aliases can make it difficult to keep track of the changes to a memory
location, since it is possible to change the contents of the location indirectly.
For example, in our program, the contents of il were changed by assigning a
new value to one of the variable's aliases. Even in a ten-line program, it can be
difficult to notice such a change; think how difficult it can be in a program
several thousand lines long, involving lots of functions with parameters passed
by reference.
When using pointers, try to keep as much control over references to
particular memory locations as you can. Fortunately, this is usually possible.
Pointers 287
For example, when passing pointers as parameters, you have control over the
arguments. As long as you have only one name for the variable in the calling
function, the only changes that can occur in this context will be inside the
function, and those changes will be passed back out to the calling function in a
controlled manner.
Misguided Pointers
Earlier we saw a listing involving pointer arithmetic. By adding to or subtract-
ing from an address, we could move to the next memory location containing a
variable of the target type. If you look back at that example, you'll see that the
original pointer variable was set to point to the middle variable of three. Had
the pointer been set to point to the first or the third, the pointer arithmetic
might have produced a memory location that was either undefined or one that
contains a value other than an int.
When you use pointer arithmetic, the compiler simply makes the adjust-
ments required to move as far as your target type warrants. The compiler will
not check to make sure that the new location contains a variable of the
appropriate type.
^REMEMBER It is your responsibility to make sure that the memory

location to which the pointer arithmetic brings your program contains the
appropriate type of information.
Again, problem can usually be avoided. Most situations that call for
this
pointer arithmetic will involve arrays, which are essentially a collection of

values of the same type occupying successive locations in memory. By knowing
the dimensions of the array, you can easily make sure you are staying within
bounds. We'll discuss arrays in the next chapter.
Summary
In this chapter, you've learned about pointers, a new type of data structure
which contains memory addresses as its values. Pointers allow you to refer to
memory locations indirectly. Pointers will be useful in many contexts. For

now, the most important use of pointers is to pass information back from
288 Using QuickC
functions — by using pointers in a call by reference.

You also learned about the indirection and the address operators involved
with pointers. These operators are inverses of each other: one returns the
address of a variable, the other returns the variable corresponding to an
address.
We also introduced pointer arithmetic, a means of moving around in
address space. In the next chapter, we'll look at arrays and their relationship to
pointers. Some of the uses of pointer arithmetic will become clearer then.
Arrays and Strings
Often, you'll need to work with multiple pieces of information that form a
collection, or that somehow belong together. For example, suppose you had
records of daily temperatures for a one month period. If you wanted to analyze
this information in a program, you would need to allocate a memory location
for each value.
You could define a separate variable for each temperature reading, nam-
ing them tempi through temp31. However, typing all this can get tedious.
Fortunately, C's array concept provides an easier way to deal with such data
collections.
289
290 Using QuickC
Arrays Basics
In C, an array is an aggregate variable consisting of a collection of elements,

each of the same type. The array identifier is the name given to the entire
collection; individual elements are identified in terms of their location in the
array.
To store daily temperature readings for a one month period, you could
define an array as follows:
double daily_temp [ 31] ;
This definition creates a variable named daily temp. The type specifier
indicates that the variable contains information of type double. The square
brackets containing the number 31 indicate that the variable is an array of
double values containing 31 elements.
^REMEMBER To define an array containing variables of a particular type,

you need to specify the type (as in other variable definitions), give the array a
name, and indicate the array's size within square brackets. The brackets
indicate that the variable is an array.
When the variable daily _ temp is defined, the compiler allocates enough
contiguous storage for 31 variables of type double. The first array element has
the lowest address in the array, and also represents the address of the entire
array variable.
To access a particular element in the array, specify the array name
followed by the subscript corresponding to the element's position in the array.
In C, all arrays start with the subscript 0. Thus, the subscript values in the
array daily _ temp[ ] range from to 30, not from 1 to 31 . To refer to the tenth
element, you would write daily _ temp[ 9], since the first element has index 0.
You'll almost certainly forget this at least once in your programs, so try to do it
as quickly as possible, so you can remember it after that.

Let's look at a sample program that uses arrays:
/* Program to show definition and use of array */
define MAX. SIZE 11 /* array Bize */
main ()
; ;
Arrays and Strings 291
int running.sum - 0, count;

int Bums [ MAX.SIZE] /* MAX.SIZE element array of int •/
/* initialize array */
for ( count - 0; count <- MAX SIZE count++)
<
running_8um += count;
suns [ count] <= running sum /• assign value to cell */
}
/* Display array contents */

printl ( "CountXtSums [ Count] \n\n" )
for ( count - 0; count < MAX.SIZE; count++)
prlntf ( "y,3d :\t'/,5d\n", count, sums [ count]);
The following table is the output from the program:
Count Sujns [ Count]
This program stores the running sum of integers between and 10 in an array,
then displays each cell of the array in a table. Let's see how the array cells are
used and how the loops are set up in the program.
The array definition has the same form as the earlier example, except that
a manifest constant is used to indicate the size. This is allowed, as long as the
constant is replaced by a positive integral value. Notice that MAX — SIZE is
11 — the array has 1 1 elements, not 10 — even though the largest subscript is 10.
Again, this is because the first cell has subscript 0.
The individual cells of the array are denoted by the array name followed
by the subscript, or index, in square brackets. These brackets identify the
variable as an array in a definition or declaration and identify a value as an
array element when used in an expression.
The continuation conditions in the two for loops accomplish the same
thing, but use different tests. The first test, count <= MAX SIZE minus is _ 1 ,
more awkward, but makes explicit the fact that the last array element has a
subscript one less than the array size. The second form of continuation
condition is more convenient, but makes the relationship between array size
and largest subscript value less explicit. Use whichever form you prefer. Just
292 Using QuickC
keep mind that, in C,

in it's vow/- responsibility to keep your program within
the bounds of the array.
^ REMEMBER In C, all array subscripts begin with 0. The last array element
has a subscript that is one less than the array size.
Arrays: Storage Classes

and Initialization
Arrays are, in one sense, variables just You can define arrays as
like any other.
global or local, with static or automatic storage duration. The only restriction
is that you cannot define arrays with register storage class.
Thus, the following are all valid array definitions, and declarations:
/* Program to show array definitions at different scope levels and with

different storage classes.
*/
double global.dbl [ 25]; /* 25 element array of double: global */

static int int.array [ 10]; /* 10 element array of int;
global, but hidden from linker.
*/
main ()
{
static double local_array [5]; /* local array; static storage */
int another.array [ 12] ; /* local array •/
printf ( "Hi. thereXn");
The syntax for defining array variables is similar to that for defining other
types of variables. This is also true if you include storage class specifiers in the
definition.
Array declarations and definitions are different. Once you've defined an
array, including an array size, you can declare it in other places. You don't have
to specify the array size in declarations, because the compiler allocates storage
at definition time. At declaration time, when no storage is allocated, the
compiler isn't interested in the array size because it's your responsibility to stay
within the array's bounds.
We've seen that it's possible to initialize variables when defining them. Is
this possible with arrays? Yes and no. You can initialize arrays with static
lifetime (that is, global arrays and those with storage class static); you cannot
initialize arrays with automatic lifetime (e.g., arrays declared within a
function).
To initialize an array at definition time, you need to specify the values for
the cells, after giving the array name and dimensions. The values are written
within curly braces, with individual values separated by commas. Your initiali-
zation may extend over multiple lines, but you may not split an individual
value between lines.
For example, the following definition initializes the cells in the array,
daysîn_month[ ] to The definition could be made

the appropriate values.
globally (in which case the array would be hidden from the linker) or locally (in
which case the storage for the array would last beyond the function in which
the array was defined).
static int days.ln.month [ 12] - {31. 28, 31. 30. 31, 30,
31, 31. 30, 31, 30. 31};
If you don't initialize an array that has a static lifetime, C initializes the
elements to zero by default. The contents of a local, automatic array are

undefined until you store something in the cells.
One exception to the rule that array size must be specified when you
define the array is when you initialize an array with static lifetime at definition
time. For example, the following is a valid definition for the days _ in _
month[] array:
static int days.in.month [] - {31. 28. 31, 30, 31, 30,

31, 31, 30, 31, 30, 31};
Here, the compiler counts the number of initial values (12) and takes this
number as the size of the array. However, it is not considered good practice to
define arrays without specifying the size explicitly at definition time.
Arrays and Pointers
The implementation of arrays in C is strongly tied to pointers. In many ways,

array indexing simplifies pointer arithmetic for the programmer. In C, the
name of an array is a pointer to the first element in the array. Unlike other
pointers we've seen so far, however, you cannot change the value of the array
pointer Once defined, an array's location is fixed, just like that of any other
variable. Consider these examples:
; ; ;
294 Using QuickC
/* Program to show Bimilarities between pointers and arrays. */
«define MAX SIZE 11

#deflne OFFSET 100
main
int entry [ MAX.SIZE]

int count, *i_ptr;
/* Initialize array »/
for ( count 0; count < MAX.SIZE; count++)
{
entry [ count] count + OFFSET;
y
i_ptr " entry; /* make pointer point to array */

print* ( "tentry [ 0] y.u; i.ptr Xu; entry - '/,u\n",
tentry [ 0], i_ptr. entry);
printf ( "entry [ 0] - y,d; *i.ptr - '/,d; *entry • y.d\n"
entry [ 0], *i_ptr. *entry)
In the following program output, notice the types displayed for each of
the parameters to the printf() calls, as well as the values printed:
tentry [ 0] - 4012; i.ptr - 4012; entry - 4012

entry [ 0] • 100; 'i.ptr » 100; *entry = 100
This program initializes an array of int values. Then, i ptr, a pointer to

int, is assigned a value that turns out to be the starting address of the array. The
program then displays information about the variables involved.
Notice three of the values displayed are addresses, and that they are all the
same location. The value of entry is, as we said, the address of the first element
of the array, which is equivalent to &entry[ 0]. Thus, we could just as well have
initialized i ptr as follows:
i.ptr « Sentry [ 0]
Notice that entry is an address, but entry[ 0] is an int. In fact, entry is
simply a label for the address of the first array element. You cannot change the
value of entry or ask for its address because entry doesn't have one. If you do
ask for the address of entry (that is, for &entry) in the program, you get a
compiler warning, that the compiler is ignoring the & operator for the array.
After compiling, you would get the same output as in the program above.
If you want you need to ask for &entry[ OJ,
to display the address of the array,
the address of the first element, or simply for entry, which amounts to the same
thing.
; ,
You can, however, ask for the target of this pointer, that is, for the value of
the first array element. The indirection operator, *, will return the variable
located at the address specified by its operand. Thus, *entry returns the first
array element. Since the address stored in i ptr is the same as the value of
entry, asking for *i ptr also returns the first array element. Because entry[ 0]
is not an address, you don't need the indirection operator with this variable.
^REMEMBER The name of an array without subscript brackets is equiv-

alent to the address of the first element in the array. Asking for the array name
has the same effect as asking for the address of the first array element. Whereas
the array name is a pointer constant, the individual elements of the array (such
asentry[ 5], in our example) are variables of the base type of the array (int, in
our example).
Accessing Individual
Array Elements
Suppose you wanted to use the value of an individual element in the array. We
already saw how to do this, in the previous section. To use the value of the fifth
element in an array, such as entry, you simply ask for entry[ 4].
In this section, we're going to look more closely at how your program gets
the element you want. Let's modify the previous program, to see what happens
when we access individual elements.
/* Program to illustrate how to access individual cells, or elements,

in an array. Program uses both array indexing and pointer arithmetic.
•/
main ()
{
int count, *i_ptr:
lor ( count - 0; count < MAX.SIZE: count++)

{
entry [ count] = count + OFFSET;
}
i_ptr - entry;
print! ( "entry = y.u\n" , entry) ;
printf ( "ftentry [ 4] = %u; i.ptr + 4 = y.u; entry + 4 = V.uXn"

kentry [ 4], i_ptr + 4, entry + 4);
prlntt ( "entry [ 4] = %d; *(i_ptr + 4) = Xd; »(entry 4) - XdXn"

entry [ 4]. *(i_ptr + 4), *(entry + 4));
;
296 Using QuickC
entry » 4044
ftentry [ 4] = 4052; i_ptr + 4 - 4052; entry + 4 = 4052
entry [ 4] - 104; '(Lptr + 4) - 104; *(entry + 4) - 104
The program displays the same information as the previous program, but
for the fifth element rather than the first. The program also demonstrates the
essential similarity of pointers and arrays. We can access arbitrary array
elements using either array syntax (subscripts) or pointer arithmetic and
indirection. Let's study the program and its output.
The second line of the output displays the address of the fifth array
element, showing three different ways to specify this location. The first,
&entry[ 4], is the most straightforward and the easiest to interpret. The other
two explicitly use pointer arithmetic. Recall that adding 4 to an address means
adding four address units, where the size of an address unit depends on the
base type of the variable.
Thus, the 4 in this context equals 4*2 (bytes per int), or 8, bytes. The
value of entry (4044) is the address of the first array element, entry[ 0].
Therefore, an offset of 8 bytes from this yields the location of the fifth element.
QuickC actually uses pointer arithmetic to access array elements. Essentially,
using array indexing is really a convenience for the programmer.
The third output line methods of writing the value
shows three different
of the fifth array element. Specifying the cell's name, entry[ 4], is most
straightforward. The other two methods use the indirection operator to return
the contents of the target variable at the specified location. Notice the use of
the parentheses around the pointer arithmetic. These are necessary because
the indirection operator has higher precedence than addition. (Compare the
*(i_ptr + *i_ptr + 4 in the second output line.)
4) with the
We've seen that you can use pointer arithmetic instead of array indexing
to get information from an array. Let's look at one more version of this
program. Notice how the pointer variable i ptr is used.
/ Program to illustrate use of pointer as an array.

Adeline MAX.SIZE 11
Adeline OFFSET 100
main ()
{
int count, »i_ptr;
;;; .
for ( count 0; count < MAX_SIZE; count++)

{
entry [ count] - count + OFFSET;
}
l.ptr entry; /• make pointer point to array •/

prlntf ( "entry - Xu\n" entry),
/* display Information about entry notation */

prlntf ( "tentry [8] - Xu; entry + 8 - Xu; ",
ftentry [ 8] entry + 8) ,
prlntf ( "entry [ 8] - Xd; '(entry + 8) - Xd\n"

entry [ 8], * (entry +8));
/» display Information about i.ptr notation */

prlntf ( "ftl.ptr [ 8] - Xu; i.ptr + 8 - Xu; ".
ti.ptr [ 8] I.ptr + 8) .
prlntf ( "i.ptr [ 8] - Xd; »(i_ptr + 8) - Xd\n".

i.ptr [ 8], *(l.ptr +8));
}
entry 4002
tentry [ 8] 4108; entry 8 - 4108; entry [ 8] - 108; *(entry + 8) - 108
ti.ptr C 8] - 4108; i.ptr + 8 - 4108; i.ptr [ 8] - 108; *(i.ptr + 8) - 108
This example uses array indexing with variables defined as pointers, in

many instances, array and pointer syntaxes are interchangeable. Notice that
the individual "array" elements indexed using i ptr are ordinary variables.
Thus, used in this way, the pointer behaves just like an array identifier.
Differences Between Arrays

and Pointers
There are some important differences between arrays and pointers. When you
declare an array of a particular type, the compiler allocates enough consecu-
tive memory to store the entire array. (This is the reason for specifying the
array size when you define an array.)
The first array element has the lowest address allocated, and each subse-
quent array element is memory location. Thus,
stored in the next available
defining a ten-element array of int guarantees you memory for ten int variables
in succession. You can safely access the eighth element in the array, in a sense.
298 Using QuickC
when you define an array, you get storage for the individual elements, and you
get a pointer constant thrown in. The compiler does not allocate any storage
for a pointer variable.
On the other hand, when you define a pointer, the compiler only allocates
the storage for the pointer variable, not for a target value. Even if you have an
appropriate target value to begin with, it's still your responsibility to make sure
you'll have the appropriate variables computed using pointer
at locations
arithmetic. Suppose you define a pointer to int — ptr, for example and make —
it point to an int. Syntactically, you can then access the memory location
ptr[ 7], and the compiler will not complain.
Just as for pointer arithmetic, it's your responsibility to keep from access-
ing array elements that are out of bounds. Using an array definition when you
want to access variables in a collection is safer, because you can always check
the array index to determine whether you're still within the permitted range of
values.
Another important difference between the array entry and the pointer
i_ptr is that you can change the value of i_ptr, whereas entry is a constant.
Until you feel confident using pointers, you're better off using array definitions
for collections of variables, and using pointer definitions for accessing individ-
ual variables.
Because of the way in which the QuickC and the Microsoft C 5.0
compilers do their work, thereis no real difference in the speed at which you
can do array indexing as opposed to pointer arithmetic, although generally,

pointer arithmetic is faster.
Array Parameters
You can pass arrays as parameters to functions. When you do this, you're
actually passing the contents of a pointer to the first array element. Thus,
arrays are passed by reference, although the array's address is passed by value.
The function does not make a copy of the array contents. Let's look at an
example:
/* Program to show how to pass arrays as parameters to functions. */

: ; ;
main ()
Int entry [ MAX.SIZE]

int count, *i_ptr;
void times.two ( int [] , int)

{
entry [ count] count + OFFSET;
}
times.two ( entry, MAX.SIZE);
printf ( "Count\tEntry [ Count3\n\n")

printf ( "X3d .•\ty,5d\n", count, entry [ count]);
/* Function to multiply specified elements in an array by 2.

Note array declaration in function declarator.
»/
void times.two ( int vals [] , int array.size)

{
int count;
for ( count 0; count < array.size; count++)

vals [ count] *- 2;
This program produces the following table as output: £
Count Entry [ Count] 4
200 i:
202 <
204 M
206
J
*
208
310
213
314
216
218
220
The program an -element array of type int with consecutive

initializes 1
1
values from 100 to 110. The program then calls a function, tinies_two( ),
which doubles the value of each cell in the array. Finally, the program displays
the resulting array in a table.
In examining function calls involving arrays, notice the function proto-
type declared in main( The prototype informs the compiler that function
).
times _two( ) does not return a value, but takes two parameters, an array of
int and an int. The array is indicated by using the square brackets. Thus, int[ ]
specifies an array of int, just as int * indicated a pointer to int. Since arrays and
pointers are equivalent, we could just as easily have used the pointer to int in
;
300 Using QuickC
the prototype. That is, the following would have been an equally valid
prototype:
void twice. two ( int *, int)
Notice that the function declaration did not specify the size of the array.
This was not necessary because the compiler won't allocate any space for the
array in the function. Rather, the compiler will reference the actual memory
location containing the array (call by reference). Generally, you'll pass in a
separate parameter that tells how many elements to process, as
the function
we've done in this program. In other cases, the function may look for a
particular value in the array, and will stop when this value is encountered. See
the next section's discussion about strings.
In the function call, we used the array name, entry, as the first argument.
Again, since only a pointer is being passed, we could also have used
&entry[ 0].
Note that in the definition of times two( ), no size is specified for the
array parameter. That information is passed in as a separate parameter, and
the value is used to tell when to stop rather than how much
the function
storage to allocate. The only storage allocated for the array is enough space to
store the pointer value. Everything else is done in the actual storage allocated
for the array in main( ).
We could have specified an array size in the function declarator. But, since
the compiler does no range checking, this would have had no effect. As in the
prototype, we also could have declared the parameter as a pointer, rather than
an array. Develop the habits that best suit your programming needs and style.
In this book, we'll use pointers mainly for individual variables, and array
definitions when a collection of values is under consideration.
"REMEMBER Because an array name is actually a reference to the starting

address of the array, passing an array as an argument to a function is always a
pass by reference. Any changes are made to the original array. Because the
compiler doesn't have to allocate space to store a copy of the array, you don't
have to specify the size of the array. Let's look at another example of a function
involving an array parameter, the function will compute the arithmetic mean,
or average of the array values passed in.
; ; : ; ; ; ; ; ;
/• Program to show use of arrays as parameters. •/
«define MAX.SIZE 100
main ()
{
int entry [ MAX.SIZE], count;
Int rand ( void) /* generates random integers */
double mean ( int [] int) /* computes mean of array elements */
, ;
double average
/* initialize array with random integers */

entry [ count] - rand ()
average • mean ( entry, MAX.SIZE);

printf ( "Nr of cases - Xd; mean • y.l0.51f\n", MAX.SIZE. average);
double mean ( int vals [8] , int array.size)
Int count
double running_Bun- 0.0;
for count
( 0; count < array.size; count ++)
running.aum +
vals [ count]
return ( running.sum / array.size)
This program calls rand( ) to generate 100 pseudo-random integers, which

are stored in an array ofentry[ ]. main( ) then passes this array to mean( ),
int,
which computes the average value of these 100 numbers and returns this
information. The array is not changed inside mean( ), although it could be. The
values in the array are needed to compute the mean.
In the following more complex example, see how the program carries out
the same general task —
generating pseudo-random integers, and computing
the mean of the integers generated. A major difference between the programs
isthat this program relies much more on "specialist" functions to do the work.
The program also breaks up the task into a series of small tasks before
computing intermediate results, then combines these into a final answer.
/* More specialized program than previous one to show use of arrays

as parameters .
main ()
<
double sampling [ MAX.SAMPLES]
int count;
double int. mean ( int [] int) ,
; ; ;; ; ; ;; ;
302 Using QuickC
double dbl.mean ( diûble [] , int)

void get.rand ( int [] int) , ; /* generates array of random ints */
double average
/* generate repeated samples oi random integers:

each time through the loop fills and processes the array once
*/
for ( count - 0; count < MAX.SAMPLES; comit++)
get.rand ( entry. MAX. SIZE)

sampling [ count] - int.mean ( entry, MAX.SIZE)
/ display mean of the curent sampling */

if ( count y. B 4) "
printf ( "XlO.BlfVn". sampling [ count]);
else
printf C "XlO.Blf ". sampling [ count]);
average - dbl.mean ( sampling. MAX.SAMPLES);

print! { "Nr of cases - Xd; mean - XlO.BlfVn".
MAX.SAMPLES * MAX.SIZE. average);
/* fill an array with random integers •/

void get.rand ( int entry [] int nr.of _vals) ,
int count, rand ( void);
for ( count 0; count < nr.of _vals; count++)

entry [ count] rand ()
/» compute mean of an array of integers •/

double int.mean ( int vals [] int array.size) .
int count;
double running. sun* 0.0;
for count
( 0; count < array.size; count++)
running.sum +- vals [ count]
/* compute mean of an array of double •/

double dbl.mean ( double vals [] int array size) .
<
Int count;
double running.sum" 0.0;
for count - 0; coiint < array.size; count**)

(
running.sum vals [ count] +

A sample run of this program produces the following output:
16213.48000 15999.79000 17099.69000 16190.17000 16003.85000

16041.38000 17343.95000 15697.17000 17672.45000 15909,62000
171B1. 91000 161B4. 44000 16638 04000 . 15390.97000 16631.60000
1B009.4BOOO 1B65B. 08000 15814.97000 15919.03000 17141.60000
177B0. 73000 17441.25000 16996.10000 17330.67000 16731.66000
15918.08000 14991.80000 16477.40000 16908.15000 16868.38000
Nr of cases 3000; mean - 16426.45800
This program generates 30 times as many random numbers in groups of

100 as the previous one. Thus, this program essentially represents 30 copies of
the previous program.
After 100 values have been generated, the program computes the mean for
these values, and stores Once all 30 groups
this result in the array, sampling[ ].
of values have been generated and their mean computed, the program calls
dbl mean( ) to compute the grand mean of all the values.
Let's look at the major points concerning this program. First, we have
two arrays, one to store the random integers as they're generated (entry[ ]), and
the other to store the means for each group of 100 integers (sainpling[ ]).
The program has given the task of generating the random integers to a
function, get rand( ), which is passed a pointer to the first element in an
array of integers and a value indicating the numberof integers to generate. The
array elements are changed by get rand( ).
Notice that the program uses two different functions for computing
means. The mean() function works with an array of int values; the
int
dbl_inean( ) function works with the array of means computed during the
program's execution. Since array indexing is done using pointers, the function
decides where the next element is on the basis of the size of a single element.
Since arrays of int and arrays of double have different element sizes, they must
be handled by different functions.
A final, minor, point concerns the last call to printf( ). Notice the expres-
sion MAX — SAMPLES * MAX_SIZE as an argument. Based on our
discussion of the preprocessor and of printf( ), you should realize that this is
valid and should be able to determine what the result is.
Strings
Strings are an important part of any program. You can use them to write
messages to the user, to read text files,and generally to make interactions with
users go smoothly. In this section, we'll look at how strings are represented and
used in C.
Note that the QuickC Run-Time library includes functions for doing
many things with strings, including reading and writing them, comparing
them, and appending one string to another. We will discuss some of these
functions in this section.

In C, a string is an array of characters terminated by a null character, '
\0'.
304 Using QuickC
There is no distinct type, string, although the printf( ) and scanf( ) functions do
recognize a placeholder, %s, for displaying and reading strings. When you
define a string, you need to make the array large enough to include a null
character. For example, to store the word "hello" you would need an array of at
least six characters, as the following illustration shows:
h
The program writes each character of the string, word[ ], on a separate

Hne. Then the program writes the total number of characters, excluding the
null character, in word[ ].
The string used, word[], is defined as a global array of char. Note first
that the technique for initializing a string is different from the array initializa-
tion we saw earlier. This method — initializing the array with a string
constant — is allowed only with arrays of char. This is equivalent to, but much
more convenient than
char word [ MAX STRING] - {"h', 'e", 'l', '
r", -e', '! };
This "initialization by assignment" situation is one of the only places where an

array name can appear on the left side of an assignment statement. Ordinarily,
you cannot assign a value to the array name, since this name is a label for a
constant value.
Notice that word was defined as an array of 50 characters, but the
program only wrote 13 (characters through 12). Strings can be shorter than
the space allocated. The length of a string is determined by the position of the
null character marking the end of the string. Allocating too much space for
your string is not a problem. You must, however, make sure you've allocated
enough space to hold the longest string you expect to store in the array.
^REMEMBER Make sure you've allocated enough space to hold the longest
string you expect to store in the array, including the null character.
Notice that the for loop in the program ends, even though a null character
is not included at the end of the string constant. The compiler automatically
adds the \0'character to the end of string constants, so
' it isn't needed in your
initialization.
The function strlen( ) is a predefined Run-Time library function that

returns the number of characters in the string argument, without including the
null character. Thus, strlen( ) returns the number of characters that you have
put into the string, although the actual number of characters in that string is
one more than the value reported by strlen( ).
; ; ;
306 Using QuickC
^REMEMBER You don't need to include the null character (' \0') in string
constants — the compiler will add the character for you.
Let's look at another example:
/• Program to Illustrate use of getsO to read strings */
include <stdio.h>
#define MAX.STRING 50
main ()
Int index
int Btrlen ( char []); /* library function, return string length */
char wd.read [ MAX.STRING]
printf ( "Enter a string please. \n");

gets ( wd.read) ; /* read a string from stdin */
printf ( "XsXn" wd.read)
,
printf ( "LENGTH, not counting \\0 — '/.d\n" strlen ( wd.read));

= ,
This program prompts you for a string, reads your input, then displays the
string and tells you how long it is. This time, the character array, wd _ read[ ],
is defined as a local variable. The Run-Time library function, gets( ), is used to
read the value for wd_read[]. This function is declared in the file, stdio.h,
and returns a string value.
Functions such as gets( ) allow you to read information into string vari-
ables. You can write this information, using the %s placeholder when calling
printf( ). This placeholder tells the function to expect an array of characters,
either a string variable or a constant.
Because the string array name is a pointer constant, you cannot really use
it as the left operand of an assignment statement — except when initializing a
character array of static lifetime. Thus, the library routines for handling
strings are especially handy because they let you read variable values into your
strings.
You can also build your own strings, character by character, by using a
routine such as the macro, getchar(), in a loop reading characters until a —
predetermined end of input character is entered. Usually, the loop will end
when a newline character (' \n') is read. The following program illustrates this
method for building a string:

: ;
/• Program showing how to build a string, character by character. */
tinclude <stdio.h>
«define MAX.STRIHG 60
#dellne NULL.CHAR "NO" /* end of string marker in C •/
main ()
{
Int index:
Int strlen ( char []);
printl ( "Enter a string please. \n");
lor ( index • 0; (wd_read [ index] - getchar ()) ! '\n'; index**)

; /* do nothing: all work done in lor expression •/
wd.read [ index] NULL.CHAR; /* terminate string properly */
printl ( "Xs\n" wd.read)

,
printl ( "LENGTH, not counting \\0 -• Xd\n" , strlen ( wd.read)):
This program reads characters up to, but not including, a newHne character,
since the loop stopswhen this character is encountered. Each character read is
added to the wd_read[]. Notice that if you build the string yourself,
string,
you may need to add the NULL_CHAR (' \0') yourself (Many C programs
use the predefined manifest constant, N U LL, to indicate the end of the string.
Because this chapter is our first discussion of strings, we've used NULL
CHAR to emphasize that a special character ends the string.)
Notice the parentheses around (wd_read [ index] = getchar( )) in the
continuation condition of the preceding program. These parentheses are
important, since they ensure that the assignment to wd _ read[ index] is made
before the comparison with '
\n'. Without the parentheses, the higher prece-
dence of the inequality operator would dominate, causing the comparison,
getchar( ) != \n', to be made first. This would return a true as long as the
'
character read was not a newline character. This nonzero value would then be
assigned to wd_read[ index]. This is not what you want, so be careful about
using parentheses in such situations.
There's yet another way to handle strings in C, based on the fact that a
string can be considered a pointer to char. The following program illustrates
this, and also shows a situation where arrays and pointers differ:
/• Progran showing how to doline and initialize string as pointer to char */
•include <stdio.h>
»deline MAX.STRING 60
•delins NULL.CHAR '\0' /• end ol string character in C •/
main ()
{
: ; ; ; ;
308 Using QuickC
int Index
/• define string as pointer to char;
Initialize by pointing to first char of string constant
*/
char 'str.ptr "hello"
printf ( "Xs\n" str.ptr)

,
/* read string, character by character •/

for ( index - 0; (wd.read [ index] - getchar ()) !• '\n'; lndex++)
wd.read [ index] - NULL.CHAR; /* terminate string properly */

printf ( "XsXn" wd.read)
,
printf ( "LENGTH, not counting WO -- Xd\n" strlen ( wd.read)); .
printf ( "Assigning string I read to my str.ptr\n");

str.ptr wd.read; /* point str.ptr at a different string •/
printf ( "str.ptr • y.s\n" str.ptr),
For an input of "How do you do?" this program produces the following
output:
hello
Enter a string please.
How do you do?
How do you do?
LENGTH, not counting \0 -- 14
Assigning string I read to my str.ptr
str.ptr • How do you do?
Let's look carefully at this program. We've already seen the definition of
wd _ read[ ] and its use in the previous program. The str ptr variable is new,
however. This is defined as a pointer to char. In practice, this definition
amounts to a definition of a string, with some differences from the definition
of wd _ read[ ], however.
Note first that the pointer definition allocates space for a pointer variable,
whereas the array definition only does so for the array elements (since the
array name refers to the address of the first element).
Second, we could initialize the pointer variable, even though it is local
with an automatic lifetime. (Recall that arrays can only be initialized if they
have static lifetimes.) Any pointer variable can be initialized, however. In this
case, the initialization essentially stores the string constant in memory and
makes str __ ptr point to the location of the first character in the string
constant.
Notice the format of the printf( ) call. In the string argument, we specified
that it was to write a string (%s). The function takes this as an instruction to go
to the variable specified, and to start displaying characters until a
; :; ; ; ;
NULL CHAR encountered. Since the compiler automatically adds a

is
NULL CHAR to a string constant, the function writes "hello" when called.
Next, notice the assignment statement, str ptr= wd read. We've seen
that we can't have an array name on the left side of an assignment statement.
We can have a pointer name there, however, since this is a variable, not a
constant. The assignment statement makes str-_ptr point to the start of the
array,wd_read[]. That is, the assignment makes the two names refer to the
same string. The "hello" string is lost at this point, since its starting location,
which had been stored in str_ptr, is overwritten. The contents are still in
memory; they're just inaccessible after the assignment.
To convince yourself of this, run the following program, which adds a
second character pointer (str_ptr2) to preserve the address of the "hello"
before str_ptr has its contents changed.
/* Program to show use ol pointer assignments with strings */
#include <Btdio.h>
Adeline MAX STRING 50
#define NULL.CHAR AO'
main ()
{
Int index;
char wd.read [ MAX. STRING]
char 'Btr.ptr • "hello"
char •str_ptr2;
printf ( "Xs\n" str.ptr)

,
printl ( "Enter a string please. \n");
/• build string, character by character */

lor ( index " 0; (wd.read [ index] getchar ()) I" '\n' : index++)
wd.read [ index] NULL.CHAR: /* terminate string properly •/
printf ( "Xs\n" wd.read),
printf ( "LENGTH, not counting WO •• y,d\n" strlen ( wd.read));,
str_ptr2 str.ptr; /* to keep pinting at "hello" */
printf ( "Assigning string I read to my str.ptrNn"):

str.ptr wd.read; /* str.ptr now points elsewhere */
printf ( "str.ptr • Xs\n" str.ptr) ,
printf ( "8tr.ptr2 Xs\n" Btr.ptr2) ,
String Library Functions
Let's look briefly at some of the library functions available for handling strings
in QuickC and Microsoft C 5.0. We'll just be able to scratch the surface here.
You should look through the Run-Time library documentation for more
information about these functions as well as others that are provided.
: ; ; ) ; ;
310 Using QuickC
gets( ) and puts( ) We've already used gets( ), which lets you read a string
from the standard input, stdin. This function takes a string argument, into
which it places the string read. Note that gets( ) substitutes a NULL_CHAR
for the newline character the ends the input string, making the string conform
to C's requirements.
As you might have guessed, there's an output counterpart to gets( ). The
puts( ) function writes a string to the standard output, stdout. This function
takes a string argument, and returns an int, representing the last character
written. Also, puts( ) replaces the N U LL _ C H AR at the end of the string with
a newline character (' \n') when writing the string. Thus, if all goes well, this
should always be the character returned by the function.
The following program illustrates the use of these two functions:
/• Program to show use of getsO and putsO functions */
#include <stdio.h>
•define MAX.STRING 50
•define NULL.CHAR 'XO'
main
{
int outc ome
int puts ( char *}

gets ( wd.read)
printf ( "string XsNn", wd.read);
printf ( "Using putsO "); :
outcome puts ( wd.read)

printf ( "value returned by putsO • y,d" . outcome);
For an input of "turkey trot," this program produces the following output:
Enter a string please,

turkey trot
string turkey trot
Using putsO turkey trot
:
value returned by putsO
strcmp( ) and strncmp(

These two functions are used to compare the lexicographic ordering of two
strings. (A lexicographic ordering is one based on the position of the charac-
ters in the charactei "êt used. For QuickC, this would refer to ordering based
on the ASCII character set.) The functions return either a negative, zero, or
positive value depending on the relative ordering of the two strings compared.
; ; . ; ; :
; ,
These functions are case sensitive. Both functions require vahd strings —that
is, strings terminated by a NULL_CHAR.
The strcnip( ) function takes two string arguments. We'll call these argu-
ments stringl and string!, respectively. If stringl comes earlier in a lexico-
graphic ordering than string!, the function returns a negative value; if the two
strings are identical, the function returns zero. Finally, if the first string is
"greater than" the second (comes later in an ordering), the function returns a
positive value.
$trncnip( ) takes three arguments. The first two are strings, just as for
strcmp( ). The third is number of characters to
an integer that specifies the
compare. This function does the same thing as strcmp( ), and returns the same
range of values, but can be used to compare just portions of strings.
The following program illustrates the use of these functions:
/• Program to show use oi strcmpO and strncmpO functions */

•Include <stdio.h>
»define MAX.STRING BO
tdefine NULL.CHAR 'XO'
main ()
int outcome:
char wdl [ MAX.STRING] ;
',
char wd2 [ MAX.STRING]

int Btrcmp ( char •, char *) >
int Btmcmp ( char •, char *, int); <
printf ( "Enter a string please. \n"); f

gets ( wdl) <
printf ( "Enter another string please. \n"); t
gets ( wd2)
j
printf ( "string 1 • y,s\n", wdl);

printf ( "string 2 - y.s\n", wd2)
outcome - strcmp ( wdl, wd2):

printf ( "value returned by strcmpO - XdXn" . outcome):
outcome " stmcmp ( wdl, wd2, B)

printf ( "value returned by stmcmpO using B chars = %d\n"
outcome)
For inputs of "hello here" and "hello there," this program produces the
following output.

hello here
Enter another string please
hello there
string 1 • hello here
string 3 • hello there
value returned by strcmpO - -1
value returned by stmcmpO using 6 chars
) .
312 Using QuickC
When comparing just the first five characters, notice that the two strings are
identical, so that strncmp( ) returns 0. (Warning, if you're using strcmp( ) as a
test in a selection or loop construct, keep in mind that the function returns
— interpreted as false in C — when two strings are identical. If you want them
to be identical,you need to make the appropriate adjustments in your test.)
For inputs of "hello" and "Hello," this program produces the following
output:

hello
Enter another string please
Hello
string 1 • hello
string 2 - Hello
value returned by strcmpO 1
value returned by strncmpO using 5 chars 1
Both versions of the function return 1; since the lowercase h comes later
than the uppercase H in the ASCII character set, "hello" is greater than "Hello."
strcat( ) and strncat(

These two functions add one string to the end of another. Each function takes
two string arguments (stringl and string2, for example). The functions add
some or all of string2 to the end of stringl. When doing their work, these
functions remove the NULL^CHAR at the end of stringl, and put a new
NULL_CHAR at theend of the expanded string. Thus, stringl (the first
argument) will come back changed from these function calls.
^REMEMBER You must make sure that you've allocated enough space for
stringl to store the characters being added.
The $trcat( ) function adds the entire second argument, stringl, to the end
of the first string. strncat( ) takes three arguments —
two strings (like strcat( )),
and an integer specifying the number of characters from string2 to add to the
end of stringl.
:; ; ; ;; ;;
/• Program to show use of strcatO and stmcmpO functions •/
#lnclnde <stdlo.h>
•define KULL.CHAR '\0'
Bain (}
{
int outcome:
Int strlen ( char *)
char wdl [ MAX.STRING]
prlntf ( "Enter a string please. (No longer than 25 characters) \n");

gets ( wdl)
printf ( "Enter another string please. \n");
gets ( wd2)
prlntf ( "string 1 - Xs\n" wdl) ,
printf ( "string 2 - Xs\n". wd2)
strcat ( wdl wd2)

,
printf ( "string built by strcatO - XsVn", wdl);

printf ( "Length of new string - Xd\n" strlen ( wdl));
,
stmcat ( wdl, wd2, 6); „

prlntf ( "string built by stmcatO using 5 chars - Xs\n" . wdl); 5
*
Z
U
I
This program produces the following output when "first" and "second" are <
entered as the strings: i
F
Enter a string please. (No longer than 26 characters) <
first U
Enter another string please. I

second
string 1 ' first
string 2 second
string built by strcatO - firstsecond
Length of new string '11
string built by atrncatO using 5 chars - f irstsecondsecon
Notice the last line of the output. Since we added wd2 to wdl using
strcat( ), wdl was changed. Therefore, the first argument to strncat( ) is not the
same as the wdl passed to strcat( ).
; ; ) ; ; ; ;
314 Using QuickC
strcpy( ) and strncpy(

While the and $trncat( ) functions added one string to the end of
strcat( )
another, strcpy( ) and strncpy( ) copy one string over another. The functions
take two string arguments, stringl and stringZ, and copy string! over stringl.
Thus, the original stringl is overwritten when the second string is copied.
Notice that the second argument is being copied over the first.
^REMEMBER It's your responsibility to make sure that you've allocated

enough space for stringl to fit all the characters being copied.
The strcpy( ) function copies all of string2, including the NULL CHAR
that terminates the string, over stringl Whatever had been stored in stringl is
.
overwritten.
The strncpy( ) function takes the same two string arguments, as well as a
third, integer, argument. The integer specifies the number of characters of
string! to copy into stringl. Use this function carefully. If the number of
characters to be copied is greater than the length of string!, the function will
simply pad stringl with NULl CHAR characters. On the other hand, if you
are copying fewer characters than string! contains, the function will not
terminate the new stringl with NULl CHAR.
^REMEMBER If you're using strncpy( ) to copy fewer characters than are

contained in string!, you must terminate the new stringl with a NULL —
CHAR. The function will not do so.
The following program illustrates the use of strcpy( ) and strncpy( ):
/• Program to illustrate the use of strcpyO and strncpyO functions */
*include <8tdio.h>
#define KULL.CHAR AO'
main ()
{
int outcome
int Btrlen ( char *)
char wdl [ MAX.STRING]
printf ( "Enter a string please. (No longer than 25 characters) \n")

gets ( wdl)
printf ( "Enter another string please. \n");
gets ( wd2)
printf ( "string 1 - Xs\n", wdl);
printf ( "string 2 - XsXn" wd2) ,
; ,
Btrcpy ( wdl wd2)

.
printf ( "string created by strcatO %s\n", wdl);

printf ( "Length of new string - Xd\n" strlen ( wdl));
,
stmcpy ( wdl, wd2. B) ;
wdl [ 5] - NULL.CHAR; /* terminate string properly •/

printf ( "string created by etmcpyO using 5 chars %s\n"
For inputs of "abcdefghijklm"and "nopqrstuvwxyz,"this program pro-

duces the following output:
Enter a string please. (No longer than 25 characters)

abcdefghljklm
Enter another string please.
nopqrstuvwxyz
string 1 - abcdefghljklm
string 2 « nopqrstuvwxyz
string created by street - nopqrstuvwxyz
Length of new string - 13
string created by stmcpyO using 5 chars » nopqr
Miscellaneous String Functions

QuickC and Microsoft C 5.0 include many other functions for dealing with
strings. Check the documentation for more information. Among the functions
you may want to study are those that convert information from one type to
another. For example, itoa( ) converts the digits of an integer variable to a null
terminated string; atoi() works in the other direction — converting a string
into an integer. There are several of these functions, and they can be useful in
various contexts.
Many string handling functions are also provided in C libraries available
from various sources. For example. The C Library, by Kris Jamsa
(Osborne/ McGraw-Hill, 1985) includes 18 functions for manipulating strings.
Studying the source code in such libraries can help you become more comfort-
able with C and can provide you with new insights into different ways of doing
things.
Multidimensional Arrays
C allows you to define two-, three-, and even higher dimensional arrays. A
two-dimensional array is essentially an array, each of whose elements is itself
an array. Consider the following example:

;
316 Using QuickC
/* Program showing how to define and use multidimensional arrays */
#deflne MAX ROWS 4

#define MAX.COLS 3
main ()
<
/* define 2-dimensional array,
with MAX.ROWS rows and MAX.COLS columns
*/
int matrix [ MAX.ROWS] [MAX.COLS]
int row, col;
lor
y
; ,
consists of a three-element array. The following illustration shows the layout of

the matrix in the preceding program:
Col Col 1 Col 2

Row
Row 1
Row 2
Row 3
When you do array indexing, the rightmost dimension changes most

quickly. For example, matrix[ 2][ 1] = 21; the next value (reading from right
to left in the illustration), is matrix[ 2][ 2] = 22; then (reading from top down
in the illustration) niatrix[ 3][ 0] = 30. Thus, the indexes change the way you
would read the cells of the matrix, matrix [0][0], matrix [0][1], matrix [0][2],
matrix [1][0], . . ., matrix [3][1], matrix [3][2].
Let's look at another example, this time in a program that passes a
two-dimensional array to a function.
/* Program showing how to pass 2-dimensional arrays as parameters. */
/* multiply array elements by 2 •/

void times.two ( int mat [] [MAX.COLS] . int row. int col)
{
int r. index, e_index;
for ( r index • 0; r index < row; r_index++)

{
for c.lndex 0; c.index < col; c.index++)
(
mat [ r index] [ c.index] 2; *
>
main
int matrix [ MAX.RDWS] [MAX.COLS]

int row, col;
void times.two ( int [] [ MAX.COLS], int. int);
/• initialize matrix array •/

lor ( row - 0; row < MAX.ROWS; row++) /* for each row •/
lor ( col - 0; col < MAX.COLS; col*+) /• for each column */

matrix [ row] [ col] - 10 * row + col;
>
times.two ( matrix, MAX.ROWS, MAX.COLS);
/* display array •/
for ( row - 0; row < MAX.ROWS; row++) /* for each row */
for ( col - 0; col < MAX COLS; col++) /* for each column */
printf ( "Row Xd. Col Xd XdNn":
row, col, matrix [ row] [ col]);

}
,,
318 Using QuickC
Row 0. Col
Row 0, Col 1
Row 0. Col 2
Row 1 Col
Row 1, Col 1
Row 1 Col 2
Row 2, Col
Row 2, Col 1
Row 2, Col 2
Row 3, Col
Row 3, Col 1
Row 3, Col 2
This program creates the same two-dimensional array as the previous

program does. Then this array is passed to a function that multiplies every
element in the array by two. Finally the resulting array is displayed.
There are some important differences in the way one- and two-
dimensional array parameters are handled. Let's look first at the definition of
the function times two().
In the parameter declarations, the second dimension of the array is
specified. It turns out that the compiler needs to know the size of any array
dimension beyond the first.
To see why
remember that an array is simply a consecutive
this is so,
collection of elements, all of the same type. When indexing an array, the
program simply uses pointer arithmetic to move to the appropriate cell. But to
do pointer arithmetic, the compiler needs to know the amount of storage
required by an element of the base type.
In a one-dimensional array, every element is a simple type (or a structured
type, which cover later), whose size is known. Therefore, the compiler
we'll
knows how many bytes to skip when moving to the next valid address for that
type. The compiler knows how far to move for each address unit in a one-
dimensional array. Since it's your responsibility to stay within the array
bounds, the compiler also doesn't care where the last array element is. So, in a
one-dimensional array, you can leave out the array size in the parameter
declaration.
two or higher dimensional array, each element is another array in
In a
itself The compiler has no way of knowing how large one of these arrays is,
unless you tell it. If you had declared the parameter in the preceding program
as mat[][], and then asked for niat[l][0], the compiler would not know where
the second row of mat started, because it hadn't been told the size of each row.
If the compiler is told that each row is a three-element array, it will know how
to do the arithmetic for the indexing.

; ;
^REMEMBER When multidimensional arrays are declared as parameters in

a function, you must specify the size of all dimensions other than the first.
The prototype declaration for times two( ) in main( ) also includes the
size of the second dimension. The compiler issues a warning if the size of the
second array dimension is not included in the prototype. Thus, the program
will compile with the following declaration:
void times.two ( Int [] [] , int. int)
However, the compiler will then let you know that there's a discrepancy
between the prototype and the function declaration. Giving the compiler the
information needed for such checking is a major advantage of using
prototypes.
Multidimensional Arrays
and Pointers
Let's look briefly at how indexing works in multidimensional arrays. This
should provide an additional perspective on such arrays, and should also give
you a chance to practice your pointer arithmetic.
As in the one-dimensional case, the array name, matrix, is a label for the
address of the first element. That is, matrix is equivalent to &matrix[ 0][ 0].
In an earlier section, we saw that we could do pointer arithmetic with arrays.
Back then, we found that *(entry + 1) returned the second element in the array.
What is *(matrix + 1)? Using the reasoning in the one-dimensional case,
this is the second array element. But matrix is an array of arrays. That would
mean that *(matnx + 1) was the name of an array. The following program
shows that this, indeed, is the case:
/* Program to show names lor certain elements of 2-dimensional array */
main ()
int matrix [ MAX.ROWS] [MAX. COLS]

int row, col:
/* initalize array */
for ( row = 0; row < MAX.ROWS; row++) /* lor each row •/
for ( col = 0; col < MAX.COLS; col+*) /* for each column */

; .
320 Using QuickC
matrix [ row] [ col] • 10 * row + col;
printf ( "*(matrix + 1), the second array element = y,d\n"

(matrix + D)
for ( row " 0; row < MAX.ROWS; row++) /* lor each row */
for ( col " 0; col < MAX.CQLS; col++) /* lor each column */
printl ( "Row '/.d. Col y.d y.2d at location y,5d\n",
:
row. col. matrix [ row] [ col],

tmatrix [ row] [ col]);
*(m
; , ; ;
#define MAX.ROWS 4
#define MAX. COLS 3
main ()
int matrix [ MAX.ROWS] [ MAX. COLS]

int row. col;
/* Initialize array */
for ( row - 0; row < MAX ROWS; row++) /* for each row */
<
lor ( col « 0; col < MAX.COLS; col++) /* for each column */
matrix [ row] [ col] » 10 * row + col;
}
prlntf ( "*(* (matrix + 2) + 1) = '/.d\n"

*(*(matrix + 2) + 1));
for ( row - 0; row < MAX.ROWS; row+ + ) /• for each row */

<
for ( col - 0; col < MAX.COLS; col++) /* for each column »/
printf ( "Row Xd, Col Xd '/.2d at location y.5d\n".
:
row. col. matrix [ row] [ col],

^matrix [ row] [ col] )
To test your understanding of the rules for creating arrays of higher

dimensions, try answering the questions we've raised in this section for the
array defined in the following program. In particular, consider what *(hyper

matrix + 1) is, and how you would compute hyper _matrix[ 1][ 1][ 1], using
pointer arithmetic. Also, try to determine the array name of the second
element in hyper _matrix[ 1].
/• Program in which to exercise your understanding of S-dlmensional arrays */
«define MAX DIMl 3

*define MAX D1M2 2
«define MAX D1M3 2
main ()
{
int hyper.matrix [ MAX.DIMl] [ MAX.DIM2] [ MAX.DIM3]
int diml, dim2. din3;
/* initialize hyper.matrix --- S-dimensional array */

for ( diml - 0; diml < MAX.DIMl; diml++) /* for each matrix •/
/• initialize matrix 2-dimensional array •/

for ( dim2 - 0; dim2 < MAX DIM2: dim2++) /* for each row •/
{
/* initialize row —
1-dimensional array */
MAX.DIM3; dim3++) /• for col •/
for (dim3 - 0; dim3 <
hyper matrix [ diml] [ dim2] [dim3] -
100 » diml 10 » dim2 + dim3;
}
}
; ; ; . , ; ;
322 Using QuickC
/* display hyper.matrix */
tor ( diml - 0; dlml < MAX.DIMl; diml++) /* lor each matrix */
{
/* display matrix */
for ( dim2 » 0; dim2 < MAX_DIM2; dim2++) /* for each row */
<
/* display row */
for (dim3 - 0; dim3 < MAX.DIM3; dim3++) /* for col */
{
printf "diml '/.d, dim2 '/.d, dim3 '/.d :",
C
diml dim2, dim3)

.
printf ( " '/,3d at location '/,5d\n"

hyper.matrix [diml] [dim2] [dim3]
thyper.matrix [diml] [dim2] [dim3] )
Pointer Arrays
You can define arrays of just about any type, including pointers. The following
example of an array of pointers will provide the first example of more complex
definitions:
/* Program to illustrate definition and use of pointer arrays */
#define MAX.SIZE 5
main ()
int il - 1, 12-2, 13-3 1^ " ^ 10. o;

int *ptr_array [ MAX.SIZE] /* array of pointers to int */
int index;
/* initialize pointers */
ptr.array [0] -til;
ptr.array [ 1] - 412;
ptr.array [ 2] - 413;
ptr.array [ 3] - 414;
ptr.array [ 4] - 415;
printf ( "index\t4ptr. array []\tptr. array [] \t*ptr. array []\n\n")
/* display information about pointers and targets */

for ( index = 0; index < MAX SIZE; index++)
{
printf ( "y,d\t'/,u\t\t%u\t\t'/.d\n" index, 4ptr. array
, [ index],
ptr.array [ index] . *ptr. array [ index] )
>
/* display Information about individual variables */

printf ( "\n\nftil - Xu; 11 - '/.d\n" , til, il);
printf ( "412 - %u Xd\n", 412, 12)
printf ( "ti3 - Xu 13 - Xd\n", 413, 13)
printf ( "414 - Xu 14 - Xd\n", 414, 14)
printf ( "415 - Xu 15 - Xd\n", 415, 15)
index
; ,
324 Using QuickC
of the base type. In this case, ptr_array[ 0] contains a/70/>7?er. Thus, writing
the value of this cell will not give us an int. Rather, we get an address. To find
the value stored at the pointer's target value, we need to apply the indirection
operator. So, we need to look at *ptr _ array[ 0] for the value of the variable to
which the first array element is pointing. The target value for this pointer
happens to be il, whose value is 1 . If you look at the output, you will see that
the address of il—&il — matches the contents of ptr_array[ 0], as you

would expect if this pointer were pointing to il. Similarly, the value of il
matches *ptr_array[ 0].
String Arrays
Recall that a string an array of characters, and can also be defined as a

is just
pointer to character. Just as you can define an array of pointers to int, you can
define an array of strings. The following program shows how to define an
array of strings and how to write each element of the array:
/• Program to illustrate definition and use of array of strings */
#deflne MAX. SIZE 5
/* define and initialize string array */

char *prompts [ MAX.SIZE] < "Hello there",
"Hello again"
"This is prompts [ 2]".
"This is the next prompt",
"And this is the last one"};
main
int index, outcome;

int puts ( char *)
/* display each string in the array */

for ( index - 0; index < MAX.SIZE; index**)
outcome puts ( prompts [ index]);
Hello there
Hello again
This is prompts [ 2]
This is the next prompt
And this is the last one
: ; , ,
Notice that the array is global. That way, we were able to initialize it with
several string constants. This is common
programs that need to display
in
messages or labels at various points in the program. By collecting the messages

or prompts in one place, it's easier to change them, if necessary, or even to
adapt the array for different programs. We'll find a use for such arrays in later
programs.
Finally, the following program combines many of the concepts presented
in this chapter, by performing a simple sort on the strings pointed to by the
array, prompts[]:
/* Program to sort an array ol strings, using a bubble sort algorithm. */

#include <strlng.h>
#define MAX.SIZE B
/* define and initialize string array */

char *promptB [ MAX.SIZE] - { "Hello there",
"Hello again"
"This is prompts [ 2] "
"This is the next prompt",
"And this is the last one"};
main ()
<
Int index, outcome:
Int puts ( char *)
void bbl.sort ( char *[]. int);
/* display each string in the array */

for ( index • 0; index < MAX.SIZE; index++)
outcome - puts ( prompts [ index]);
/* sort the strings in the array »/

bbl.Bort ( prompts, MAX.SIZE);
printf ( "•***»»*\n")
/• display each string in the sorted array •/
for ( index - 0; index < MAX.SIZE; index++)
outcome puts ( prompts [ index]);
/* void bbl.sort ( char *strs [] int size) ,
Sort an array of strings by letting the "largest" remaining string

work its way to the top of the array on each pass.
•/
void bbl.sort ( char »Btrs [] , int size)
char »temp; /* for exchanging pointers •/

int low. hi. top; /* for looping through array •/
top " size; / highest element that will need to be compared •/

while ( top > 0)
{
; ;
326 Using QuickC
for ( low = 0, hi = 1; hi < top; low++, hi++)

{
/* il strs [ low] > strs [ hi] exchange them */
.
if ( (strcmp (strs [ low], strs [ hi])) > 0)

{
temp " strs [ low]

Btrs [ low] - strs [ hi]
Btrs [ hi] » temp;
>
} /* END lor hi < top */
top--; /* another string has been placed. •/
} /* END while top > */
END bbl.Bort () */
Hello there
Hello again

Hello again
Hello there
The basic strategy behind a bubble sort compare successive values of

is to
the array, while moving the larger value of each comparison toward the end of
the array. This value is involved in the next comparison, etc. After one pass
through the array, the largest value is at the top of the array, allowing the
program to ignore the top element the next time through the array. The second
time through, the second largest value moves to the second highest array
position. Each time through the array, another value is put into place.
Let's look at the first few passes through the array. The first time through
the array, the function will look at each array element (top== MAX SIZE).
The first comparison will switch "Hello there" and "Hello again" so that
prompts[ 1] will now The next comparison ("Hello
point to "Hello there."
there" with "This is prompts [ 2]") produces no changes. The next comparison
("This is prompts [ 2]" with "This is the next prompt") also makes no changes.
The next comparison switches "And this is the last one" with "This is the next
prompt. " After this pass, the highest array element points to the largest string.
The next time through the array, the function only needs to look at four
strings (top--). This pass exchanges only "And this is the last one" with "This is
the next prompt" on the last comparison.

Summary
In this chapter, we've covered lots of material. We've looked at arrays and their
relationship to pointers, learning how to define arrays of one or more dimen-
sions, how to access individual elements in an array, and even how to use
arrays to accomplish some of the same tasks as pointers.
We've also looked at a particularly useful class of arrays, namely, strings.
Although these arrays of characters have many of the same properties as other
arrays, they also have their own unique features. In particular, the use of
pointers to define string variables ismuch more common than using pointers
to mimic other types of arrays. The QuickC Run-Time library provides
numerous functions for handling strings.
In the next chapter, we'll have more to say about functions, and we'll try to
consolidate the things we've learned so far. In the process, we'll add to the
function collection that we've been building in our programs.
More on Functions
and More Functions
This chapter contains several miscellaneous topics that add some minor points
about functions and provide an opportunity to collect some of the functions
we've developed so far. You'll learn about functions that return pointers, and
we'll look at some error handling techniques. You'll also find some new
functions to add to your collection. Finally, the chapter provides a brief
introduction to recursion, a powerful programming technique in which func-
tions can call themselves.
329
:: : ; :
330 Using QuickC
Functions Returning Pointers
You've seen how to define functions that return the simple data types we've
discussed so far. In C, functions can also return pointers to simple and
complex data types. For example, the following program uses the build str( )
function to combine three other strings into a new sentence. This function
returns the address of a string (pointer to char) containing the new sentence.
/* Program to build a string out of three other strings.

Program illustrates use of functions returning a pointer to char.
*/
#define MAX.STR 80
main ()
{
char *subject = "The cow ";
char 'verb = "jumped over ";
char *object » "the moon";
char *sentence:
char *build_8tr( char *, char *, char •)
sentence build.str ( subject, verb, object);

printf ( "sentence: Xa\n" sentence): ,
printf ( "subject: Xs\n" subject): ,
char *build_str ( char first [] , char second [] , char third [])

{
char tl [ MAX.STR] t2 , [ MAX.STR] , t3 [ MAX.STR]
int count, 11, 12:
/* note use of strcpyO, rather than simple assignment */

atrcpy ( tl first)
,
strcpy ( t2, second):

strcpy ( t3, third)
/* add t2 only if there's enough room in tl */

if ( { 11 - strlen ( tl)) + ( 12 • strlen ( t2)) < MAX.STR)
strcat ( tl, t2):
/* add t3 only if there's enough room in tl */
if ( ( 11 - strlen ( tl)) + ( 12 - strlen ( t3)) < MAX.STR)
strcat ( tl, t3)
return ( tl): /* other strings have been added to tl */
sentence: The cow jumped over the moon

subject: The cow
; ; ; ;
More on Functions and More Functions 331
This program writes "The cow jumped over the moon" and the value of subject
to the screen. Let's look at the program.
The main( ) function calls build_str( ) with three strings (defined as
pointers to char, so they could be initialized) as arguments. The build_str( )
function makes a longer string by combining the three string parameters. The
function returns a pointer to the first character of the resulting string.
Look at the function definition for build_str( ). Just as you would use
char to specify the return type for a function returning a character, you use
char *when defining a function that returns a pointer to a character.
Remember that, in definitions, the indirection indicator tells you the type
involved is a pointer to the base type rather than an ordinary variable of that
type.
The function prototype for build str( ) in main( ) also uses the * to
declare the function as returning a pointer to char. Concerning the prototype,
we can ask the same kind of question we asked when defining an array of
pointers: why doesn't this syntax indicate a pointer to a function returning a
char?
The answer takes the same form as for the earlier question. The paren-
theses represent an operator in C. '\\\t function call operator, ( ), has higher
precedence than the indirection operator The precedence of the function call
operator is the same as the precedence of the array subscripting operator, [ ],
the highest precedence of any operator. (Incidentally, it is possible to have

pointers to functions, but they're too advanced for this book. You may want to
explore such pointers on your own.)
Let's look at another example, involving integers this time:
/• Program to Illustrate use of function returning a pointer to int •/
main
{
int result;
int *get_value (char )
result " *(get_value ( "value to return?"));
prlntf ( "%d\n" result)
,
int *get value ( char *meBsage)

{
int value;
print! ( "%s ", message);

scanf ( "Xd", Icvalue)
return ( Jtvalue)
}
This program writes the target value for the pointer returned by get_value( ).
The indirection operator in the assignment to result tells the program to get the
; ;
332 Using QuickC
value directly, in this case, and assign this value to result. By using the
indirection operator (thus getting a value right away), the program ensures
that an int value is stored in result, and that this value will be accessible even if
the get_value() function is called again.
Returned Pointer Pitfalls
If you're using functions that return pointers to something, be careful of what

you're returning and of what happens at the locations to which the functions
return. The function returns an address. That address may have been allocated
and assigned a value in a local environment (such as in the function). The
variable to which the returned pointer is assigned will thus be pointing to a
reusable address.
In the previous program, we used a function that returned a pointer to int.
Rather than assigning the result to another pointer, we used the indirection
operator to read the value directly. In this section, you'll see what happens if
you work with the pointers instead.

The next program assigns the pointer returned by get value( ) to another
pointer. Notice what happens when get^value( ) is called a second time with a
different assignment statement. The contents of rptr's target value, *rptr, are
changed without an explicit assignment.
The storage allocated for value, whose address is assigned to rptr, is local,
and it will probably be reused the next time the function is called. Because rptr
was pointing to the area of memory used to store information local to
get_value( ), the contents of its target location can be changed by a call to
get_value( ). Here is the program:
/• Program to illustrate conaequenceB of returning an address to a pointer,

then reusing the address.
»/
main ()
{
int result, reeult2, *rptr;
int *get.value (char *)
rptr get.value ( "value to return?");
/• This assignment will change the value of *rptr,

since the contents of the location stored in rptr will change.
•/
results - *(get_value ( "value to return?"));
printf ( "\n*rptr • Xd; rptr - Xu\n". *rptr. rptr);

printf ( "results - Xd; tresult2 - Xu\n" results, irresultS)
,
: ;
Int *get.vBlne ( char 'massage)

{
Int value;
printf ( "%e ", message):

scant ( "Xd" frralue)
,
printi ( "value " Xd; fcvalue • ilu\n" . value, tvalue) ;
return ( ftvalue )
The following listing represents a typical session:
value to return? 38
value - 38; tvalue - 4368
value to return? 94
value S4; Icvalue • 43B6
*rptr " 94; rptr - 4356

result2 - 94; tresultS - 4368
Notice that the value of *rptr changes after the second call to get value( ),
without any assignments involving *rptr. You'll see why if you look at the
address stored in rptr and the storage used for the local variable value.
In this case, the same memory location has two names, or aliases. We saw
earlier that aliasing could get you into trouble, in a situation such as the one in
the preceding program, aliasing may be more difficult to detect because the
names occur at two different levels of scope.
^ REMEMBER Be careful of aliasing, particularly of referring to the same

location in two different scopes. Your program may make unwanted changes
in the aliased memory location, and these changes may go unnoticed.
String Pitfalls
String handling can also get tricky in C, because of subtle differences among
the variety of waysyou can define and manipulate strings. In this section, we'll
look at some programs that illustrate common errors to be avoided.
In an earlier program, we defined three character arrays in function
build_str( ), and copied {not assigned) the parameter strings into these arrays.
The actual string building was done using the local copies of the strings. The
following program shows what happens if the function works directly with the
parameter strings.
; ; . :
334 Using QuickC
/* Program to illustrate consequences of working directly with parameters

passed by reference.
•/
#define MAX.STR 80
main ()
<
char *sub]ect "The cow ";
char •verb "jumped over ";
char *obJect "the moon":
char »sentence;
char *bad_bulld_str( char *, char *, char *);
sentence build.str ( subject, verb, object);

print! ( "sentence: Xs\n" sentence): ,
printf ( "subject: XsNn" subject): ,
>
/* This function does not make copies of the string contents.

The function works directly with the original strings (because the
parameters are pointers)
•/
char *bad build.str ( char *firBt, char *Becond, char *third)
{
int 11, 12;
if ( ( 11 - strlen
( first)) + ( 12 - strlen ( second)) < MAX.STR)
strcat ( first, second);
if ( ( 11 - strlen ( first)) + ( 12 • strlen ( third)) < MAX.STR)
strcat ( first, third);
return ( first)
sentence: The cow jumped over the moon

subject: The cow jumped over the moon
Notice that the value of subject has been changed by the function call because
strcpy( changes the value of its
) first argument. The following version of
build_str( ) won't work properly either, for a similar, but subtler, reason.
String assignments, such as tl = first, merely store an address; these assign-
ments do not transfer string contents. Therefore, the assignment just creates an
alias for the parameter string. When strcat( ) does its work, the parameter
string is changed, as in the previous example, as is shown below.
char 'bad build.str ( char *first, char *second, char 'third)

{
int 11, 12;
char *tl, t2, *t3;
tl - first;
t2 second;
t3 third;
if ( 11 - strlen (
( tl)) + ( 12 - strlen ( t2)) < MAX.STR)
strcat ( tl, t2);
strcat ( tl, tS)
return ( tl)
; ; ; ; ; ; ; : ;
The assignment just stored an address; the assignment does not make a
copy of the string contents. Therefore, any changes made to tl are also made to
subject, since the two names are ahases for the same memory location.
The library function, strcpy( ), does make an actual copy of the string.
This means any changes made in tl are confined to the function's duration and
scope. That's why the first program in this chapter worked without changing
the parameter variable.
^CAUTION Be careful when using string handling functions. Such func-

tions may change one or more of their string arguments. Make sure you work
with copies of any argument strings whose original value you'll need.
The following program random sentences by building longer

creates
strings out of shorter components. The program also addresses other string
pitfalls related to string storage allocation.
/• Program to generate random sentences built out ol components.

Program illustrates importance of copying string contents, rather than
merely transferring addresses.
*/
«deflne MAX.STR 80
»define MAX.ENTRY 6
char *Bub] MAX.ENTRY] - { "The bull ". "The cow ",

[ "The robin ".
"The train ", "The wind "};
char *vb [ MAX.ENTRY] - < "broke ", "jumped over ", "ate ", "arrived at ",
"bent "};
char *ob] [ MAX.ENTRY] - < "the window", "the moon", "the worm",
"the station", "the trees"}:
main ()
<
char *temp;
char subject [ MAX STR]
char verb [ MAX.STR]
char object [ MAX.STR]
char sentence [ MAX.STR]
char 'build.strC char *, char *, char •)
char *get. random. str ( char *[], int)
Int index
for ( index 1: index <- 15; index++)
temp - get.random.str ( subj . MAX.ENTRY)

strcpy ( subject, temp):
temp - get.random.str ( vb, MAX.ENTRY):

strcpy ( verb, temp):
temp • get.random.str ( obj , MAX.ENTRY)

strcpy ( object, temp):
temp build.str ( subject, verb, object);

strcpy ( sentence, temp):
printf ( "XsNn" sentence):
,
; ; ; ; ; ; )
336 Using QuickC
char *build_Btr ( char first [] . char second [] . char third []
char tl [ MAX.STR] t2 , [ HAX.STR] . *t3;

int count, 11, 12;
Btrcpy ( tl, first)

Btrcpy ( t2, second);
strcpy ( t3, third);
strcat ( tl, t2)
strcat ( tl t3) ,
return ( tl)
}
char 'get.random.str ( char *strings [] , int array.size)
int randO
int element, index;
char chosen.str [ MAX.STR]
element • rand array.size; OX

strcpy ( chosen.str, strings [ element]);
return ( chosen.str)
This program produced the following output:
The cow ate the trees

The bull bent the trees
The train arrived at the worm
The wind broke the window
The cow ate the moon
The cow broke the worm
The robin jumped over the moon
The wind ate the station
The robin ate the moon
The cow arrived at the window
The robin Jumped over the moon
The train bent the worm
The robin bent the window
The wind arrived at the moon
The robin arrived at the station
This program generates random sentences, created by selecting components

from different string arrays. The program works as follows:
The function main() calls get_random_str( ) three times to get three
random sentence elements: a subject, verb, and object. Then, inain( ) calls
build_$tr( ) with these elements as arguments. Finally, the program displays
the resulting sentence.
Look at the string definitions in main( ). We've defined five strings: four .
as arrays of characters, one as a pointer to character. The program allocates I

storage for the arrays, so we are guaranteed enough space to store the values
assigned. The pointer variable, temp, is used to assign values to the string. This
value is then copied into the appropriate array.
J
)
Notice how temp is used. First, we assign the pointer returned by the
function get_random_str( ) or by build_str( ) to temp. Then we copy the
string to which temp is pointing to a different string. Why did we use such a
roundabout way of getting the strings we wanted? Why not return the new
string directly to the appropriate string?
You cannot have an array name on the left side of any assignment
statement other than an initiahzation at definition time. To get around this
problem, you need to define the variables as pointers to char instead of as
character arrays. The drawback there is that you're not allocating any memory
for a string.
The second reason is and explains why simply using pointers to
subtler,
char won't do the trick. Suppose we did define subject, verb, object, and
sentence as pointers to characters (char *) instead of as arrays of char.
Suppose also that the program returned the strings resulting from the function
calls directly to these strings.
When get _ random _str( ) returns its result, the function is returning an
address: the contents of a local pointer variable. The storage referred to is
local storage. Suppose this variable points to address location 4000. The
function return means that the variable on the left side, subject, now contains
the same address as the local variable. The program has not made a second
copy of the string whose contents start at location 4000; rather, the program
has merely made a second variable point to the same copy of the string.
After the first call to get_random_str( ), things may still be all right, but
the next call to get_random_str( ) will almost certainly upset things. When
the program puts the environment for get_random_str( ) into memory, there
is a good chance that roughly the same areas of memory will be used as in the
previous call — since memory for a function's local environment is given back
when a function finishes executing, theprogram generally uses the next
available memory when executing a function call, and all variables and formal
parameters in the functions are local. This means the storage allocated for the
parameters can be reused when the function ends.
When get _ random str( ) is called a second time, there is a good chance
thatthe storage around location 4000 will be used again, quite possibly to store
a new string. As a result, the memory to which subject is pointing is being
changed by the second function call. Results will be incorrect after all three
components have been determined using get _ random _ str().
By passing the result to a pointer variable, then making a copy of the
string to which the pointer is pointing, you avoid this difficulty. strcpy(
338 Using QuickC
creates a second version of the string so the program can safely write over the
first version.
^CAUTION Be very careful if a function is returning a pointer to a local

variable. The contents of the memory for that variable may change without the
recipient of the function return knowing it.
Error Handling and stderr
Earlier, we found that some files were opened automatically when a C program
started, and were closed automatically when the program finished. We dis-
cussed stdin and stdout at that time: these two files are used by scanf( ) and
printf( ), respectively. Ordinarily, stdin refers to the keyboard and stdout refers
to the screen.
Another useful, but less frequently used, file can also be opened automat-
ically when a program starts. The file stderr is generally used to display error
messages. By defauh, this file is the screen in DOS. If you tell your program to
read the stdio.h file, stderr is opened for you, and will be closed when the
program ends. Do not try to open and close this file yourself
Although both stderr and stdout refer to the screen by default, there is an
important difference between them. You can easily use the DOS redirection
operators (> and »)
to redirect stdout. to a disk file, for example. Ordinary
redirection has no effect on stderr. It remains associated with the screen, even
if stdout has been associated with a disk file.
This means you can have your program write its normal output to a file,
but have it display any error messages to the screen. Thus, you get the
advantages of error reporting without cluttering up the output file. The
following program shows how to write error messages to stderr:
/* Program to show use of stderr and IprintfO •/

#include <stdlo.h>
#define MAX.COUHT 20
main ()
Int count;
for ( count - 1; count <- MAX COUNT; count++)

<
printf ( "X3d: Xl0.611\n".
count, (count - 1.0) / ( count + 1.0))-
if (I (count X 3))
fprlntf ( stderr. "XSd is divisible by 3\n" , count);
1: 0.00000
0.33333
0.50000
3 18 divisible by 3
0.60000
0.66667
0.7142g
e iB divisible by 3
0.75000
0.77778
0.80000
is divisible by 3
0.81818
0.83333
0.84616
13 is divisible by 3
0.86714
0.86667
0.87500
15 is divisible by 3
0.88336
0.88889
0.80474
'ii
18 is divisible by 3 '^\
10: 0.00000
30: 0.00476
The program counts from to 20, and displays an appropriate fraction at each
1
value. The program also checks whether the current value is divisible by 3, in
which case the program writes a message to stderr.
Notice in the output that everything seems to be written to the same place.
There is no distinction between stderr and stdout because the default for each
is the screen. In the next example, we'll redirect stdout to a file.
First, let's look at this program. Notice the preprocessor command to

include the contents of file stdio.h. This file contains the definitions needed for
QuickC to recognize your reference to stderr. Although you don't need to open
..
340 Using QuickC
or close stderr, the status of this file is from stdin and stdout. The
different
latter two files are known to QuickC immediately, whereas stderr must first be
defined for the compiler.
The stderr file is used with fprintf( ), a version of printf( ) for which you
can specify a file to which the function is to write. In this case, we've specified
stderr. Note the order of the parameters.
Notice the condition in the By asking for the negation of the
if statement.
expression, count % 3, we get a nonzero value whenever this expression is zero.
That is, the condition is true whenever count is divisible by 3.
Watching an if Statement with Quicl(C more explicitly, run To see this

this program in debugging mode: at the same time, you'll see more clearly how
the flow of control changes when the condition in an if statement becomes

true. To see this, do the following:
1 Start QuickC with the file containing the previous program.
2. Type CTRL-d, then C, to clear any breakpoints currently set in the file.
3. Type CTRL-D, then L, to clear any watch variables set in the file.
4. Type CTRL-R , then C, to get to the compiler options.
5. If you don't have debug set to on, type D to set this option to on. Then
press ENTER to compile the program.
6. Type CTRL-D then press ENTER to indicate that you want

, , to add a
watch variable, and enter count as the watch variable.
7. Move the cursor to the hne containing the condition for the if
statement.
8. Type CTRL-D , then B, to set a breakpoint at this line.
9. Move the cursor to the next line, containing the call to

fprintf( ).
10. Type CTRL-D, then B, to set a breakpoint at this line.
1 1 Type CTRL-R, then press ENTER , to start the program.
12. Step through the program using the F5 key. Notice that the program
stops at the second breakpoint line (fprintf( ) ) only when count is a
multiple of 3 — that is, only when the condition evaluates to nonzero.
Any time the condition fails, the second breakpoint line is bypassed.
To see the difference between stderr and stdout, run the program (which
we'll call errdemo) using redirection. To do this, type
errdemo > den
This command assumes that the program is called errdemo.exe. Substi-

tute whatever name you've given the program. Running the program this way
redirects any output to stdout to the file, demo.out. You can look at demo.out
with your text editor. To see it, type
qc demo out
.
or whatever the appropriate command would be for the text editor you're
using. If you run the program and then look at the file, you'll see the following:
1
342 Using QuickC
^REMEMBER To use stderr, you need to include the contents of the file
stdio.h. Do not try to open and close stderr yourself
exitO
C provides two functions for leaving programs earlier than anticipated. The
program will do some cleaning up before terminating. It can also pass along
information to the operating system about the reasons for program termination.
The exit( ) function allows a graceful exit from a program. If you need to
end a program immediately, you can use this function. It closes any open
output and flushes any buffers before ending the program. This allows you
files
to keep whatever the program had created up to that point.

The following program illustrates the use of the exit( ) function:
/* Program to illustrate use of exitO •/
#lncludo <Btdio.h>
#define MAX.COUHT 20
main ()
{
Int count:
for ( count - 1; count <- MAX.COUNT; count++)
printf ( »X3d: XlO.Blf\n".

count, (count - 1.0) / ( count + 1.0));
If (I (count X 13))
{
fprintf ( stderr, "Ending programXn");
exit ( 1);
'
>
}
1
The program counts and displays values until it reaches a number divisi-
ble by 13, at which point the program terminates with the error message.
Notice the argument, 0, passed to exit( ). This int parameter represents
the "terminating status" of the program. A status of generally means normal
termination. Other return codes will represent different conditions. Check
your DOS documentation for information about these return codes. This
return value can be used by the DOS batch command, IFERRORLEVEL, as
shown in the following example, which assumes the preceding program is
named test 13:
echo off
testis
if errorlevel 1 goto early
echo program terminated normally
goto done
early
:
echo program terminated early

echo on
rdone
The Other function for leaving a program is _ exit( ). This function is just
like exit( ), except that _ exit( ) does not close files and flush buffers before
ending the program.
You've now learned four different ways of breaking out of a program or
program portion: break, continue, exit( ), and return. Table 12-1 reviews the
conditions under which each of these is appropriate.
Table 12-1. Four Ways of Breaking Out of a C Program or Program Portion
Method Use
break
344 Using QuickC
Adding to Your Function Collection
Throughout the book, we've used various functions to illustrate concepts in C.

Some of these functions can be generally useful and are worth considering for
inclusion in function libraries. In this section, we'll gather some of these
functions,and we'll introduce two programs that provide additional functions.
This segment gives you more exposure to C code and to some of the
concepts the code illustrates, and also provides you with some usable tools for
writing your own programs. Many functions require one or more of the library
functions gathered in qcstuff.qlb, which we built to make these functions
available to the QuickC compiler. This library, which is described in Appendix
B, is only needed for QuickC; you don't need the library when compiling under
Microsoft C 5.0. If you're using a different compiler, you may need to build a
comparable library.
Already Defined Functions

We've defined several functions that can be useful in various situations. In this
section, we'll look at a few of these.
non_zero() and safe — division()

The functions non_zero() and
safe division( ) help make programs a bit more robust, by avoiding certain
situations that will cause problems in a program. Both functions are used in
the finance program later in the chapter

non zero( ) takes one argument, a double, and returns TRUE if the
argument differs from zero by more than a predetermined amount. Otherwise,
the function returns FALSE.
safe _ division( ) takes two arguments, both double, and returns the
quotient of the argument divided by the second. The function checks
first
whether the denominator (the second argument) is zero. If so, the function
returns a predetermined extreme value.
swap_int( ) and swap — dbl( ) These functions swap the contents of the
two arguments passed between them. The changed values are passed back to
the calling function because the parameters for these functions are pointers. In
the case of swap _ int( ) the parameters are pointers to int; the parameters are
pointers to double in the case of swap_ dbl( ).
zero_one — rand() This function talces no arguments, and returns a

random double between 0.0 and i .0 inclusive. Such a function can be useful for
creating simulations or for generating sample table values. This function may
be used in conjunction with a function that fills such a table with random
values. The latter function would be passed an array of double, and would fill
this array with random values.
dbl — mean( ) and int — mean( ) These two functions compute the aver-
age, or mean, of an array of values. Each function takes two arguments — an
array of the appropriate type and an int specifying the number of values to
generate — and returns a double whose value is the average of the array
elements.
These functions, along with the functions for generating random values,
form the beginnings of a statistics toolbox. For example, functions could be
added to compute the standard deviation of arrays of values or to generate
random samples with desired characteristics.
String Functions
In this section, we'll describe a few functions for handling strings and we'll
look at a program that will let you exercise the functions. First, we'll summar-
ize the purpose and usage of each of the functions. Then we'll look at the
program that lets you loop and test whichever string function you want.
deleteO This function deletes a specified number of characters from a

string. The function takes three parameters: the string in which to make the
deletion, the starting position of the deletion, and the number of characters to
delete. Note that the starting position is in terms of counting position in the
string, not in terms of the array subscripting for the string. Thus, to delete the
first five characters of the string str, you would call delete( ) as follows:
delete ( Btr, 1 , 5) ; /* delete lirst 6 characters from str */
Notice that the function call uses 1 rather than as the second argument. You
are likely to count characters in a string to determine when to start deleting.
Since more natural for us to count from than from 0, the delete( ) function
it's 1
uses counting numbers instead of array indexes.

.
346 Using QuickC
reverse slr( ) This function reverses the string passed in as a parameter.

There is a hbrary function, strrev( ), that does the same thing. However, this
function illustrates a common strategy when doing such things as reversing or

comparing corresponding elements on opposite sides of a midpoint. The
strategy is to work from both ends toward the middle, stopping when the
middle is bypassed.
reverse _str() takes one parameter the string to be reversed. The
following call illustrates the use of this function:
reverse_str ( str) ; /* reverse string str •/
clean of char() This function removes all occurrences of a specified

character from a string. The function simply copies the string onto itself,
leaving out any occurrences of the character to be filtered in the process. The
function takes two parameters: the string to clean and the character to
remove. The following call would tell a program to remove all occurrences of
the letter r from the string str:
cleaji_of_char ( str, 'y'); / remove all y's Iron str »/
char pos( ) This function returns the array subscript of the first time a
specified character appears in the string. This function takes two parameters
and returns an int. The parameters are the string to search and the character to
seek. The function returns the array subscript of the first occurrence of the
character in the string. If the character is not contained in the string, the
function returns — 1
Note that the position returned by this function is an array index — unlike
the starting position specified for delete( ), which is a counting value. Thus, the
following call would return 0:
/* assujne result has been defined as an int */

result - char.pos ( "hello there", 'h');
You might use the value returned by char_pos( ) as an array index; in that
case, returning the subscript value is an advantage.
remove— wd() This function removes the first word in a string and
returns this word. The function takes one string parameter and returns a
The parameter is the string from which a word is to be removed, and the
string.
returned value is the word removed from the string. A word is any sequence of
characters followed by a blank.
If the string contains no blanks, then the entire string is returned as the
word, and the string is reduced to an empty The function deletes any
string.
leading blanks in the string before removing a word. Such a function can be
useful if you want to change the line breaks in a text file — for example, if you
need to print in smaller or wider margins.
The following call would assign the string "why," to word and would
remove this string from sentence, leaving that string with the value, "hello
there."
/* assuine sentence has the value "why, hello there."

assume word has been defined as a pointer to char.
*/
word remove _wd ( sentence); /* word now "why," -
sentence now " "hello there.'
•/
A Program to Exercise the String Functions The program that follows

includes the source code for the functions described above. The program also
includes additional routines for testing the string handling functions. Try
running the program and trying out the functions, to get a feel for what they
do.
There are several things worth noting about this program. First, notice
the global array of strings, nienu[]. This contains the messages displayed for
the menu options. You can tailor this menu to different programs, as we'll see
later in the chapter.
The show menu( ) function displays the desired menu and prompts the
user for a selection.The show menu( ) function takes two parameters: an
array of strings and the number of menu items currently initialized. This
function can be used, without modification, by any program containing the
appropriate type of menu. The only thing you need to change is the menu itself
The main( ) function contains one long switch construct. Each case in the
switch corresponds to a menu selection. Each selection lets you test a different
string function. The appropriate actions are specified for each selection. This
switch construct is inside a loop that continues until the user wants to quit.
Again, this strategy can be adapted for different programs. The only changes
required are in the actions corresponding to each switch case, and the value
displayed at the end of the switch. The program follows.
; ; ; ; ;
348 Using QuickC
/• Program to exercise string functions. */
Mefine NULL.CHAR AO' /* end of string character */

Adeline MAX.STR 80 /* maximum string length */
#define MAX MENU 10 /* maximum # of menu selections */
#define BLANK.CHAR •
•
/* menu for the selections possible with this program */

char *menu [ MAX.MENU] - { "0) Quit", "1) Delete", "2) Reverse", "3) Clea
"4) Char.Pos". "B) Remove.Word"};
/• void show.menu ( char *menu [] , int menu_size)
Display the specified menu, which is an array of strings,

menu.size indicates the number of strings in the menu.
Function also prompts user for a choice.
CALLS printf ()
:
GLOBALS MAX.MENU
:
PARAMETERS :
char *menu [] array of strings, containing menu.

:
int menu.slze number of items in menu. :
USAGE: show.menu ( str.array, nr.entries)

»/
void show menu ( char *menu [] , int menu.size)

{
Int count;
printf ( "\n\n");
/* if programmer claims menu has more than maximum allowed items,

bring the value into line.
*/
if ( menu size > MAX MENU)
menu.size - MAX.MENU;
/• display the individual strings in the array •/

for ( count 0; count < menu.size; count++)
printf ( "y,B\n" menu [ count]); ,
printf ( "\n\n");
/* prompt user */
printf ( "Your choice? (W to Xd) ", 0, MAX.MENU - 1);
main ()
void reverse. Btr ( char •)

void clean.str ( char «, int);
void delete ( char *, int, int);
void show.menu ( char*[], int);
char •remove.wd ( char *);
char *temp.str, new.word [ MAX.STR]
int char.pos ( char *. int);
char test str [ MAX.STR]
char char.str [ MAX.STR]
int to.clean, start, how.many, selection, result;
printf ( "String? ");

gets ( test.str);
/* repeat this loop until user wants to quit */
do
{
show. menu ( menu 6) , ;
scanf ( "y,d" tselection)

,
/» switch on user's menu selection */

switch ( selection)
<
. ; ;; ; ; ; ;
; ; ; ; ; •
default:
break;
"Be 1: /» delete ./
printf ( "Start? ");
scanf ( "Xd", ftetart);
printf ( "How many? ")
Bcanf ( "'/.d", fthow.many)
delete ( test.str, start, how many)
- J"
break
*^*° ® 2: /» reverse str •/
reverse.str ( test. str)
break
<="« 3: /, clean str */
pnntf ( "Char? ");
scanf ( "Xs", char.str)
to.clean = char.str [ 0];
clean.str ( test. str. to clean);
break;
= "« 4: /, char.pos */
printf ( "Char? ");
scanf ( '"/.s", char.str);
to.clean = char.str [ 0];
result - char.pos ( test.str. to.clean);
printf ( "Xd\n", result);
break;
case 5: /, remove.wd •/
temp. str = remove.wd ( test.str)
strcpy ( new. word, temp.str)
printf ( "'/,s\n" new.word),
break;
>
printf ( "'/.sVn" , test.str)
while ( selection !• 0);
/* void reverse.str ( char »Btr)

Reverse the string passed in as a parameter.
CALLS : strlenO
GLOBALS :
PARAMETERS :
char *Btr string to be reversed.

:
tJSAGE: reverse.str ( str);

Basic strategy have two counters, one (up) running from start to end of
string, the other (down) running from end to front of string.
Each time through the loop, swap the two characters at the positions
indexed by the two counters. When the counters pass each other
(that is, when up becomes greater than down), the job is done and the
loop ends
void reverse.str ( char *str)
int temp, /* to hold character during swap */

up, /• index, up left --> right in string */
:
down; /* index, down right -> left in string •/

:
/* swap first with last, second with second to last, etc., until
middle of string is reached.
for ( up » 0, down " strlen ( str) - 1; up < down; up**, down--)
temp • str [ up]

str [ up] • str [ down]
str [ down] temp;
: : ; ; ;
350 Using QuickC
/* void clean.str ( char *str, int ch)
Remove all occurrences of a specified character from a string.

CALLS :
GLOBALS NULL CHAR:

:
PARAMETERS
char *str string form which to remove character occurrences;
:
Int ch character to remove from string.

:
USAGE clean.str ( str, ch)

:
*/
void clean.str ( char *atT, int ch)
int old, new; /* array indexes for old and new version of string */
/* Keep two separate counters:

new for the characters being added to new version of string;
old for character in old string currently being examined.
Old is Incremented each time through loop:
new Is Incremented only when a character passes the filter
and Is added to the new version of the string.
*/
for ( new - 0. old - 0; str [ old] I- NULL.CHAR: old++)
{
/* if character is OK, add it to new string,
and increment counter for new string.
»/
if ( str [ old] I- ch)
str [ new++] str [ old]
>
str [ new] NULL.CHAR: /• terminate string properly */
/• void delete ( char (str, int start, int how.nany)
Delete a specified number of characters from a string,

beginning at a specified position in the string.
NOTE: The starting position refers to the actual position of the
characater In the string, NOT in the array.
Thus, the first starting position in the string is 1 NOT 0.
CALLS strlenO
:
GLOBAL NULL CHAR

:
PARAMETERS :
char *str string from which characters are to be deleted;

:
int start position (NOT array subscript index) of first

:
character to delete:
int how_many number of characters to delete.
:
USAGE : delete ( str, 2. 27);

*/
void delete ( char *Btr. int start, int how many)

{
int indexl , index2
/* if starting position is an invalid value, start with 1 */

if ( start < 1)
start - 1
/* If # of chars to delete would go past end of string,
just delete to end of string.
•/
if ( start + how.many - 1 > strlen ( str))
how.many strlen ( str) + 1 - start;
/* leave all characters before start position alone;

begin changing characters at character (start - 1),
(because arrays begin at index 0)
begin moving new characters from position (start + how_many
. ; ; ; ;; ;
substitute the characters indexed by index2 for those indexed by

indexl
continue until the end of the string has been reached.
for ( indexl - start - 1 index2 - start + how. many -

. 1
str [ index2] !- HULL CHAR; indexl ++, index2++)
<
str [ indexl] str [ index2}
str [ indexl] « NULL.CHAR; /* terminate the string properly •/
/* int char_poB ( char *6tr, int ch)
Return the array subscript corresponding to the first occurrence of the

specified character in the string.
If the character does not occur in the string, the function returns -1.
CALLS :
GLOBALS NULL CHAR;

:
PARAMETERS :
char *8tr string to search for occurrence of character.

:
int ch character to seek in str. :
RETURN int representing array subscript of 1st occurrence of ch in str.

;
USAGE where = char_pos ( str. ch)

:
•/
int char pos ( char *str. int ch)

i
int index:
/• The function only searches, continuing until either

the character is found OR end of string is reached.
•/
for ( index 0;
( str t index] !- ch) tft { str [ index] != NULL.CHAR);
index* +)
/* if end of string (i.e.. character NOT found), return -1,

else return subscript (index value) at which character was found.
*/
if (str [ index] -- NULL.CHAR)
return ( -1)
else
return ( index)
/• char 'remove. wd ( char 'str)
Remove the first word from a string; a word is any sequence of characters
followed by a blank. Strip this word from the string being processed.
If no blanks are found in the specified string, the entire string is
returned as the word.
CALLS charposO. deleteO. strcpyO
:
GLOBALS BLANK.CHAR. MAX.STR. NULL.CHAR

:
PARAMETERS :
char 'str string from which to remove a word. ;
RETURN string containing first word found in str.

:
USAGE now word.str - remove.wd ( str)

:
•/
char *remoTe_wd ( char *str)

{
; ; ;; ; ;
352 Using QuickC
Int Index, where;

int char.pos ( char * , int)
char temp [ MAX.STR]
/* remove any leadli;g blanks from string */

while ( lchar_poB ( etr. BLANK. CHAR))
delete ( str, 1, 1)
/* find position ol first blank in string.

If a blank is found, copy everything up to (but not including)
the blank into temp, then delete everything up to (and including
blank) from the string.
If no blank is found, return entire string as the new word,
then empty the original string.
•/
where char.pos ( str, BLANK.CHAR)
if ( where >- 0)
<
/* copy word into temp */
for ( index " 0; index < where; index++)
temp [ index] str [ index]
temp [ index] • NULL_CHAR; /* terminate temp properly */
delete ( str, 1, where +1); /* remove word from str */
>
else
{
strcpy ( temp, str); /• copy str to temp */
str L 0] - NULL.CHAR; /• set str to empty string
}
return (temp)
Finance-Oriented Functions
In this section we'll introduce a few functions for computing some values
commonly encountered in financial contexts, such as banking, borrowing, or
saving. After the discussion of the individual functions, you'll again find a
program you exercise the finance functions. You'll see how to adapt
that lets
the menu array and the switch construct for this new group of functions. You'll
also find additional general purpose functions that can be used in other
programs.
compound — interest() This function returns the interest on a starting

an initial deposit), given the principal, frequency of com-
principal (such as
pounding, and annual interest rate. For example, for a principal of $1000,
invested at 8% interest, compounded quarterly for 3 years, the function returns
$268.24 as the interest earned.
The function takes four arguments, — principal, annual inter-
all double
est rate, frequency of compounding, and number of years — and returns the
resulting interest as a double. The following call illustrates the usage for
compound _interest( ).
/* assume result, princ . interest, freq. and yrs «ire all double */
result comppund.interest ( princ, interest, freq, yrs);
monthly mortgage() This function computes monthly mortgage pay-

ments when mortgage amount, annual interest rate, and total number of
monthly payments are specified. For example, for a mortgage of $80,000, at
9.5% interest amortized for 420 months (35 years), the monthly mortgage
payment is $657.29.
The function takes three double arguments — mortgage, annual interest, and
number of monthly payments —and returns a double specifying the size of the
required monthly payment. The following call illustrates the usage for monthly _
niortgage( ):
/* assume result, mortgage, interest, payments are all double */

result monthly_mortgage ( mortgage, interest, payments);
annuity( ) This function computes the size of an annuity when the annual
interest rate, annual deposit, and number of years are specified. For example,
for an interest rate of 8.5%, with $300 deposited annually for 21 years, the
function returns $16,046.72.
The function takes three double arguments — a/7/7wa/ deposit, annual
interest rate, and number of years —
and returns the annuity size as a double.
The following call illustrates the usage for annuity( ):
/* assume result, deposit, interest, yrs are all double */

result annuity ( deposit, interest, yrs);
annuity_deposlt( ) This function computes the annual deposit required

to reached a desired annuity when the desired annuity, annual interest rate,
and number of years are specified. For example, for a desired $10,000 after 14
years at 8.5% interest, you must deposit $398.42 annually, according to the
function.
The function takes three double argumenls — desired annuity, annua!
interest rate, and number of years —
and returns the required annual deposit
as a double. The following call illustrates the usage for annuity _deposit( ):
/* assume result, goal, interest, yrs are all double */

result " annuity.deposit ( goal, interest, yrs);
A Program to Exercise the Finance Functions The following program

includes the source code for the functions described above. The program also
:
354 Using QuickC
includes additional functions useful for testing the finance functions. Try
running the program and trying out the functions to get a feel for what they do.
There are several things worth noting about the program. First, notice
again the global array of strings, inenu[]. This contains the messages dis-
played for the menu options. It was easy to initialize menu[] to the selections
required for the finance functions.
Again, the inain( ) function contains one long switch construct. Each case
in the switch corresponds to a menu selection. Each selection lets you test a
different finance function. The appropriate actions are specified for each
selection. The switch shell and the loop within which the shell is found are the
same as in the string testing program. The only differences are the actions
carried out when a specific switch case arises.
This program makes use of some of the functions we've built during the
earlier chapters, such as non zero( ) and safe division(). There is also a
new function, get dbl(), which takes a string parameter and returns a
double. The string will usually be a prompt of some sort.
The include files float. h and math.h contain definitions used by library
functions such as pow( ).
/* Program to exercise finance functions */
#lnclude <float.h>
#lnclude <math.h>
define MAX.MENU 10
#define TOLERANCE l.Oe-7 /* acceptable difference or error •/
define INVALID VAL -99999.999 /• val to return for invalid double */
define FALSE
define TRUE 1
I* array with menu selections for this program */

char *menu [ MAX.MENU] « < "0) Quit", "D Monthly Mortgage".
"2) Compound Interest", "3) Annuity",
"4) Annuity Deposit"};
/* void show.menu ( char *menu [] , Int menu_size)
Display the specified menu, which is an array of strings,

menu.size indicates the number of strings in the menu.
CALLS : printf ()
GLOBALS :MAX.MENU
PARAMETERS :

:
int menu.size number of items in menu.

:
USAGE : show menu ( menu. array. Nr.of .entries)

*/
void show menu ( char *menu [] , int menu. size)

{
; ; ; ;
int count;
print* ( "\n\n");
/* If programmer claims menu has more than maximum allowed items.

•/
if ( menu.Bize > MAX.MEHU)
menu.size • MAX.MEIfU:
/• display the individual strings in the array •/

for ( count 0; count < menu.size; count**)
printf ( "%s\n", menu [ count]);
printf ( "\n\n"):
/• prompt user */
printf ( "Your choice? ('/.d to '/.d) ", 0. MAX.MENU - 1);
/* double get.dbl ( char *message)
Prompt user with message, read and return a double.

If the read was unsuccessful, returns INVALID VAL.
*/
double get dbl ( char ^message)

{
double val; /* slot to store value read */
int args.read; /* number of values read successfully */
printf ( "Xs ", message);

args.read scanf ( "Xlf", Aval);
if ( args.read) /* if at least one value was read
return ( val)
else
/* double saf e.division ( double numer, double denom)
Divide num by denom, checking for division by zero before doing so.
Return quotient or a default value ( INVALID.VAL) on division by zero.
*/
double safe division ( double numer, double denom)

{
Int non.zero ( double)
if ( non.zero ( denom))
return ( numer / denom)
else
return ( INVALID.VAL);
>
/• int non.zero ( double val)
Return true if val differs from zero by more than a predefined amount.
*/
int non.zero ( double val)

; ; ; ;; ; ; ; ; ; ; ,
356 Using QuickC
it ( (( val - 0.0) > TOLERANCE) II ((val - 0.0) < -TOLERANCE))

return ( TRUE)
else
return ( FALSE)
main
double monthly.mortgage ( double double double) , ,
double compound.interest ( double, double, double, double);

double lunortlzation ( double, double, double, double):
double annuity ( double, double, double);
double annuity.deposit ( double, double, double);
double get_dbl ( char *)
int get.lnt ( char •)
void show.menu ( char •[], int);
double prlnc, Interest, months, result, freq, yrs;

int selection;
show.menu ( menu, B)
scanf ( "Xd" ^selection)
,
switch ( selection)
{
default:
break;
case 0:
break;
case 1
prlnc - get.dbl ( "Mortgage? ");
interest • get.dbl ( "Interest? ");
months get_dbl ( "Months? ");
result " monthly.mortgage ( princ interest ,
months)
break;
princ - get.dbl ( "Principal? ");

Ireq - get.dbl ( "Frequency? ")
yrs " get.dbl ( "Years? ");
result - compound.interest ( princ, interest,
freq, yrs);
break;
princ • get.dbl ( "Annual Deposit? ");

interest " get.dbl ( "Interest? ");
yrs - get.dbl ( "Years? ")
result " annuity ( princ, interest, yrs);
break;
princ " get.dbl ( "Desired Annuity? ");

yrs - get.dbl ( "Years? ");
result » annuity.deposit ( princ, interest,
yrs):
break;
}
printf ( "Xl0.21f\n", result);
}
while ( selection ) 0);
/* double aonthly.mortgage ( double mortgage, double interest, double months)

; ; ; , , :
Compute monthly mortgage payment, given annual interest rate and

total number of monthly payments.
Formula: mortgage * ( numer / denom)
where nuner (Interest / 12) * term:
where denom term - 1
where term (1 + interest / 12) * months.
CALLS powO, safe.divisionO

:
GLOBALS :
PARAMETERS :
double mortgage total mortgage :
double interest annual interest rate :
double months total months of mortgage

:
RETURN monthly mortgage payments.

:
USAGE payment " monthly.mortgage ( mortgage, interest, months)

:
•/
double monthly.mortgage ( double mortgage, double interest, double months)
double pow ( double, double);

double 8afe_division ( double, double):
double result, numer, denom, term;
/• if person enters 2B instead of .25 for 2By, , convert to fraction »/

if ( interest > 1.0)
interest /= 100.0;
/* compute intermediate terms in equation */

term « pow ( 1 + interest / 12.0, months);
numer (interest / 12.0) * term;
denom term - 1
/* compute monthly mortgage */

result - safe_division ( numer, denom)
return ( mortgage * result)
/* double compound.interest ( double principal, double interest,

double frequency, double years)
Compute compound interest on a principal, given: the principal,

annual interest rate, frequency of compounding, and number of years.
Formula: principal » term ' (freq * yrs)
where term 1 + interest / freq;
CALLS : powO, safe divisionO

GLOBALS :
PARAMETERS :
double principal starting amount :
double interest annual interest rate

:
double frequency frequency of compounding / year

:
double years number of years

:
RETURNS amount of interest

:
USAGE : result ' compound interest ( princ interest, frequency, years);,
*./
double compound.interest ( double principal, double interest,

double frequency, double years)
double result, term: /* term used for intermediate values •/

double safe. division ( double, double):
/• 11 person enters 26 instead of .25 for 25X, convert to fraction */

if ( Interest > 1 .0)
interest /- 100.0:
/* compute intermediate terms */

. ; ; ;
358 Using QuickC
term 1 + safe.divislon ( interest, frequency);

result • pow ( term, frequency * years);
return ( principal » result - principal);
/* double annuity ( double deposit, double interest, double years)
Computes amount of an annuity, given: annual deposit,

annual interest, years.
Formula: deposit • term / interest
where term " (1 + interest) " years - 1;
CALLS : powO safe.divisionO

,
GLOBALS :
PARAMETERS :
double deposit initial deposit :
double years number of years building annuity

:
RETURN annuity amount

:
USAGE : annuity_amt - annuity ( deposit, interest, years);
double annuity ( double deposit, double Interest, double years)
double result term ,

double safe.division ( double, double);
/• if person enters 26 instead of .25 for 25%, convert to fraction */

interest /« 100.0;
term " 1 + interest;
result - pow ( term, years) - 1;
return ( deposit result / interest)
/• double annuity_deposit ( double total, double interest, double years)
Computes annual deposit required to get a specified annuity, given:

desired total, annual interest, years.
Formula: total * interest / term
where term = (1 + interest) " years - 1;
CALLS : powO, safe.divisionO

GLOBALS :
PARAMETERS :
double total desired annuity :
double years number of years building annuity

:
RETURN annual deposit required to reach desired annuity

:
USAGE : deposit = annuity.deposit ( total, interest, years);

*/
double annuity_deposit ( double total, double interest, double years)

{
double result, term;
double 8afe_division ( double, double);
/* if person enters 25 instead of .26 for 257., convert to fraction */
interest /• 100.0;
/* compute Intermediate terms */

term 1 + interest;
result pow ( term, years) - 1;
return ( total * interest / result)
Using Debugging to Checit

Intermediate Values
Several of the functions in this section compute intermediate values on the way
to returning the desired value. Sometimes it can be helpful to check these
intermediate values, so you can follow the solution more easily, or because you
need to show your work.
Rather than embedding printf( ) commands throughout your source
code, you can use QuickC's debugging facility to watch the variables asso-
ciated with these intermediate values. For example, to check the values of term
and result in annuity _ deposit( ), you just need to compile the program with
the Debug option on, add term and result as watch variables, and set break-
points at the lines assigning values to these variables. Then step through the
program, noting the values of term and result at the appropriate times.
Recursion
Earlier, you learned about the flow of control when a program is executing and
when functions are called. Essentially, when main() (or any function) calls
another function (let's say, speciali$t( )), execution of main( ) is suspended
temporarily while specialist( ) executes. When specialist( ) finishes, control
returns to main( ).
Now, suppose that specialist(), itself, calls a third function (let's call it
superspecialist( ) ). Execution of specialist( ) pauses while super$pecialist( )
does its work. Thus, while superspecialist( ) executes, there are two other
functions temporarily on hold in our example. If the program terminates
normally, these suspended functions will eventually be completed.
A recursive function is, in some ways, the ultimate specialist. It calls itself
to do part of its task. This means that one version of the function is put on
hold, while a different version is activated.
•
A recursive function takes a task. If the task is simple enough to be solved
right away — that is, if there is nothing left to do — the function solves itand
returns control to the calling function. On the other hand, if there is still work
to be done, the function calls a copy of itself to work on a slightly easier version
of the function. This continues until one of the calls occurs with a simple
enough version of the problem.
Let's look at a few examples. The
example simply counts to the first
desired number, displaying some information about where the program is in

;; ;;
360 Using QuickC
the recursion. The recursive function, count( ), checks whether the parameter
is 1,which case the function displays the value of its parameter. If the
in
parameter is not the function calls itself with an argument one less than the
1 ,
parameter that was passed to it. Thus, if count( ) is called with a parameter
other than 1 , versions of count( ) will be put on hold, while other versions work
on a simpler task. Eventually, the parameter passed to a version of count( ) will
be at which point the function can display its value and return control to the
1 ,
function that called it. Here is our first example:
/ Program to count recursively, and also to write information about

current level of recursion.
Program illustrates recursive function call.
*/
#include <stdio.h>
int level;
void count ( int val)

{
/ Write some information about the level of recursion. */
printf ( "Starting count, level %3d; val 5i3d\n" ++level, val); — .
/* the actual recursion occurs if the condition is true.

Otherwise, control simply passes to the next statement.
*/
if ( val > 1)
count ( val - 1)
/* Main task line for function count ().

After a return from another call to countO, control returns
to this point.
»/
printf ( "\t\t\t\t**** Displaying val: y,3d\n" , val);
/* Write some more information about the level of recursion. */

printf ( "Leaving count, level '/.Sd; val »= '/.3d\n" level--, val); ,
main ()
void count ( int)

int how.high;
printf ( "Count to what value? ");

scanf ( "Xd". ihow.high)
level - 0;
count ( how.high)
For an input of 4 for how _ high, the program produces the following output:
Count to what value? 4

Starting count, level 1; val — 4
Starting count, level 2; val - 3
Starting count, level 3; val -- 2
Starting count, level 4; val •" 1
•** Displaying val:
Leaving count, level 4; val — 1
»*•* Displaying val:
Leaving count, level 3; val 2
•*** Displaying val:

Leaving count, level 2: val 3
**** Displaying val:
Leaving count, level 1; val -'
This program counts to the desired number, but also displays some adminis-
trative information to help us see what happens in recursive calls. Let's look at
the output first, to see how the recursion process works.
The program begins executing in main( ). This function calls count( ) with
an argument of 4. At this point, main( ) is on hold, and count( 4) begins
executing.
The function count( 4) displays information about level of recursion. The
function then checks whether it can do parame-its work — that is, whether its
ter has value 1. Since 4 != 1, the function calls count( ) with an argument of 3.
At this point, main( ) and count( 4) are on hold, and count( 3) begins execut-
ing. Notice, count( 4) has not yet done its main task, which is writing the
"displaying" line.
Just as its calling routine did, count( 3) displays information about level
of recursion. The function then checks whether it can do its work — that is,
whether its parameter has value Since 3 != the function calls count( ) with
1 . 1 ,
an argument of 2. At this point, main( ), count( 4), and couni( 3) are on hold,
and count( 2) begins executing.
Just as the two previous calls to count( ) did, count( 2) displays informa-
tion about level of recursion. The function then checks whether it can do its
work — that is, whether its parameter has value 1 . Since 2 != 1 , the function
calls count() with an argument of 1. At this point, main(), count( 4),
count( 3), and count( 2) are on hold, and count( 1) begins executing.
The function count( 1) displays its information about recursion level.
This time, however, the test condition for the if statement fails. Control thus
passes to the next statement in the same function, which turns out to be the call
to priiitf( ) for officially displaying the value of val. Before leaving, count( 1)
writes some additional information about level of recursion. Control then
transfers back to its calling function, namely count( 2).
Notice that the last version of count( ) called was the first version to do
any work. One feature of recursive function calls is that the last version called
is the first one to do its work. The last one called is, therefore, also the first one
io finish its work. You can see this in the output from the program.
The function count( 1) writes the recursion level (4) when the function
starts. The function then displays its value for val, namely, 1. Finally, the
function writes its recursion level as the function finishes.

;
362 Using QuickC
When control transfers back to count( 2), this function continues execut-
ing at the next statement — namely, ils call to printf( ) to display the value of
val. Notice that the value written this time is 2. You would expect this, since this
value was passed in as a parameter, and since the parameters are merely being
passed by value (rather than by reference) in the function. This means that,
while count( 1) was executing, there were 4 versions of val allocated — one for
each call to count( ). The versions do not interfere with each other, since each
version has a scope local to the function itself, and since different calls to the
same function are essentially different functions.
After count( 2) writes its value and its recursion level information, the
function transfers control back to its caller. Notice that count( 2) was the
second to last function called and is the second function finished. The same
process is repeated for count( 3) and for count( 4). Again, notice that
count( 4), the first function called, is the last to finish.
^REMEMBER In recursive function calls, the function versions finish their

work in the reverse order in which the functions were called; the first version of
the function called is the last to finish and the last to be called is the first to
finish.
Before we look at another example, let's look at the unembellished form

of the recursive function in the preceding program:
/* Unembellished version of recursive count () function •/

{
/* the actual recursion occurs if the condition is true.
Otherwise, control simply passes to the next statement.
*/
if ( val > 1)
count ( val - 1)
/* Main task line for function countO.

After a return from another call to countO, control returns
to this point.
•/
printf ( "\t\t\t\t**** Displaying val: y.3d\n", val);
Without the statements that write information about the recursion level,
this function turns out to be very simple. A recursive function must include the
following types of statements:
1. The statements needed to carry out the task of the function. In the
preceding function, this would be the call to printf().
: . .
2. A test to determine whether the function can avoid calling itself
again — that is, to determine whether the function can simply do its
work and terminate. In the preceding function, this is the if statement

testing whether (val > 1).
3. A statement that calls the function itself This call must be made with
parameter values that will eventually make the test condition take on a
value that will bypass the recursive call. In the preceding function, this
is accomplished by calling the function with arguments that approach
the termination value of 1
The function must test whether a recursive call is necessary before making
such a call. If you write your function so that the function calls itself first, then
tests whether it's all right to stop, the function will never terminate. Thus, the
following version of the recursive function will never terminate:
/• Incorrect recursive function */
/• NOTE: DO NOT USE THIS VERSION OF THE RECURSIVE FUNCTION.

This version will terminate In a run-time error.
•/

{
/• The recursion occurs first In this version.
The function will keep calling Itself, so that no version
of the function will ever get to test whether it can stop.
The program will eventually terminate with a run-time error.
•/
count ( val - 1)
if ( val > 1)
prlntf ( »\t\t\t\t»*»» Displaying val: X3d\n" , val);
Similarly, the following version of the function is incorrect because the

value of val used in each call is moving away from the termination value of 1
This version will also end in a run-time error.
/* Incorrect recursive function */
/* NOTE: DO NOT USE THIS VERSION OF THE RECURSIVE FUNCTION.

This version will terminate in a run-time error.
•/

{
if ( val > 1)
count ( val +1): /• val IncreaBes, so it won't terminate */
; ; ; ; ; ;
364 Using QuickC
/* Main task line for function countO.

After a return from another call to countO , control returns
to this point.
*/
printf ( "\t\t\t\t***« Displaying val: X3d\n" , val)
^REMEMBER A recursive function must always test whether it can stop

before calling another version of itself If a recursive call is made, the parame-
ters in some call should eventually have values that will make further recursive
calls unnecessary.
The following program calls a function, recurse_reverse( ), to print the

reversed form of a string:
/* Program to reverse a string and display it.

Program uses a recursive function to reverse and display the line.
ttinclude <atdla.h>
#define NULL.CHAR 'NO'
»define MAX.STR 80
/• reverse a line, and display it backwards. */

void recurse.reverse ( char •str)
<
/* If the next character is NULL.CHAR, do nothing.
Note that the condition increments the pointer value,
BO the "new" string is actually one character shorter.
Thus, if the original string was "hello",
the new string would be "ello".
NOTE: the test condition increments the current position
in Btr BEFORE testing. Thus, the version of str passed in the
recursive call starts one character into the string.
For example, if str •
"hello", the argument to the recursive
call "
''ello".
•/
if ( •(++Btr) !- NULL.CHAR)
recurse.reverse ( str)
/* NOTE: The current position of Btr is decremented BEFORE writing.

This is because the if test had incremented the position before
the recursive call. This decrement essentially restores str to
the value it is supposed to have in the current version of the
function.
For example, if the value of str "hello" coming into the
function, then this version of the function is responsible for
writing the 'h' NOT the 'e'.
*/
printf ( "y.c", *(--8tr))
}
mainO
void recurse.reverse ( char *);
char curr.str [ MAX.STR]
printf ( "? "):

gets ( curr.str)
printf ( "XsXn" curr.str).
recurse.reverse ( curr.str)
The function works by checking whether it is positioned before the null

character. If so, the function writes the current character. If not, the function
moves forward one character in the string and calls itself with the shortened
version of the string. Each successive call to recurse reverse( ) works with a
shorter string. Eventually, the function must be called with a single character
string. The following illustration summarizes the calls and the values of
*{++str) and *( str) after each call;
Inside called function
Calling function Called function (++str) *(--Btr)
main () recurse. reverse (hello) e h

recurse.reverse (hello) recurse.reverse (ello) 1 e
recurse.reverse (ello) recurse.reverse (llo) 1 1
recurse.reverse (llo) recurse.reverae (lo) o 1
recuTBe.reverse (lo) recurse.reverse (o) \0 o
Costs of Recursion
Recursive functions can make your code much more compact and easy to
read, but not necessarily more efficient. In fact, sometimes recursive versions
of a function can be very inefficient. In this section, we'll look briefly at an
example of a recursive function that becomes more inefficient as the values
used increase. If you don't feel comfortable with the numbers used here, don't
worry. The main point is to give you an idea of how the number of recursive
calls can grow. The example also shows that you can make more than one
recursive call in a function.
The following program uses a recursive function to compute a Fibonacci
number. Fibonacci numbers are elements in a mathematical series that seem to
occur in all sorts of situations. The definition of a Fibonacci number is simple
but recursive.
The two Fibonacci numbers, fib( 1) and fib( 2), are defined as I.
first
Subsequent Fibonacci numbers are formed by adding the two preceding

Fibonacci numbers. Thus, fib( 3)==fib( 2)+fib( 1)== + == 2. Table 1 1
12-2 lists the first few Fibonacci numbers.

The following program computes the desired Fibonacci number The
program starts to become quite inefficient after about the twentieth Fibonacci
number.
366 Using QuickC
Table 12-2. Fibonacci Numbers
Number Value
nb( 1)
; ;;
The following program records each call to the fib( ) function. Otherwise,
it is identical to the preceding program.
/• Program to compute a specified Fibonacci number.

and also to keep track of the number of recursive calls
Program also illustrates recursion.
•/
•Include <Btdlo.h>
•include <nath.h>
long nrcalls 0;
long fib ( int x)

{
nrcalls +" 1;
if ( X > 2)
return ( fib ( x - 1) + fib ( x - 2));
else
return ( 1)
}
main ()
<
long fib (int), fibans;
int seed;
printf ( "Number? ")

scanf ( "Xd" tiseed)
,
fibans • fib ( seed);

printf ( " fib (X7d) -- Xld; ". seed, fibans);
printf ( "X71d calls to fib()\n", nrcalls);
The program produces the following outputs for selected Fibonacci

numbers:
Number? fib (10) -- 55 109 calls to fibO

Number? fib (20) ~ 6765 13529 calls to fibO
Number? lib (30) ~ 832040 1664079 calls to fibO
Notice that the number of calls gets unacceptably high for even a rela-
tively small value of seed.
It is always possible to accomplish a task in a nonrecursive way. The

trade-offs are efficiency of coding and efficiency of execution. For example,
the following version of the fib( ) function will compute Fibonacci numbers
nonrecursively:
/* Non-recursive version of Fibonacci function. •/
long fib ( int x)
long fl - 1. /• fib ( n - 1) »/
12-1. /• fib ( n - 2) */
368 Using QuickC
curr.fib; /* current value of fib */

int index;
if ( X > 2)
{
/* cases 1 and 2 are handled by the else *t
for ( Index » 3; index <» x; index++)
{
curr_fib = fl + f2;
/* as index increases, fl becomes f2, and
curr fib becomes fl.
*/
f2 - fl;
fl " curr.fib;
}
return ( c\irr_f ib) ;
>
else
return ( 1);
In this section, we've only been able to introduce some of the main
concepts associated with recursion. We'll see more examples in Chapter 17.
You may want to consult other sources. The C Library, by Kris Jamsa (Osborne/
McGraw-Hill, 1985) has a chapter on recursion, and includes numerous
additional examples.
Summary
In this chapter you learned more about functions, and learned some proce-
dures for error handling. The chapter also provided some additional examples
of C source code, including two short programs for exercising some special-
ized but useful functions.
In the next chapter, you'll learn about a variant of the main( ) function
that includes parameters. You'll learn how to write programs that allow you to
specify options on the command line when invoking the program. In the
process, you'll get another exercise program you can add to or adapt to your
needs.
13
Command Line^
Arguments
Under many operating systems, including DOS, you start a program simply by
typing the program's name. Thus, to start QuickC, you can type
and press RETURN. At that point, the QuickC environment will start up,
placing you in a file named untitled.c.
You can also start up QuickC with various options, including a file name.
For example, suppose you wanted to edit, then compile the contents of the
string exercising program from the previous chapter. Suppose this program
was in a file named str.c.
The following command line will start QuickC and will immediately put
you in the str.c file, ready for editing:
qc 8tr
369
370 Using QuickC
assume you had the finance exercising program in a file named

Let's
finance.c; some of its functions should be taken from the Quicit library,
qcstuff.qlb. You could use the following command line to invoke QuickC, tell
the compiler to refer to the qcstuff.qlb Quick library, and tell the compiler that
you want to work with the file finance.c.
qc /Iqcstulf finance
So, we've seen three different ways to call up the QuickC program. Each
invocation puts you into a somewhat different mode. These three ways repre-
sent only a small fraction of the options you can specify when invoking the
program. QuickC is a very flexible program, capable of operating in different
ways.
This chapter will discuss how to give your programs the same kind of
flexibility.
main( ) as Program
and as Function
You've seen that C programs start executing at the function main( ). If a
program terminates normally, the program ends when main( ) has finished
executing. In a sense, main( ) is the program. On the other hand, because the
main( ) function can be put anywhere in the program, it doesn't really look any
different from other functions. In this sense main() is just an ordinary func-
tion.
Functions, as you know, can have parameters. You can define a niain( )
function with parameters. However, C restricts main( ) in the number and

types of parameters it can have, as we'll see.
Ifyou define niain( ) with parameters, you are essentially passing parame-
ters to the program, since main() will start executing. Thus, the qc str
command invokes the QuickC program with the name of a file as a parameter.
c
Command Line Arguments 371
What Are Command Line Arguments?
When you interact with the operating system, you are generally giving com-
mands of one sort or another. We've already seen that typing a program's name
amounts command to run the program. A line containing such a
to giving a
command is called a command line.
As the examples above and your own experience should demonstrate, you
can specify more than just a program name on a command line. Such
additional terms on a command line are known as command line arguments.
Command line arguments are separated by blank spaces. Thus, str was a
command line argument for the qc command; /Iqcstuff and flnance were
command line arguments for qc in another example.
You may have been using command line arguments all along, perhaps
without even knowing that you were doing so. All of the following examples
include command line arguments:
A> copy finance. c b:
A> diskcopy a; b:
A> type finance.
A> cat filel file2 fileS file4
A> tex chl3
A> qc /Iqcstuff /b
The first of these copies the file finance.c from the current directory to the
same name on a disk in drive B. In addition to the program name (copy), there
are two command line arguments (finance.c and b:). The second command,
diskcopy, also has two command line arguments (a: and b:). The next example
has only one argument in addition to the program name. The following
example actually has four command line arguments, besides the program; this
command displays the contents of each of the four files on the screen. Finally,
the last example invokes QuickC, using the qcstuff.qlb Quick library, and
rur\ning theprogram on a monchrome monitor.
Eventually, you will learn to write your C programs so that you pass the
372 Using QuickC
programs such command line arguments. This is a powerful facility that
allows you to build flexible programs.
Command Line Arguments in DOS

Before looking at how to command line arguments in your C
implement
programs, let's look at a few examples of command line arguments with some
DOS commands. If you're familiar with DOS, these examples may give you a
better insight into how DOS works. If you're new to DOS, you can read these
examples for information about how the programs work.
The echo Command

The DOS echo command displays messages on the screen. You'll generally use
echo in batch files (files consisting of DOS command sequences), to provide
certain messages as the commands in the file are being carried out. The
following batch file (let's call it showecho.bat) provides an example:
echo This line and the same line without the echo will be written
If you type showecho or showecho.bat at the DOS prompt line (let's say,
A>), the following will appear on the screen:
A> echo This line and the sane line without the echo will be written
This line and the same line without the echo will be written
You can also use echo in other ways, and we'll look at these different uses
of echo to find out how the command works.
echo with No Arguments If you type echo at the DOS prompt, the
following message will appear on your screen:
ECHO is on
This tells you that DOS is in its defauh mode, which echoes (or displays)
whatever you type and whatever DOS has to say to you.
When you itself, DOS checks whether or not the default
type echo by
mode is to echo input and other information. Thus, if DOS finds no command
line arguments for the echo command, the response is to tell you whether the
echo mode is on or off
echo with On or Off If DOS prompt,

you type echo on or echo off at the
or if you include one of these command lines in a batch file, DOS will change
its setting for the echo mode to the specified value. Thus, if DOS reads either
"on" or "off" as the first command line argument, the echo mode is set to the
specified value.
echo with a String If you type echo followed by an ordinary string at the
DOS prompt, two lines (such as those in the first echo example) will be
displayed on your screen. Thus, if DOS sees a sequence of characters, not
starting with either"on" or "off," the remainder of the command line is
interpreted as something to be displayed. (There are certain characters that
will make echo do additional processing, but we won't get into them here.)
Depending on how you give the echo command, DOS will take different
actions, and will interpret the contents of the command line differently. You
don't need to worry about how DOS does this. Essentially, DOS checks a
certain area of memory for anything you might have typed on the command
line. Based on what, if anything, it finds there, the echo command does what
you've asked.
The dir Command

The dir command gives you a listing of and directories. You can ask for
files
such a listing by simply typing dir, or you can include command line argu-
ments to elaborate your request.
dir with No Arguments If you just type dir, DOS will list the files and
directories contained in your current directory. DOS interprets the absence of
command line arguments as an instruction to display the contents of the
374 Using QuickC
directory in which you are currently working, and to use the defauU directory
display mode.
Thus, typing dir at a DOS prompt produced the following listing:
Volume in drive C has no label

Directory of C;\BK\SRC
dir with Switches You can also control the way in which the contents of a
directory are displayed. DOS allows switches to specify certain processing
options. Switches usually begin with a predefined character (/ in DOS and —
in UNIX), and are used to tell a command orprogram what options you want
to use when invoking the command.
The DOS dir command can understand two switches, /p and /w. The/p
switch tells DOS to fill the screen with directory entries, then to pause until the
user presses a key. The following command line leaves the partial directory
listing below it on the screen:
C:\BK\SRC> dir chl2 /p
<DIR> 7-08-87 3:05p

<DIR> 7-08-87 3:0Bp
1 C 1390 7-20-87 3:27p
2 C 211 7-20-87 3:27p
3 C 554 7-20-87 3:27p
4 C 878 7-20-87 3:28p
B C 306 7-20-87 3:28p
6 C 1170 7-20-87 3:28p
7 C 231 7-20-87 3:28p
8 C 568 7-20-87 3:28p
9 C 2378 7-20-87 3:28p
10 C 568 7-20-87 3:28p
11 C 565 7-20-87 3:28p
12 C 628 7-20-87 3:29p
13 C 175 7-20-87 3:29p
14 C 168 7-20-87 3:29p
15 C 489 7-20-87 3:29p
16 C 293 7-20-87 3:29p
17 C 643 7-20-87 3:29p
18 C 392 7-20-87 3:29p
19 C 295 7-20-87 3:55p
20 C 225 7-20-87 3:29p
21 C 209 7-20-87 3:29p
Strike a key when ready . . .
This command line tells DOS to display the contents of the directory
chl2, contained in the current directory. The /p switch tells DOS to pause
when the screen is filled, until the user presses a key.
After a key is pressed, the remainder of the listing is displayed.
DOS looks for a / in the command line arguments. If the line contains
such a character, DOS checks the character after it and acts according to the
intei'pretation it gives that character. A switch can be a separate command line
argument, or it can be at the end of a command line argument. Thus, the
following command — which leaves no space between the directory name and
the switch — would have the same effect as the command in the previous
example:
C;\BK\SRC> dir chl2/p

)
)
376 Using QuickC
The /w option tells DOS to list only the file names and extensions,
writing five names on each line displayed. Using a /w switch in the previous
example would produce the following listing:
C:\BK\SRC> dir chl2/p/w
Volume In drive C has no label

Directory of C:\BK\SRC\CH12
42 File(s) 1882112 bytes free
In this case, the /p switch has no effect, since the listing is not long enough
to fill the screen. Notice that DOS processes each switch included on a
command line.
Switches are a commonly used technique for letting users control the way
aprogram is to work. You will come across switches in many contexts, and will
probably find yourself using them in your own programs.
Arguments to main(
The basic strategy for writing a C program capable of handling command line
arguments is to pass the arguments to main( ) as strings. Once inside, it will
become the program's responsibility to interpret the arguments appropriately.

Let's look at an example. Assume that the following program is in a file named
argdemo.c:
/* Program to illustrate use of parameters with mainC) */
main ( int argc , char *argv []

<
if ( argc > 1) /* if there is a command line argument */
{
printf ( "At start of program, argc -- Xd\n\n". argc):
: .
/* write the appropriate strings from the argv array •/

while ( argc-- > 1)
prlntf ( "argc -• %d: argv [ Xd] •- XsXn"
argc argc
, . argv [ argc ] )
If the executable version of this program were named argdemo.exe, the

following command line would produce the output below it in the listing. The
command line includes a program name and five command line arguments.
argdemo you? are How there. Hello
At start of program, argc "" 6
argc "5
; ,
378 Using QuickC
cleanly whether you've processed all the arguments.

The following listing illustrates this, using a variant of the preceding
program:
/* Program to illustrate use of parameters with malnO */

main ( int argc, char *argv [])
{
int index • 0;
if ( argc > 1) /* if there is a command line argument */
printf ( "At start of program, argc •• y,d\n\n" , argc);
/ write the appropriate strings from the argv array;

stop when the empty string is reached.
*/
while strlen (argv [ ++index]) > 0)
"
(
printf ( "index Xd; argv [ %il •• %s\n"
index index argv [ index ] )
. .
The following command line produces the output shown below the
command line:
argdemo2 Hello there. How are you?
At start of program, argc « 6
argc -" 1: argv 1] == Hello

" "
[
argc 2: argv 2] there,

"
[
argc 3: argv 3] "- How
" "
[
argc 4: argv 4] are

"
[
argc 5: argv [ 5] »» you?
This program writes the command line arguments, but writes them in the
order the arguments were entered on the command line. Internally, the
program moves forward in argv[] — that is, toward higher subscripts.

Notice the continuation condition for the while loop. The loop stops after
the last command line argument has been written — when the empty string
that indicates the end of the argv[ ] array is encountered.
and argv[ ], are just conventional
Incidentally, the parameter names, argc
identifiers used for arguments to main( ). The names derive from argument
count and argument values, respectively. You can, of course, name them
anything you want.
Elements 1 through argc — 1 in argv[ ] correspond to the command line
arguments. What about argv[ 0]? That depends on the operating system in
) ; ;
which you're working. In some environments (including DOS 3.0 or later), the
first string in the argv[ ] array contains the program's name. This is not the case
\ -'th earlier versions of DOS.
^REMEMBER Strings in argv[ 1] through argv[ argc — 1] correspond to

command line arguments. In most implementations, argv[ 0] points to the
program name.
Using Parameters to main()

Let's look more closely at what you've just seen. You can define the main( )
function with either zero or two parameters, if you define the function with
two parameters, one must be an int and the second must be an array of strings
(array of pointers to char).
word on the command line is treated as a separate
In this context, each
string, thusbecoming a separate command line argument. Blanks separate
words from each other. The int parameter specifies the number of words on the
command line, including the program name. This value will always be at least
1, because points to the program name.
Although you can have only two parameters to main( ), you can have
virtually any number of command line arguments. This is because one of the
arguments is an array that can be of variable size. The actual number of
command line arguments supported is always operating system dependent.
The fact that the array elements must be strings is not a real limitation, as
some examples will show. You can enter numerical values on the command
line, read them as strings, then convert them to numerical form. The following
program illustrates this:
/* Program to illustrate use ol parameters with mainO

and use of conversion function atofO.
•/
#include <stdlib.h> /* for atofO */
main ( int argc , char targv []

{
double fahr_to_cent ( double);
double cent_to_f ahr (double)
double temperature, result;
double atof ( const char *)
if ( argc *- 3) /* if there's a 3 element command line argument •/

<
; , ; ;
380 Using QuickC
temperature • atof ( argv [ 2]

—
)
if ( argv [ 1][0] -f)
{
result f ahr_to_cent ( temperature)
printf ( "1.6. 211 F 5i6.21f C\n",
temperature, result);
y
else
<
result cent_to_f ahr ( temperature)
printf ( "X6.21f C ~
X6.21f F\n"
temperature, result);
>
> /< If 2 command line arguments */
else
printf ( "Usage : temp <'f' I c'> <temperature>\n")
double fahr to cent ( double fahr)

{
return ( ( fahr - 32.0) * (5.0 / 9.0));
}
double cent.to.fahr ( double cent)

{
return ( ( cent * (9.0 / 5.0)) + 32.0);
}
For each of the following calls to the program temp, the program pro-
duces the outputs below them:
temp f 98.6
98.60 F •= 37.00 C
temp c 100
100.00 C •" 212.00 F
temp f
Usage : temp <'f' or 'O <temperature>
This program reads the command line arguments as strings, just as in the
earlier examples. The program then calls the QuickC library function, atof( ).
This function converts a string argument to a floating point type, and returns
this as a double. Thus, the function lets you read numerical information into
your programs. The stdlib.h header file is needed to make atof( ) usable in your
programs.
Notice how we referred to the first letter in argv[ 1]: as element in this
array, or argv[ 1][ 0].
Learning About Functions in Quicl<C One of QuickC's handiest facilities
is its on-line help with C and with the available library functions. Use this
facility to find out about atof( ). To get on-line information about the library
function atof( ):
;
1. Press the Fi key to get the Help dialog box.
2. Press K to get the C keywords list.
3. Use the arrow keys to move the cursor downward, and select the Data
Conversion label from the list.
4. Select atof( ). Notice that there are other functions, with similar names:
atoi( ), atol( ).
5. Press RETURN.
The top part of the screen will contain information about the function,
including any header files required, a prototype for the function, and a brief
summary of its purpose.

Notice the prototype for the function,
double atof ( const char •<strlng>)
contains the keyword const before the declaration for the string parameter.
This keyword is a type specifier, and indicates that the lvalue associated with
the specifier cannot be modified. In this case, the const specifier makes the
parameter that is being declared a constant. This arrangement protects against
undesirable changes to the parameter that might surprise the calling function.
You can use the const specifier in conjunction with other type specifiers
(such as int, double), in definitions or declarations. The following two defini-
tions are equivalent:
If you define a const variable without specifying a type, the variable is
assumed to be of type int.

By looking at QuickC's on-line help, you can also find other functions
related to the one you're inquiring about. For example, in searching for help
about atof( ), you will come across atoi( ) and atol( ), which convert strings to
int and long, respectively.
Another Example Involving Conversions Let's look at a more complex
example, where the number of command line arguments may vary drastically
: ); ; ;
382 Using QuickC
each time you run the program. The following program uses one of the
functions mentioned in the last chapter, int mean():
/* Program to Illustrate use of parameters with mainO

and use of conversion function atolC).
*/
#lnclude <stdllb.h> /* for atolO */

#deflne MAX.SIZE 30
main ( int argc , char *argv []

{
double int_mean ( int [] int) ,
double result
int atoi ( const char *);
int index « 0;
int values [ MAX.SIZE]
while strlen ( argv [ ++index]) !» 0)

(
values [ index - 1] = atoi ( argv [ index]);

if (index > 1)
result " int.mean ( values, --index);
else
result - 0.0;
printf ( "mean =« XlO.Blf, # of values =" y,2d\n" result, index); ,
/* compute mean of an array of integers */

double int mean ( int vals [] int array_size) ,
{
int count:
double running. sum- 0.0;
for count " 0; count < array. size; count++)

(
running. sun +" vals [ count]

return ( running. sum / array. size) ;
This program computes the mean of a collection of int values which have
been entered on the command line. In this program, you can enter up to 30
values. In DOS, there is a limit to the number oi characters a command line
can have ( 127 bytes). This will indirectly determine how many arguments you
can pass to a program. If you think this restriction may cause problems in your
programs, check the documentation for your operating system to find out
more about the command line, and the possibility of increasing its size.
A Program to Exercise Command

Line Arguments
The following program lets you convert from any of several units to another.
The program also illustrates the use of parameters to main( ). The program
checks the number of command line arguments, and acts accordingly.
) ; ,
To run the program, convert.exe, you can simply type the

program name
or you can pass up to two command Hne arguments a starting unit and a —
starting value. If you enter both a starting unit and a value, the program
immediately computes the answer for you. If you enter just a starting unit (one
command line argument), the program asks you for a value. If you simply type
the program name, with no arguments, the program prompts you for both a
conversion and a value.
The program uses include files, to make it somewhat easier to read and to
indicate more clearly the portions of the program that are related to each
other. The functions for converting between units are read in from file units.c.
Some general utilities used in this program are in a file named utils.c. The
header files (those with the .h extension) are read in so that certain functions
will work properly. The following listing contains only the main program file;
the listing does not include the source for the conversion functions.
The main program action occurs in two switch statements. The one in
main( ) acts on the basis of the number of command line arguments. The
second switch statement, in handle all values( ), acts on the basis of the
conversion requested by the user.
/* Program to convert values from one unit to another.

User provides a unit, using either the full name of the
unit or a common abbreviation;
user also provides a value to convert.
Program returns the corresponding value in the new unit.
USAGE convert <<8tarting unit>} {<value>}
:
where both arguments are optional, but

a value must be preceded by a starting unit.
Program also illustrates use of parameters with mainC)
*/
ffinclude <stdio.h>
#include <math.h> /* needed for atofO »/
ftinclude "units.c" /• contains unit conversion functions •/
înclude "utils.c" /* contains miscellaneous utility functions */
#define INVALID VAL -B9S99.999

#define MAX STRING 80
#define MAX_UNITS 30
tdefine NULL.CHAR AG'
/* array of strings containing the valid names and abbreviations for
units recognized by the program.
MOTE: Add new names to the end of the array, since the function
calls are based on the position of a name in the array.
*/
char •units [ MAX.UNITS] - {"eel", "centig" "centim". "cm", "f ahr"
.
"gm", "gram", "in", "kg", "kilog".

"kilom", "km", "lb", "pou" "liter", ,
"mi", "ou", "oz", "qt", "quart"}:
char start.units [ MAX. STRING] ; /* abbreviation for starting units •/

char end.uiiits [ MAX.STRING] ; /• abbreviation for ending units »/
main ( int argc , char 'argv []

<
void make_str_lower ( char •)
; . ; ;
384 Using QuickC
double get.dbl ( char •)

double handle.all. values (Int, double):
int what.case ( char *, char*[], int);
int conversion:
double answer, value:
char which.unit [ MAX. STRING] :
,
/* handle 0, 1, or 2 command line arguments, in cases 1. 2. 3 */

switch ( argc)
{
case 1 /• command line arguments; just program name •/
/
:
/* go into complete prompt mode

/* get starting unit •/
printf ( "Convert from what unit? ");
gets ( which.unit)
nake.str.lower ( which.unit)
/* get starting value */

value get.dbl ( "Value? ");
/* determine the conversion desired */

conversion what.case ( which.unit. units. 20);
/* compute the result */

answer " handle.all.values ( conversion, value);
break;
case 2 : /* 1 command line argument: just starting unit */
/* got conversion, but no value; prompt tor value */
/* get starting value */
value = get.dbl ( "Value? ");
/• prepare argument lor checking */

make.str.lower ( argv [1]);

conversion what. case ( argv [ 1]. units. 20);
/* compute the result */

answer • handle. all. values ( conversion, value);
break;
case 3 : /* 2 command line arguments */
/• got conversion and value */
/* prepare argument lor checking */

make.str.lower ( argv [1]);
/* convert argument to a double */

value - atol ( argv[ 2]);

conversion what.case ( argv [ 1], units, 20):
/• compute the result */
answer handle. all.values ( conversion, value):
break:
default :
break;
y
printf ( "XlO.Blf Xs -- XlO.Blf Xs\il" .
value, start units, answer, end.units)

} /* END mainO */
/* int what.case ( char *str, char *table [] int how.many) ,
Determine what conversion is being asked for.

*/
,, , ; ; ; ; ; ;; •
int what.case ( char *str. char ttable int how.many)

[] ,
int Index;
lor ( index - str.pos ( str, table [ index]) !- 0) 4t

0; (
index < how.many); index++)

(
• /• do nothing */
If ( index >- how.many) if no match was found */ /
return ( -1);
else
return ( index) ;
} /* END what.caseO */
/* void assign.units ( char *start, char *flnish)

Store the appropriate units in the globals start.unit
^^ and end.unit
void assign.units ( char *start, char *linish)
Btrcpy ( start .units, start);

strcpy ( end.units, finish);
/• double handle.all.values (int conversion, double value)

call the required conversion function and return the
conversion
double handle.all.values (int conversion, double value)
/ function prototypes */
double cent.to.fahr ( double), fahr to cent ( double)-
double cm.to.inch ( double) inch to.cm ( double) ,
double gm.to.oz ( double) .to.gm ( double)

double kg.to.lb ( double), Ib.to.kg ( double);
double km.to.mi ( double) mi.to.km ( double)
double qt.to. liter ( double) liter.to.qt ( double);
void assign.units ( char *, char •)
double result;
/• switch on conversion selected

switch ( conversion)
/
{
default:
printf ( "I don't recognize that unit. ");
printf ( "Leaving program. \n")
exit (0);
case :
case 1 :
assign.units ( "C", "F")

result cent.to.fahr ( value);
break;
case 2 :
case 3 :
assign.units ( "cm", "in");

result cm.to.inch ( value)
break;
case 4 :
assign.units ( "F", "C");

result - f ahr.to.cent ( value)
break;
case 5 :
case 6 :
assign.units ( "gm", "oz");

386 Using QuickC
; : ; ) ; ;
To complete our discussion, let us consider the contents of the two

function files read in at the start of the conversion program. The following
listing contains the functions from utils.c:
/* include file containing some miscellaneous utilities used in the

unit conversion program.
*/
#include <ctype.h> /* needed ior tolowerO macro »/
/* int Btr_pos ( char str [] char substr []

,
returns the subscript value of the first occurrence of substr inside str.
Returns -1 if substr is not found in str.
*/
int str.poB ( char str [] . char substr [])

{
int start, current, sub.current;
/* see whether substr begins at each value of start */

for ( start " 0; str [ start] != NULL.CHAR; Btart++)
/* compare substr with str, from position start in
str onwards. Stop as soon as a mismatch is found
or the end of substr is reached.
*/
for ( current = start, sub. current = 0;
str [ current] == substr [ sub.current]
current++, sub_current++)
/* if entire substr was found in str, return current value of

start as position.
•/
if ( substr [ sub.current] == NULL.CHAR)
return ( start)
else
/* if substr was not found •/
return ( -1)
y /* END str.posO */
/* void make.str.lower ( char *str)

•
convert a string to lower case characters
*/
void make.str.lower ( char *str)

<
int index
for ( index - 0; str [ index] !" NULL.CHAR; index++)

str [ index] - tolower ( str [ index] )
. ; . ; :
388 Using QuickC
/* double get.dbl ( char *me8Eage)
Prompt for ajid read a double

*/
double get_dbl ( char *message)

{
double val; /* slot to store value read */
int args_read; /* number of values read successfully */
printf ( "Xs ", message);

args.read - scanf ( "%lf". tval)
if ( args.read) /• if at least one value was read */
return ( val)
else
This file contains three general purpose functions that are useful for the
conversion program. The make str lower( ) function converts a string to
all lowercase characters. This is important for the conversion program, since
the array containing the units uses only lowercase characters. The header file,
ctype.h, is needed for the tolower( ) macro. This file is actually a nested include
file, since the utils.c file is read into convert.c.
The str pos( ) function returns the array subscript corresponding to the
first occurrence of substr in str. If substr is not found in str, the function
returns — 1
Let's look at the algorithm used in this function. The basic strategy is to
move through str from left to right, one character at a time. Starting with each
character, the next step is to check whether substr is in str, beginning at the
current starting character (start). To do this the function compares successive

characters of substr with successive characters of str until the function reaches
the end of substr or until there is a mismatch. If the end of substr is reached
without a mismatch, then the position to be returned is the value of the current
starting character.
The next listing contains the functions in units.c. These are all very simple
functions — single line formulas. Nonetheless, they can be useful.
/* Include file containing various functions for converting between units.

Currently used by program CONVERT.C
•/
double cent to.fahr ( double cent)

<
return ( ( cent * (9.0 / 5.0)) + 32.0);
}
double cm.to.inch ( double cm)

<
;; ; ; ;
Mefine INCH.PER.CM 0.3937
return ( cm * INCH_PER_CM)
double lahr.to.cent ( double lahr)
return ( ( fahr - 32.0) * (5.0 / S.O));
double gm_to_oz ( double grams)
•define OZ.PER.GRAM 0.03527396
return ( grams * OZ.PEK.GRAM)
double lnch_to_cm { double inch)

<
•define CM.PER.INCH 2.640005
return ( inch * CM.PER.INCH);
double kg.to.lb ( double kg)
•define LB.PER.KG 2.20462
return ( kg • LB.PER.KG);
double km.to.mi ( double km)

{
•define MI.PER.KM 0.62137
return ( km * MI.PER.KM);
double Ib.to.kg ( double lb)

{
•define K6.PER.LB 0.45359
return ( lb * KG.PER.LB)
double liter to qt ( double liter)

<
•define QT.PER.LITER 1.05668
return ( liter • QT.PER.LITER);
double mi.to.kffl ( double mi)

<
•define KM.PER.HI 1.609347
return ( mi * KM.PER.MI)
double oz.to.gm ( double oz)
•define GRAM.PER.OZ 28.349527
return ( oz * GRAM.PER.OZ);
double qt.to.liter ( double qt)
•define LITER.PER.QT 0.94636
return ( qt » LITER.PER.QT)
390 Using QuickC
The program is make it easy to add new conversion functions.

designed to
To do so, you simply need to add new values to the units[ ] array, and add new
cases to the switch in handle all values( ).
Summary
In this chapter you learned about a means of making your C programs more
flexible. By defining the main function to accept arguments, you make it
possible to call the program with command line arguments, thereby making it
easy to do things quickly with the program.
One of the most common uses of command line arguments is to specify
files to read and write. In the next chapter, you'll find out how to create and
open files, and how to use command line arguments to tell your program what
files to use.
14
Files and Memory
So far, all our programs have involved just the standard input and output
sources, stdin, stdout, and stderr. In the previous chapter, you learned how to
pass arguments to a C program. You should now be able to handle files
conveniently in C programs.
In this chapter, you'll learn how and close files. We'll also
to create, use,
look at some Run-Time library functions for working with files, and simple
programs for manipulating files, such as removing blank lines.
Memory is the second major topic of the chapter. We'll look at why you
would want memory while the program is running,
to get additional how to get
the memory when you need it, and how to use it when you have it.
391
392 Using QuickC
Files
Earlier, you learned that a stream is essentially a sequence of characters. In

most cases, this stream will be interpreted as a sequence of text characters,
although sometimes the stream is treated as binary data. In text streams, some
of the characters may play special roles, such as indicating the end of a line or
the end of the stream. You also found that the standard files automatically
available to your program were closely related to streams. In this section, you'll
learn to define and use your own files.
From your perspective as programmer, files in C are pointers. When you
create or open a file in a C program, you get a pointer to a variable of type
FILE. This is a data type that contains information about a stream, such as its
location, size, your current position in the stream, and so on. FILE is defined
in stdio.h, so you need to include this header file in any program that involves
files.
Let's look at a very simple example, useful only for demonstrating how to
define a file. (If, by some coincidence, you have a file named zqzqzqzq on your
disk, change its name temporarily or change the string argument to fopen( ) to
a name that doesn't match one of your disk files.)
/* Program to open and close a file. /

#lnclude <stdio.h>
main
{
FILE •lile.ptr;
FILE *fopen { char *. char *);
Files and Memory 393
tion in your functions. In subsequent listings, we'll assume the function is
declared in stdio.h.
In line 3, the program opens a new file. The library function, fopen()
(which is declared in stdio.h), associates the variable name, file_ptr, with a
text stream. If saved properly, this stream will become a file on your disk. In
addition to returning a pointer to information about a stream, fopen( ) fills in
some of this information.
The first argument to fopen( name to use for
) is a string that specifies the
the disk file. When saved, the stream associated with nie_ptr will be a file
named zqzqzqzq on your disk. The second argument tells fopen( ) how you
want to use this file. In this case, you are telling the program that you want to
be able to write to this file.
If, for some reason, fopen( ) cannot open a file, the function returns a null
pointer. This indicates that no suitable target location could be found. The
example just shows the syntax for calling fopen( ). Ordinarily, you'll check for
an unsuccessful outcome when you first try to open a file, as in the next
example. In the current program, line 4 checks for a null pointer.
a
If was opened — that
file is, if the pointer returned by fopen( ) pointed
somewhere — line 5 closes the file. The function fcIose() takes a file as its
argument, and saves the file's contents to disk. This preserves anything written
file. Nothing was written
to the in the program, so the file, zqzqzqzq. contains
zero bytes, as you'll see if you do a directory listing. You can remove this file
from your disk, since we won't use it again.
What You Can Do to a File
In C, you can do the following things to a file:
• Open an existing file, for reading (r)
• Create a new file for writing (w)
. • Add to an existing file (a)
• Open an existing file for both reading and writing, starting at the
beginning of the file (r+)
• Create a new file for both reading and writing (w+)
• Open an existing file for both reading and writing, starting at the last
place anything was changed in the file (a+)

394 Using QuickC
The second argument to fopen( ) specifies one of these things.

Ifyou want to read information from a file that you've already created,
use r when opening the file. This argument assumes that the file already exists.
That is, ) checks your disk for the file specified in the first argument to
fopen(
fopen( ), and returns a pointer to this file. If the function can't find the file,
fopen( ) returns a null pointer. You are not allowed to write to a file opened with
the r option.
want to create a new file, into which you'll write information, use w
If you
as the argument to fopen( ). If you already have a disk file with the specified
name, you'll lose the existing disk file. The w option always creates a new file.
You can't read from such a file; you can only write to it.
If you'd like to write to an existing file, use a as the argument to fopen( ).
This option tells the function to try to open an existing file for writing. If the
function is able to do this, it moves you to the current end of the file and starts
writing from that point. If the you specified doesn't exist, the function
file
creates a new file with that name. You can only write to such a file.
Sometimes, you may need to read from and write to the same file. You can
enhance the preceding options to tell the function you want to be able to do
both.
Use r+ if you want to start at the beginning of an existing file, so you can
read and write your way through it. As with r, this option tells fopen( ) to look
for an existingand return a pointer to it. However, the r+ option
file, lets you
both read from and write to the file, once it is opened.
Use w+ to create a new file that you'll be able to read from and write to, as
needed. As with W, this option will destroy any existing file with the name you
specify.
Finally, use a+
add to the file (starting at the current position in the
to
file), while being able to read from or write to it. The current position is the last
place at which anything was read from or written to the file.
^REMEMBER To open a file, use fopen( ), with two arguments. The first
argument is the name of the disk file to be saved. The second argument
specifies what you want to do with the file.
To close a file, use fclose( ), with the file pointer as its argument.
) ; ; ; ; ; ; ;
A Simple Notepad Program

The following program is a very simple note-taker. It provides another exam-
ple of how to define and use files. The program is small, but contains
important information. Study it carefully.
/* Program to write text entered at the keyboard into a iile.

Program illustrates use of files in C.
•/
#include <Btdio.h>
«define HAX.STR 100 \

i
main ( int argc , char *argv [] i
{
FILE *notes; /* essentially, the file you defined */ ;
char curr.str [ MAX.STR] /* text entered at keyboard •/ !
int line.count "0; /* # lines written */ ;
if argc < 2)
( /* if user didn't specify a file name */ •
printf ( "Usage:: note <file name>\n") i; i
else /* if argc >= 2 */ i

< ,
/* try to create a file, for writing to. ii

}
If unable to create file, you get a NULL pointer back. '
j;
•/ '
i
if ( ( notes - fopen ( argv [ 1], "w")) !" NULL) ;
< ';
/* prompt for and get string */

printf (":"); i
gets ( curr_Btr) ^
/• stop when user enters an empty line •/

while ( strlen ( curr.str) I" 0) S
< i
I* write string to the file you created •/ J
f printf( notes, "Xd: XsXn" ,
jj
++line_coujit, curr.str) "l
/* prompt for and get string */

printf ( " ") :
gets ( curr_Btr)
> /* END while no empty string */
f close ( notes) ; /* close file to save your work */
printf ( "XSd lines written\n", line_count)

} /* END file writing activity */
else /
if unable to open file */
printf ( "Couldn't open file\n");
} /» END else (if argc >= 2) */
•} /* END mainO */
Suppose you had a compiled version of this program in a file called

note.exe, and you started the program with the command line that follows.
396 Using QuickC
The program will create a file that will be saved to disk as file 7.10. Each line
you entered while the program was running will be written to file 7.10. When
you finish your note-taking by entering a blank line, the program will close the
disk Look at the contents of the file with your editor or by using the DOS
file.
TYPE command.
First, let's look at the major portions of the program. The body of inain( )
consists of an if statement and its alternative. If the program does not find a file
name as a command line argument — if there is only one element in argv[ ]
—
you see a "usage" message. The real work occurs if you have specified a file to
be opened.
The else construct also contains an if statement. If the log file was
successfully created, the program reads your input and writes it to the log file.
If the program is unable to open a file —
that is, if the call to fopen( ) returns a
null pointer —
the program displays an error message.
The pointer variable notes is used to refer to the file, and is defined the
_
same way as file ptr was in the earlier program. Similarly, the call to fclose( )
has the same format as in the earlier example.
The call to fopen( ) is made in a different context than in the first example.
This syntax for using fopen( ) is common in C programs. The main work of
creating a file is done in the assignment statement. This time, however, the
assignment is made within a test for the if statement. If the returned pointer is
NULL, the file could not becreated, the condition would befalse, and the else
portion of the selection construct would be executed. (Remember that argv[]
contains strings, so the first parameter to fopen() is valid.)
The other statement involving files is the call to fprintf( ). Recall that we
used this function when discussing stderr. The function works just like
printf( ), except that you can specify the file to which it writes. This program
writes to notes, the program's name for disk file 7.10.
A Simple File Reader Program

While the note program writes simple files, the following program reads them:
/* Program to read text from a llle.

Progran illustrates use of files, and some file functions in C.
*/
înclude <stdio.h>
) ; ;
•define HAX.STR 100
main ( Int argc . char *argv []

{
FILE *noteB: /* essentially, the file you defined */
char curr.Btr [ MAX.STR] ; /* text entered at keyboard */
if ( argc I" 2) /* it user didn't specify a file name */

printf ( "Usage:: note <file na]iie>\n"):
else
{
/• try to open a file, for reading.
If unable to open file, you get a NULL pointer back.
•/
if ( ( notes - fopen ( argv [ 1], "r")) 1= NULL)
<
/* stop when a NULL pointer is returned. •/
while ( fgets ( curr.str, MAX.STR, notes))
/* display string */
printf ( "XsVn" curr.str)
,
feof ( notes)) if (
printf ( "\n\n End of file reached. \n")
fclose ( notes): /* close file */
} /* END file reading activity »/
else /• if unable to open file */
printf ( "Couldn't open fileVn"):
} /• END else (if argc 2) */ ~
} /• END mainO »/
This program, called reader, opens the file specified in a command line
argument (stored and reads from this file, line by line, until an
in argv[ 1])
error is encountered or the end of the file is reached. The program displays
each line as it's read from the file.
The only difference between the calls to fopen( ) in note and in reader is in
the option specifying what you want to do with the file. In this case, the r
option says you want to read from the beginning of the file.
This program introduces two new functions, fgets( ) and feof( ). The
fgetsO function is from a file. It is similar to the gets()
for reading strings
function you've seen already. There are some important differences between
the two functions, however. The functions differ in the number of parameters
they take, and in how they handle the newline character.
Notice that fgets( ) takes three parameters, whereas gets( ) takes only one.
The first parameter to fgets( ) specifies the string to be read. The second
parameter specifies the maximum number of characters to be read. The third
parameter specifies the file from which to read the string.
in the call to fgets( ) in reader, the function reads characters from the
specified file and builds a string (curr str) from these characters. The
(notes),
function keeps adding to curr str until it reads a newline character or until
MAX _ STR — 1 characters have been read. After it has finished reading, the
function adds a \0' to terminate the string properly. Notice that the
' maximum
398 Using QuickC
number of characters the function reads is one less than the function call
specifies. This is because the function needs to add the null character at the end
of the string.
Recall that gets( ) replaces the newline character with a null character. On
the other hand, fgets( ) keeps the newline character and adds a null character.
Because of this, the output from this program is double spaced. One newline
character is contained at the end of the string read, and another is at the end of
the string argument to printf( ).
Notice how fgets( ) is being used in the continuation condition for the
while loop in reader. If the end of the file has been reached, the function
returns an empty, or null, string. This is just a null character, 0, which evaluates
to false in C. Thus, the continuation condition tests whether an empty string
has been read.
A Note About Function Returns If you check the documentation for

fgets( ) or for gets( ), you'll find that these functions have a return type, char *.
Ordinarily, when you call a function in C, you'll assign its returned value to a
variable of the appropriate type. In that case, the function call will be on the
right of an assignment statement, and the variable to which the returned value
is being assigned will be the left operand.
Sometimes, however, you may want to call the function in order to
accomplish a task or to get information back through one of the parameters.
In that case, you needn't use an assignment statement; just call the function
with the appropriate parameters. We've generally been doing this when using
printf( ) and scanf( ). Recall that these functions actually do return values —
the number of characters printed, and the number of arguments processed,
respectively. However, we've been using these functions just to display or read
information, and haven't made use of the returned value. For this reason, the
calls to these functions have not been assignment statements.
Similarly, we've been using gets( ) and fgets( ) without making use of their
returned values because we've gotten the desired strings through the parame-
ters. However, unless the function is defined as returning void, it always
returns the appropriate type of value — whether or not your program uses this
value.
In the previous listing, we've implicitly made use of this property of C
functions by using the value returned by fgets( ) — looking for an empty string
in the continuation condition for the while loop. Thus, when the fgets()
; . )
function cannot read a proper string — because the end of the file has been
reached or because of another error —the function returns an empty string. If
the function returns a null string, then the function's "value" can also be
interpreted as false.
feof ( and ferror( )

) When the fgets( ) function returns a null pointer, your
program has no way of knowing whether this value was returned because of a
normal end of file or because of an error. Your program's actions may depend
on the answer to this question. The feof( ) macro tells you whether the end of
file was encountered.
This macro takes one argument, a pointer to the file, or stream, you want
to check. The macro returns if the current file position is not the end of the
and a nonzero value if the end of the file has been reached.
file,
There's also a macro available for asking explicitly whether an error

occurred. An error might occur, for example, if you open a file just for reading
(using the R option), and then try to write into the file. The ferror( ) macro also
takes a file pointer as an argument, and returns a nonzero (true) value if an
error has occurred while reading or writing the file.
A Program to Remove Blank

Lines from a File
The following program removes blank lines from a file, then writes the
remaining lines to a new file. The program opens and closes both files, in for
reading and out for writing.
/* Program to remove blaiUc lines from a file.

A "blank" line contalna only a newline, \n. or other whitespace,
such as a tab, \t
USAGE : : deline <infile> <outf ile>
•/
«define FALSE
#deflne TRUE 1
#define MAX.LIHE 100
main ( Int argc char *argv [] ,
/» argc Number of command line words

: »/
/* argv [] Pointers to command line words */
:
<
FILE 'in; /» File used for input »/
FILE *out /* File used for output */
; ; ; ; ; ; ; ; ; ; , ;;
400 Using QuickC
int nr.lines - 0; /* nr of lines written */

int discard. lines =0; /• nr of lines discarded •/
char *test_str. curr.str [ MAX.LINE]
if (argc < 3)
{ /* Check if enough arguments */
fprintfCstderr. "BLANK LINE removal utilityNn")
fprintf(atderr, "Usage: deline in.filename out_filename\n")
exit(l):
}
if ((in - fopen(argv[l] ,"r")) " NULL)

<
fprintfCstderr," Can't open source file: Xs\n" .argv[l] )
exit(l):
>
if ((out •= fopen(argv[2] ,"w")) =- NULL)

{
fprintf(8tderr. "Can't open target file: y,8\n" .argv[2])
exit(l)
}
/* main work of the program is done here */

while ( (test.str - fgets ( curr.str, MAX LINE, in)) !» NULL)
<
/* if the line contains any material, write line to new file
(otherwise, discard line)
•/
if ( just.wspace.str ( curr str) -- 0)
{
fputs ( curr.str, out);
nr_lines++;
}
else /* if the string was just whitespace */
discard.lines++
}
/* Report on activity •/
printf ( "\n\nXB > Xs\n\n" , argv [ 1], argv [ 2]);
printf "X5d lines written; XBd lines discarded\n"

(
nr.lines, dlscard.llnes)
fclose(in)
f close (out)
/* Returns true if the entire string has Just whitespace characters. •/

int just.wspace.str ( char *the.str)
{
int index
int just.wspace.char ( char)
for ( index 0; just.wspace.char ( the. str [ index]);

index**)
{
>
if ( index >- strlen ( the.str))
return ( TRUE)
else
return ( FALSE)
/* returns TRUE if character is a whitespace or end of string character. */

int just.wspace.char ( char the char)
<
: : ; ; ;
switch ( the.char)
{
case '
'
case '\n'
case '\r'
case '\t':
case *\0'
return ( TRUE)
break
default
return ( FALSE)
break
>
This program opens the first file specified, and reads its contents line by
line. Each line is examined to determine whether it contains anything other
than whitespace characters. If so, the line is written to the second file; other-
wise, the line is discarded, and is not written to the file.
Notice the commands for opening the two files. They are similar to the
commands in the earlier examples, and are just the standard way of opening a
file. You've seen fprintf( ) for writing material to a file. You've also seen puts( )
for writing a string to stdout.

The fputs( ) function writes a string to the specified file. The function
takes two parameters, the string and the file, and it returns the last character
written as an integer The function does not copy the terminating null charac-
ter to the file.
The section of the program responsible for deciding whether to write a

line to the new file uses the specialist functions, just wspace char( ) and
just_wspace_str( ). These functions return a nonzero int if the string or
character they have been processing contains anything other than a white-
space character. Notice the use of just wspace _ char( ) in the continuation
condition of just wspace _ str( ).
A Program to Replace Tabs

with Spaces
Let's look at one more program involving files. This one replaces any occur-
rences of the tab character (' \t') with the appropriate number of spaces:
/• Program to replace tabs with spaces In a file, and to write

detabbed information to a new file.
•/
; ; ; ) ; ; : ;; ;
402 Using QuickC
#define FALSE
#deline TRUE 1
#deline CZ •\032- /* Ctrl-Z */
#deline TABSKIP 8
mainClnt argc, char *argv []

{
FILE *in; /* File used for input •/
FILE *out; / File used for output */
int ch_read, index;
print! ("XdNn", argc):
if (argc < 3) /* Check it enough arguments */

<
fprintKstderr, "TAB removal utility\n") ;
fprintKstderr, "Usage: detab in_filename out_filename\n")

exit(l);
}
if ((in - fopen(argv[l] ,"r")) == NULL)

<
fprintf(stderr, "Can't open source file: XsVn" ,argv[l])
exit(l):
>
if ((out = fopen(argv[2] ."w")) == NULL)

{
fprintf(stderr, "Can't open target file: y,s\n" ,argv[2])
exit(l) ;
>
/» detabbing process starts here •/

index = 1
/* read contents of in file character by character, to find tabs */

while ( ( ch read - getc (in)) I- EOF)
{
switch ( ch.read)
{
case '\t' : /* tab character */
do /* put spaces until next tabstop */
{
putc ( ' '
, out)
index++
}
while ((index X TABSKIP) !- 1);
break;
case '\r': /* return •/
case '\n': /* newline */
putc ( ch.read. out);
index 1
break;
/* to strip out Ctrl-Zs that may be there
at end of file;
»/
case CZ:
break;
default
futc ( ch.read, out);
ndex++;
break;
} /» switch */
> /* while */
fclose(in)
f close (out)
This program replaces any tab character encountered in a file with the
number of blanks needed to get to the next tabstop. The program then writes
the resulting string to a new To do its
file. work, the program reads character
by character from in, the source file, and writes character by character to out,
the detabbed file. The program uses the character handling macros you
learned about in Chapter 5, putc( ) and getc( ).
The CZ case in the switch construct is designed to deal with text editors
that pad out files with Control-Z characters. The detabbing program just
ignores these characters, and does not write them to the detabbed file.
Overview of File IVIanipulation
Although you'll use files often in your programs, the number of things you'll
actually do with files is quite small. Before you can do anything with files
you've defined, you must open them, using the fopen( ) function. This function
gives you a pointer to a FILE.
Depending on what you intend to do with the file, you'll use either the
input routines — getc( ), fgets() — or the output routines — putc(), fputs(),

fprintfO — or both.
If anything goes wrong, you can use the feof( ) and ferror( ) macros, to
determine what actions to take. Finally, you'll need to close the file, using the
fclose( ) function. This ensures that files are properly terminated and saved.
Dynamic Memory Allocation

When you program or function, the compiler allocates
define variables in a
storage space for these variables. The amount of storage allocated for these
variables is predetermined and fixed. This allocation strategy is called static-
storage, since you allocate the memory once, in advance, and then leave it
alone. Static storage works well if you know in advance the amount of storage
you'll need.
However, sometimes your memory requirements may vary drastically.

For example, suppose you had a program to compute the mean of a collection
404 Using QuickC
of numbers read from a file. Sometimes the file might contain only a few
values, and sometimes it might contain several hundred. You could define an
array large enough to hold the largest number of values expected. This would
use up lots of memory each time you ran the program, but would probably be
acceptable if you only had one such array.
On the other hand, suppose you had several arrays you needed to manipu-
late, each with a range of possible sizes. In such a situation it won't be practical,
and may not even be possible, to allocate enough storage for the largest
possible size of each. For example, suppose you had 10,000 bytes of available
memory, and you had five arrays, in each of which you might need to store as
many as 400 double values. For each of these, you would need 3,200 (400
values * 8 bytes per double) bytes. The 16,000 bytes required exceeds what you
have available. So you won't be able to define all five of these arrays — even if
you'll never need all the space in each of the arrays at the same time.
What you really need to be able to do for each array is get enough memory
to store the number of values you'll need to read for that particular run of the
program. For example, suppose you had 400, 200, 100, 100, and 200 values for
the 5 arrays. Using space efficiently means you would need 3,200 + ,600 + 800 1
+ 800 + 1,600 = 8,000 bytes, which is under the 10,000 byte limit. With a
means of allocating the required storage when you need it, you would be able
to run this program.
The solution is a technique called dynamic memory allocation, which
memory as you need it. For a situation such as the above,
allows you to allocate
a dynamic storage allocation strategy would grab enough memory to hold 400
double values, then 200, then 100, and so on. C implementations include
functions for allocating memory in this manner. Before we look at some
examples, you need to find out about another operator, for converting infor-
mation from one type to another.
C's Cast Operator
So far, you've seen that the C compiler can convert information from one type
to another to evaluate an expression. Sometimes you'll want to force such
conversions.
For example, suppose you have a double variable, which you need to
display in integer format. You can't simply include an int placeholder and pass
printf( ) a double argument. The outcome will not be correct, as the following
:
program and output show. One way to solve the problem is to assign the
double to an int variable, then pass this variable as the parameter to printf( ).
This is effective, but very roundabout.
The C cast operator () — lets you make such conversions much more
—
directly. The following example illustrates the use of this operator, and shows
the differences when using or not using the operator:
main ()
<
double dl • 10;
prlntl ( "as Int: X5d\n". dl);

printf ( "as (int) %5d\n" (int) dl);
,
This program produces the following output. Notice that the first line is
incorrect:
as int
as (Int) 10
This program tries to write the contents of a double variable as an int. The
first time, the double is passed directly, and an incorrect result is written. The
second time, the double is first converted to int by using the cast operator — in
this case, (int) — to copy the value to an integer internally, so that the proper
result could be displayed.
To use the cast operator with an expression, simply precede the expres-
sion with the type to which you want to cast the expression. This "target type"
must be in parentheses, because these parentheses represent the cast operator.
The cast operator is a unary operator. As such, it has very high precedence at —
the same level as the address, indirection, and sizeof( ) operators. For example,
to convert the result of evaluating 7.0 * test val to integer, you would write:
(int) (7.0 » test.val)
.Recall that the unary operators associate right to left. This means that if
you have multiple unary operators in succession, they are applied from right to
left. For example, what will be displayed in the following?
main ()
<
int il - 10. 12 - 10;
. ;
406 Using QuickC
printl ( "as (double) Xl0.611\n", (double) - ++il);

printf ( "as (double) y.lO.Bll\n". (double) - --12);
This program writes the values - 1 1 and —9 in double format. Let's see how the
program arrives at these values. The first call to printf( ) builds its argument as
follows, by applying the unary operators from right to left.
1 Increment il before using (— 11).
2. Apply unary negation operator to the new value of il (^ ~11).

3. Convert this value to a double.
The second call works in a similar manner, except that the value of 12 after
step 1 above == 9, rather than II.
Why is the call to printf( ) in the following program invalid? If you're not
sure, compile the program to see the error message.
/* Program to test your command of the unary operators. */
main ()
<
int 11 = 10;
printf ( "as (double) XlO.BlfXn". (double) ++ -il)

}
P^ REMEMBER To apply the cast operator to an expression, put the type to

which you wish to convert the expression inside parentheses, then put this
operator to the left of the expression you want to convert. For example, to cast
X * y to double, type (double) (x*y).
Note that (double) x * y would produce a different intermediate resuh,
since the cast operator has higher precedence than multiplication. Only the x
would be cast to double. The final outcome, in this case, would still be the
same, however.
Syntactically, you can convert an expression to either integral or floating

point types, or to a pointer type. Thus, the following assignment is a valid
conversion — converting the value of il from an ordinary integer to an
address.
;
/* assume i_ptr is a pointer to int; il 4CX)0:
i-ptr - (int *)il;
Applying the cast operator produces only values, not variables. That is,
the cast operator never returns an lvalue. The operator simply returns a
temporary value of the appropriate type, for use in an expression. The pro-
gram can assign this temporary value to a variable, if necessary.
In the next section we'll see why converting to a pointer variable can be
useful.
The Strategy of Dynamic Memory

Allocation
The strategy for dynamic storage allocation is to define a pointer to the

appropriate type, then allocate the desired amount of contiguous storage and
make the pointer variable point to the first cell in this storage. (Contiguous
storage is Once allocated, you can
storage in consecutive address spaces.)
move through the values you've read by using pointer arithmetic or array
subscripting. The following program shows how to allocate such storage:
/* Program to allocate storage for an array ot elements,

and to display the contents.
Program illustrates use oi nallocO.
*/
#include <stdlib.h>
#define HAX.SIZE 10
main ()
{
int int.array [ MAX.SIZE]
int *int_ptr, index;
for ( index - 0; index < MAX.SIZE; index++)

int_array [ index] " index;
int.ptr - (int *) malloc ( MAX.SIZE * sizeof ( int));
if ( int ptr)
{
for { index - 0; index < MAX.SIZE; index++)
dnt.ptr + index) - int. array [ index] ;
for ( index 0; index < MAX.SIZE; index++)

<
printf ( "X2d: tint. array [ index] " Xu;
index, ftint.array [ index]);
: ,
.
408 Using QuickC
printf ( " int_array [ index] -" y,2<i\n"

int_array [ Index] )
printl ( "\n\n");
for ( Index - 0; index < MAX SIZE; index++)
{
printf "%2d: int_ptr + index == y,u: ",
(
index, int_ptr + index);

printf ( "*(int_ptr + index) == y,2d\n"
*(int_ptr + index));
/* END if storage was allocated */
On a sample run, this program produces the following output:
0: feint.array index] -- 4076; int_array index] -

•
[ [
1: ftint.array [ index] 4078; int.array [ index] == 1

2: ftint.array [ index] -- 4080; int.array index] == 2
"
[
3: tint.array [ index] 4082; int.array index] =- 3

"
[
4: ftint_array index] 4084; int.array index] == 4

B: tint.array
[
index] = 4086; int.array
[
index] == 5
"
[ [
6: tint.array [ index] 4088; int.array [ index] == 6
7: tint .array [ index] •- 4090; int.array [ index] == 7
8: tint.array index] == 4092; int.array index] == 8
9: tint.array
[
[ index] « 4094; int.array

[
[ index] ^= 9
0: Int.ptr + index -- 4306 (int.ptr + index)

1: int.ptr + index == 4308 (int.ptr + index)
2: int.ptr + index =- 4310 (int.ptr + index)
3: int.ptr + index == 4312 (int.ptr + index)
4: int.ptr + index -- 4314 (int.ptr + index)
6: Int.ptr + index =• 4316 (int.ptr + index)
6: int.ptr + index - 4318 (int.ptr + index)
9: int.ptr + index ~ 4324 (int.ptr + index)
This program initializes an array of int, then calls the function malloc( ) to
allocate space for as many integers as are contained in the array. The starting
address of this allocated memory is assigned to the pointer variable, int ptr.
The contents of the array elements are assigned to the successive storage
locations in the memory allocated by the call to malioc( ).
The program then displays the contents and addresses of the array cells
and of the MAX SIZE integers stored in consecutive integer slots starting at
location 4306 (the first cell allocated by the call to nialloc( )).
The dynamic memory allocation takes place in the statement that assigns
an address as the value of int ptr. Notice that the right operand of the
assignment statement involves a cast operator. The malloc( ) function actually
returns a pointer to an unspecified type. The cast operator makes the compiler
interpret the returned value as a pointer to int. In this way, the appropriate
amount of storage is allocated, so that integer pointer arithmetic will work.
The call to malloc() returns enough space to store a MAX _ SIZE
element array of int. In addition to ensuring that the space is available, the use
of mallocO also guarantees that the storage is in consecutive memory loca-
tions.The advantage is that there is no need to define a huge array at the
beginning of the program or function.
More on malloc() Before we look at another example, let's look a bit
more closely at nialloc( ). If you look at the documentation for malloc( ), you'll
see that the function is defined as returning a pointer to void, void *. You'll also
see that its parameter is a variable of type size_t.
The argument to malIoc() represents the number of bytes of storage
requested. The identifier size_t is simply a typedef for unsigned int, as you'll
see if you look in the file stdlib.h. This type is intended to represent values of
the sort the sizeof( ) operator returns. Making argument unsigned
the
increases the range of values you can pass. This can be useful if you need to
allocate very large amounts of storage.
The return type, void *, is really a placeholder that makes malloc( ) usable
with any variable types. The Draft Proposed ANSI Standard says that a
pointer to void may be converted to a pointer to any type. In our program, the
conversion was to a pointer to int, so that each address unit is two bytes. Had
we cast the result from malloc( ) to pointer to double, the size of each address
unit would have been eight bytes.
The nialIoc( ) function returns a null pointer if it cannot allocate the
amount of storage your call requested. It is always a good idea to check that
the storage was actually allocated, as in the next example.
Using malloc()
The following program generates a specified number of random numbers, then
writes these to a file:
/* Program to allocate storage lor specified number oi int values.

then to generate random integers to store In these cells.
Program Illustrates use ol dynamic memory allocation and
command line arguments.
*/
•include <Btdlib.h>
; ; ;
410 Using QuickC
#include <stdio.h>
#deflne MAX.SIZE 200
main ( Int argc, char *argv [])
Int •Int.ptr. index;

int rand ( void), val, curr rand;
FILE *fp;
if ( argc < 3)
printf ( "Usage: getrand <# values> <flle naTne>\n");
else
{
/* convert the first command line argument to a number */
val " atoi ( argv [ 1] )
/* if the user wants too many values */

if ( val > MAX SIZE)
{
printf ( "Too many values. Max = y.d\n". MAX.SIZE);
exit (0)
}
else /* if program can handle requested # of values */
/* allocate storage for requested # of integers */

int.ptr " (int *) malloc ( val * sizeof ( int));
if int.ptr 1= NULL)
(
for ( index = 0; index < val; index++)

*( int.ptr + index) = rand ;
else /* is storage could not be allocated */

{
printf ( "Couldn't allocate storage. \n" ) ;
exit (1);
}
/* try to create a file for writing. */

if ( ( fp = fopen ( argv [ 2], »w")) != NULL)
{
/* write array to file */
for ( index = 0; index < val; index++)
{
/* write 5 values per line */
if ( ( index 5) 4)
'/, "
f printf ( fp, "'/.10d\n".
•(int.ptr + index));
else
f printf ( fp, "XlOd",
(int.ptr + index));
}
fclose ( f p) /• close file when done */
;
} /* END if file was opened */

else /* if file can't be opened. */
printf ( "File could not be opened\n")
} /* END if have a valid number of values /
y /* END if have the correct number of arguments */
Suppose this program is stored in a file named getrand.exe. The following

command line would write the contents below it to the file called randout:
getrand 100 randout
41
; ; ; ;
412 Using QuickC
il ( argc < 3)
printf ( "Usage: readvals <# values> <Iile nanie>\ii");
else
{
/* find the number in the first command line argument */
val - atoi ( argv [ 1] )
if ( val > MAX.SIZE)

<
printf ( "Too many values. Max - y,d\n" , MAX.SIZE);
exit (0);
}
else
{
/* allocate the space, if possible */
int.ptr • (int *) malloc ( val * sizeof ( int));
/* if unable to allocate storage, exit program */

11 ( int.ptr NULL) "
{
printf ( "Couldn't allocate space. \n");
exit (1)
}
/* il file could be opened, read from the file;

continuation condition says stop if either:
1. enough (val) values have been read, OR
2. as many values as possible have been read
from the file for example, because
the end of the file has been reached.
—
•/
if ( ( fp - fopen ( argv [ 2], "r")) != NULL)
{
for ( index - 0;
(index < val) t6
(fscanf ( fp. "Xd".
int_ptr + index) > 0)
index++)
; /• do nothing */
fclose ( f p)
val » index: /* in case not all values were read */
/* display the values read */

for ( index « 0; index < val; index++)
/• display 5 values per line */

if ( (index X 5 ) 4) "
printf ( "y.lOd\n",
•(int_ptr + index));
else
printf ( "y.lOd",
*(int_ptr + index));
} /* END if file was opened »/
} /* END if have a valid number of values */
} /* End il have the correct number of arguments */
With the preceding program stored in a file named readval.exe and the
data in the randout file created in an earlier example, the following function
call would produce the output below it:
readval 23
414 Using QuickC
ing parameters by reference, this use of addresses should be clear.

In this program, int ptr is a pointer variable, so passing its value as a
parameter to fscanf() means that an address is being passed in, as required.
Because int ptr is a pointer, offsets (such as those involving index) are
interpreted in terms of address units. Thus, int _ ptr + 2 rekrs to an address 4
bytes higher than the address contained in int — ptr.
callocO
The mallocO function simply you the number of bytes you want, and
gets
leaves it up to you to partition those bytes and to assign values to them. There
is a related function, calloc( ), that also returns a pointer to an area of
contiguous storage. The calioc( ) function works in a slightly more structured
manner, and it even initializes the memory returned.
The calloc( ) function takes two arguments — the number of elements and
the size of each element — and returns a pointer to void, which your program
should cast to a pointer of the appropriate type. Essentially, calloc( ) returns a

pointer to the first element of an array that has as many elements as you
requested in the first argument to the function, or a null pointer if the function
cannot allocate the desired amount of storage. The calloc( ) function initializes
each element allocated to 0.
Usage for calloc( ) is the same as for malloc( ). Thus, the following would
allocate storage for a 200 element array of double and would make dbl_ptr
point to the first element of this array. Each element in this array would be
initialized to 0.0:
/* assume the following definition : doable *dbl_ptr;
dbl.ptr • (double *) calloc ( 200, sizeof ( double)):
Getting More Memory Later

It may happen that you allocate a specified amount of space for information,
and then find that you need more space. It's generally not desirable to store
information in two separate data structures, when it really belongs together.
C provides the realloc( ) function for dealing with situations such as this.
This function lets you add to an existing collection of contiguous storage, or

gets you a new, larger section of contiguous storage. The function takes two
; ; ; . .
arguments —
a pointer to the existing storage collection, and the new size (in
bytes) —
and returns a pointer to void. This pointer references the first element
of a contiguous area of memory having the desired size.
The following program illustrates the use of realloc( ):
/* Program to illustrate use of reallocO to modify amount of

storage allocated dynamically.
*/
main ()
<
double dl , *dbl_ptr;
/* get room for IBO double values •/

dbl.ptr (double *) calloc ( 150. sizeof ( double));
11 ( dbl_ptr I- NULL)
<
/* display starting and ending addresses */
printf ( "ftdbl.ptr [ 0] == Xu; tdbl.ptr [ 149] == '/.uNn"
tdbl.ptr [ 0] tdbl.ptr [ 149] )
,
/• expand the storage to room for 200 double values */

dbl.ptr • (double *) realloc ( dbl.ptr, 200);
if ( dbl.ptr !- HULL)
/* display starting and ending addresses */
printf ( "ftdbl.ptr [ 0] =« Xu; ",
ftdbl.ptr [0]):
"ftdbl.ptr [ 199] =- y.u\n"
printf (
ftdbl.ptr [ 199] )
} /» END if not a null ptr */
else
printf ( "null pointer\n")
On a sample run, the program produces the following output:
ftdbl.ptr [ 0] " 4292; ftdbl.ptr [ 149] -= 5484

ftdbl.ptr [ 0] " 4292; ftdbl.ptr [ 199] " 5884
This program allocates storage for an array of 150 double elements,

first
and writes the addresses of the first and last elements in this array. Then the
program tries to reallocate storage for a 200 element array of the same type.
Finally, the program writes the addresses of the first and last elements in this
array.
The intent when using realloc( ) is to expand the original array to a larger
Data from the original array should not be lost. When realloc( ) does its
size.
work, it will simply return the same starting address if enough contiguous
416 Using QuickC
storage is available immediately after the last cell of the original array, as in this
example.
If this is not possible, realloc( ) will try to find the storage for a large
enough array elsewhere. If successful in this search, the function will then
transfer the contents of the original array to the new location, and will release
the storage that had been allocated for the original array. In the second case
reaIloc( ) moves the array into a new, bigger location.
In the previous program, the function was able to simply allocate the 50
additional double storage spaces immediately after the original array. In other
situations, this may not be possible because the storage right after the original
array is being used. In that case, the function moves the array's contents to a
new location. Because the original array may be moved, you should not count
on the value of the pointer parameter being the same before and after the call
to realloc( ).
The realloc( ) function can be useful, but you must use it carefully. Like
other storage allocation functions, realIoc( ) returns a null pointer if it is unable
to allocate the desired storage. I n this case, however, a null pointer means that
your original storage has been lost.
^REMEMBER Be careful when using realloc( ). You can lose your original
data if something goes wrong. Always test the value of the pointer realloc()
returns.
Giving Storage Bacl<
So far, you've seen three ways of obtaining storage space and reserving it for
use in a program. In this section, you'll learn about a way of returning storage
to the program for reuse.
Suppose you had a program that needed to manipulate as many as five
large arrays, but that your available memory could only fit four of these arrays
at any one time. The free( ) function lets you "deallocate" storage. This makes
the storage available for use at another point in the program.
To deallocate storage, call the free( ) function with a pointer parameter. In
the function definition, this parameter is a pointer to void, for which you can
substitute a pointer to the appropriate type. The pointer must refer to storage
allocated with either the inaIloc( ), calloc( ), or realloc( ) functions. The free( )
function does not return any value. Using free() with a pointer allocated by
other means causes an undefined result, and is likely to cause storage errors.
: ;
^REMEMBER You can only use free( ) to deallocate storage allocated with
mallocO, callocO, realloc(), or similar Run-Time library functions.
With this function, you can

around certain storage limitations, if you
get
can discard data after you've processed it. For example, if you can only fit four
of the five large arrays mentioned earlier, you might do the following:
1 . Use malloc( ) or calloc( ) to allocate storage for up to four of the arrays.
2. When you've finished with one of these arrays, use free( ) to deallocate
the storage.
3. Use malioc( ) or calloc( ) to allocate storage for any remaining arrays.
Determining Available Storage

Sometimes it's useful to know how much storage is available for use. For
example, suppose you want to expand an array of double by 100 values. If you
knew that there were fewer than 800 bytes of available storage, you could save
yourself the grief of possibly losing your data (because realloc( ) returned a null
pointer) by not even calling the realloc() function.
QuickC (and Microsoft C v5.0) provide a function for determining the
amount of storage available. The memavl() function returns an unsigned
(actually a size t) value indicating the number of bytes of storage available.
The following program lets you see how the available storage changes as
the amount of storage allocated varies. n some cases, the program is unable to
1
allocate the storage, in which case the return from _memavi() remains
unchanged.
/* Program to show use of .memavlO lor determining available storage */

«lnclude <8tdllb.h>
#lnclude <stdlo.h>
#lnclude <malloc.h>
»define MAX.TRIALS 10
main ()
<
double dl 'dbl.ptr •dbl.ptr2
, ,
unsigned memory
int rand index, how.many;
.
for ( index - 0; index < MAX TRIALS; index++)

<
/* determine amount of available storage *t
memory _memavl ();
printf ( ".rnemavl » Xu\n" memory): ,
; .
418 Using QuickC
/• get a random size to allocate */

how.many • randO;
/* allocate storage •/
dbl.ptr " (double *) calloc (how.many / 2, aizeol (double));
/* now how much storage is available? */

memory _memavl ();
print! ( "alter getting '/,5d doubles. _memavl = y.u\n\n"
how.many / 2, memory);
/* deallocate storage, to start afresh */

free ( dbl.ptr)
The following listing contains a sample run of this program.
.memavl = 61286
Notice that sometimes no storage seems to be allocated. These cases ask

for too much storage, in which case malloc() returns a null pointer and
allocates no space.
Dynamic Allocation Pitfalls
There are certain common errors to watch out for when dealing with dynamic
memory allocation. These errors concern errant or lost pointers and unavail-
able space.
First, do not lose access to your starting value. This means you should
always have a way of getting to the first element of the array to use as an origin
for pointer arithmetic.
Second, don't change the value of a pointer to a collection of data. You'll
lose your real data,and may damage your environment when you try to write
to the new (and unknown) data area.
Finally, your program should always make sure it has gotten the storage it
requested. Don't assume you have the storage and begin writing to it. You may
overwrite important information by mistake.
Uses of Dynamic Storage

Allocation
A major advantage of dynamic storage allocation is that you need to allocate

only the storage required to do the job. The examples we've looked at generally
involve arrays of values, with some way of finding out how large the array
needs to be. Using the storage allocation functions guarantees that the amount
requested will be available, if a non-null pointer is returned.
Dynamic allocation can also be useful for string handling because you can
get storage for a new string or for a temporary string while needed. This is
much safer than relying on pointers to char, which may overwrite other data if
you're' not careful. By assigning the pointer to the first cell of an array of
character that nialloc( ) allocates, you ensure that the storage for the string is
available and can be used safely.
A third major use of dynamic storage allocation comes in programs that
involve data structures such as trees and linked lists. You'll learn about the data
structures used to build trees and lists in Chapter 16.
420 Using QuickC
Summary
In this chapter you learned how to open and use files, including how to read
from and write to them. File handling is particularly convenient if you use
command line arguments, since that makes it much easier to specify the files
with which the program should work.
You also learned how and deallocate storage dynamically, as
to allocate
needed while running a program. This capability is handy for certain types of
data structures whose size will not be determined until the program is actually
running.
In the next chapter, we'll cover some miscellaneous topics and operators
for manipulating individual bits in variables.
Bit and Othei
Operators
The first chapter claimed that C lets you manipulate data at the level of
individual bits. In this chapter, you'll find out how this is done. In addition,
you'll encounter a new operator.
Bitwise Operators
A bil is a single binary digit, a or 1 . In C, integral data types are stored as a

sequence of bits occupying an allocated amount of storage. Thus, in QuickC,
an int is a sequence of 16 bits, while a long int is a sequence of 32 bits. The
operators for manipulating bits apply to integral types only. (Floating point
421
; ; ; ; ;; ; ; ; ; ; .
422 Using QuickC
variables are also stored as bit sequences. However, for these types, different
parts of the bit patterns serve different functions — fraction and exponent, for
example. Therefore, the bitwise operators do not apply to floating point
types.)
Bit Patterns
Before discussing the bitwise operators themselves, some examples let's look at
of numbers represented in binary form. The following program generates bit

patterns for specified numbers. To get some practice working with binary
representations, play with this program.
/* Program to display the binary representation of 16-bit integers.

Program illustrates binary representations.
•/
#include <stdlib.h>
#define MAX.STR 80
main ()
Int value
int make_bin_str ( char *, int);
char curr_8tr [ MAX.STR]
char val.str [ MAX.STR]; /* value to convert, read as string */
printl ( " ? " )

gets ( val.str)
value = atoi ( val.str)
do
{
printf ( "%d " value) : ,
it ( make.bin.str ( curr.str, value))

printf ( "%s\n" curr.str) ,
else
printf ( "string not built correctly:: y,s\n"
curr.str)
printf ( "? ");

gets ( val.str)
value = atoi ( val.str)
>
while ( value !- 0)
; ;;
Bit and Other Operators 423
/* build a string consisting of binary digits, based on value passed in */

int make.bin.str ( char *8tr. int value)
<
•define MAX.PWR 32768L /• largest bit in an unsigned 16 bit int /
unsigned index:
int outcome, bin.place - 0;
for ( index - MAX.PVKR; index > 0; index /- 2)

{
outcome (int) ( value / index)
if ( (outcome --1) (outcome -- -1))
I I
Btr [ bin_place++] • 1 '

'
else
I Btr [ bin_place++] "O";
value X* index;
Btr [ bin.place] - NULL.CHAR;
if ( bin.place •- 16) /* if 16 bits were processed :

-- 15 */
return ( 1)
else
return ( 0)
This program produced the following sample session:
: 0000000000000000
? 2
2 : 0000000000000010
? -2
-2 : 1111111111111110
? 10
10 : 0000000000001010
? -10
-10 1111111111110110
:
? 1024
1024 0000010000000000
:
? -1024
-1024 1111110000000000
:
? 32767
32767 0111111111111111
:
? -32767
-32767 1000000000000001
:
The program uses gets( ) to read a string, then converts this input to an int. The
16-bit pattern for this value is returned in a string by make bin str(). The
program displays this string.
Converting internally from a string to the desired type is a safer way of

424 Using QuickC
getting input than using scanf( ), because scanf( ) can get confused if it encoun-
ters the wrong type of information, such as a string, when it expects a
numerical value.
The make _ bin _str() function works with a long MAX PWR value
to avoid difficulties with the leftmost bit, the sign bit on regular int variables.
Note that in the program you can only get the bit pattern for if this is the
first binary representation you ask for. After the first time through the loop,
the program checks at the bottom of the do-while loop, so the bit pattern for
is never computed again.
Although the bitwise operators have the same kinds of names as the
logical operators — AND, OR, NOT — there are some important differences
between them. The logical operators work with entire expressions, and always
return a value that can be interpreted as true or false. The bitwise operators, on
the other hand, work with each individual bit of their operands. The results
can be any integral number within the allowable range. Thus, the logical
operators return logical values, whereas the bitwise operators return numbers
having the appropriate bit patterns.
The Bitwise Complement

Operator
You may want to reverse a bit pattern by turning every bit to 0, and every bit 1
to 1. For example, 1010101010101010 would become 0101010101010101. C's

bitwise complement, or negation operator, ~, performs such a reversal. This
operator, which is sometimes known as the one's complement operator,
converts every to and every to 0. The following program illustrates the
1 1
bitwise complement operator at work;
/* Program to display the binary representation of 16-bit Integers,

and the bitwise negation of the specified integers..
Program illustrates binary representations and bitwise negation operator.
•/
•Include <Btdlib.h>
•define NULL.CHAR •\0'
•define MAX STR 80
; ; ; ;; ; ; ; ;; ; ;; ,,
main ()
int value
int make_bin_str ( char *, int);
char val_Btr [ MAX.STR]; /* value to convert, read as string */
printl ( "? ");

gets ( val.str)
value " atoi ( val_str)
printf ( "Xd " value)

: ,
if ( make_bin_str ( curr.str, value))

printf ( "y,s\n" curr.str) ,
else
printf C "string not built correctly:; %s\n"
curr.str)
/* now apply the bitwise negation operator. */

printf ( "" Xd "
", "value); ;
if ( make.bin.str ( curr.str, "value))

printf ( "Xs\n" curr.str) ,
else
printf ( "string not built correctly:: XsNn"
curr.str)
printf ( "? ");

gets ( val.str)
value - atoi ( val str)
>
while ( value 1-0);
/• build a string consisting of binary digits, based on value passed in */

int make bin str ( char 'str. int value)
{
*define MAX.PWR 327681 /* largest bit in an unsigned 16 bit int */
unsigned index;
int outcome, bin.place 0;
for ( index - MAX.PWR; index > 0; index /- 2)
{
outcome • (int) ( value / Index)
if ( (outcome --1) (outcome -- -1)) I I
str [ bin_place++] • '1';

else
str [ bin_place++] "O";
value X* index;
>
str [ bin.place] - NULL.CHAR;
if ( bln_place — 16) /* if 16 bits were processed : -- IB */

return ( 1)
•Isa
return ( 0)
426 Using QuickC
A sample session with this program produced the following listing:
?
: 0000000000000000
" -- -1 1111111111111111
:
? 1
1 : 0000000000000001
- -- -2 1111111111111110
:
? -1
-1 : 1111111111111111
== 0000000000000000
:
? 2
2 0000000000000010
"
:
-3 1111111111111101
:
? -2
-2 1111111111111110
~
:
1 0000000000000001
:
? 32767
32767 0111111111111111
~
:
" -32768 1000000000000000

:
? -32767
-32767 1000000000000001
"
:
" 32766 0111111111111110

:
? -32768
-32768 1000000000000000
' ~ 32767
:
0111111111111111
:
This program does the same things as the previous program and, in
addition, it computes and displays the binary representation of the bitwise
negation of each value.
Notice that the bitwise complement, or negation, of a number is not the
same as the arithmetic negation. Thus, —5(1111 1111 1111 1010) does not
represent the same number as —5 (1111 1111 1111 1011). However, both the
arithmetic and bitwise negation operators produce a positive number from a
negative one, and vice versa.
The Bitwise AND Operator

The bitwise A ND operator, &, combines the bit patterns of its two operands, if
corresponding bits on both operands are 1, then the same bit in the outcome
will be 1; otherwise the bit will be in the outcome. For example,
1000000000000001 & 1010101010101010 would produce 1000000000000000,
since only the leftmost bit is 1 in both operands.
Essentially, the bitwise AND operator multiplies corresponding bits from
each operand, and puts this product in the corresponding position in the
result.The only possible products are from — * 0, * 1, 1 * — and
1 —
from 1*1. Thus, the bitwise AND operator returns a 1 in a specific
position only if both elements used to compute the bit are 1.
I
The results of such an operator can often be shown in a truth table. For
the bitwise AND operator, combining bits from left and right operands, the
truth table is shown in the following illustration:
left
bit
; ;
;; ;
; ; : ; ; ; ;; ; ; ,
428 Using QuickC
int make_bin_str ( char , int)

int mask ( int, int);
int masked_val;
char val_str [ MAX_STR] /* value to convert, read as string */
;
void put.nibble ( char *)
printf ( "\n? "):

gets ( val_8tr)
value ' atoi ( val.str)
printf ( "Xd ", value);

:
xi ( make_bin_str ( curr.str, value))

put_nibble ( curr_str)
else
curr.str)
/* now apply the bitwise AND operator. •/

masked.val mask ( value, OxFF)
printf ( "\nvalue k '/,X -• y,d ", OxFF, masked_val) :
if ( make_bin_8tr ( curr.str, masked.val))

put.nibble ( curr.str)
else
printf ( "string not built correctly: Xs\n" :
curr_str)
printf ( "\n? ");

gets ( val.str)
value atoi ( val.str)
}
while ( value I- 0)
/• build a string consisting of binary digits, based on value passed in */

int make.bin.Btr ( char *Btr, int value)
<
#define MAX.PWR 32768L /• largest bit in an unsigned 16 bit int */
unsigned index;
int outcone, bin.place • 0;
lor ( index - HAX.PVffi; index > 0; index /- 2)

<
if ( (outcome 1) •
(outcome -« -1)) I I
str [ bin_place++] • '1';

else
str [ bin_place++] = '0';
value X- index;
}
Btr [ bin.place] - HULL.CHAR;
if ( bin.place " 16) /» if 16 bits were processed :

-- 15 */
return ( 1)
else
return ( 0)
; ; ;
/* mask off the specified bit patterns */

int mask ( int value int the mask) ,
<
return ( value ft the.nask)
}
/* write a string in groups of 4 characters,

with each group separated by a space.
Useful for writing bit patterns grouping the bits into
groups of 4 makes It easy to determine hexadecimal digits.
—
*/
void put nibble ( char *str)
{
int index
for ( index - 0; str [ index] I- NULL.CHAR; index++)

{
If ( ( index % 4) -- 3)
printf ( "%c " str , [ index] )
else
printf ( "Xc", str [ index]);
>
For a sample session, this program produces the following output:
?
0000 0000 0000 0000
"
:
value ft FF 0000 0000 0000 0000:
? 266
256 0000 0001 0000 0000
:
value ft FF "
0000 0000 0000 0000:
7 1023
1023 0000 0011 1111 lUl
"
:
value ft FF 255 0000 0000 1111 1111 :
7 1001
1001 0000 0011 1110 1001
value ft FF
:
233 -
0000 0000 1110 1001 :
This program displays the bit pattern for the number you enter, and
displays the bit pattern of the number resulting when you mask this number
with the number OxFF, which has all 1 's in its rightmost byte and all O's in the
rest of the number. The bit patterns are displayed in groups of 4 bits, some-
times known as a nibble.
The only differences betwen this main( ) function and the previous one
are the calls to put _ nibble( ) instead of printf( ), and the activity involving
masked _ value. This program has two new functions to do the work: ma$k( )
and put _ nibble( ).
The mask() function returns the result of applying a bitwise AND

operator to its two parameters. Notice that the parameter is specified in
;
430 Using QuickC
hexadecimal (prefixed by Ox). While not necessary, this is common, because it

is often much easier to determine what bits are 1 by looking at the hexadecimal
representation. Remember, each hexadecimal digit represents 4 binary bits, or
one nibble. Thus, the value OxFF represents the bit pattern 0000 0000 1111 1111.
Similarly, the value OxAF represents the bit pattern 0000 0000 1010 1111.
This bit pattern is much easier to determine from the hexadecimal representa-
tion than from its decimal value, 175.
The function put_nibble() writes characters to the screen in groups of

four. This function will usually be passed a string representing binary digits.
The function makes it much easier for you to read a binary number than if all
You can determine the hexadecimal representation

16 bits are written together.
of the number more easily from the output of put nibble(). _

If OxFF masks off everything but the rightmost byte of a number, how
would you mask oif just the rightmost byte? You can accomplish this by
substituting the following assignment for the one in the preceding program,
and changing OxFF to ~OxFF wherever you find it.
masked.val - mask ( value , "OxFF)
For a session with the same input as for the previous program, the new
version of the program would produce the following output:
?
0000 0000 0000 0000
:
value k FFOO •= 0000 0000 0000 0000

:
? 266
256 0000 0001 0000 0000
"
:
value k FFOO 256 0000 0001 0000 0000

:
? 1023
1023 0000 0011 1111 1111
:
value It FFOO -- 768 0000 0011 0000 0000

:
? 1001
1001 0000 0011 1110 1001
:
value k FFOO -- 768 0000 0011 0000 0000

:
The only two programs is in the value used to

difference between the
mask — OxFF in one case, and its one's complement (~OxFF) in the other.
How would you use masks to distinguish even from odd numbers?
The Bitwise OR Operator

The bitwise OR operator, \
, takes two operands and returns a value whose bit
pattern contains 1 wherever the corresponding bits of the left or the right
operand, or of both operands, are 1 . The only zero bits in the result of a bitwise
OR operation come in places where both operands have bits. For example,
1101010101010101 I
1010101010101010 would producelllllllllllllUl, since one
or the other operand has I's in each place in the result.
In essence, the bitwise OR operator works like a loose form oi addition on

bits. Just as the bitwise AND operator multiplied corresponding bits from the
left and right operands, so the bitwise OR operator adds corresponding bits.
This addition differs from ordinary addition, however. First, there are no
carries from one bit position to another. Second, 1 + ==
1 1 in this addition.
The truth table for the bitwise OR operator provides the same results, as shown
here.
left
bit
432 Using QuickC
«deflne
"pure" powers of two, so that each of these constants has a different bit
pattern.
The regions have been defined in a way that will keep them from overlap-
ping; that is, no two regions have a 1 bit in the same place. This makes it
possible to use the bitwise OR operator to specify a combination of regions, all

of which can be treated together This combination of bit patterns results in a
number that is useful not for its value, but for its bit pattern. The binary
representation of the resulting number has a 1 in each bit position that
corresponds to one of the regions out of which the number was built, and hasO
in all the other bit positions.
Thus, the first assignment statement makes terri consist of the following
regions: NORTH, NNE, NE, ENE. The bit pattern for terrl would therefore
consist of 0000 0000 0000 1111.
Once you've created new value for terrl and other territories, you can
the
ask such questions as whether a given region is in a particular territory. The
following expression would determine whether WEST was in terrl:
/* asBuiie nj.val has been defined as int */
my.val - terr2 k WEST;
If the bit corresponding to WEST is not on in terr2, the expression on the right
side will be 0, since that expression could contain a number with a 1 bit only if
terr2 had the WEST bit turned on.

Look at the last assignment to terrl in the program, in which the
territories are rearranged. To combine territories, you can simply "add" the
numbers representing the two territories. This creates a new territory whose
bit pattern is the "sum" (bitwise OR) of the original territories.
A complication arises because the statement also redefines the territory

by removing some regions. Recall that the bitwise AND operator can be used
to mask them from the number. To
particular values, effectively removing
create a mask to remove a specific bit, use a number with that bit set to 0, and
with the remaining bits set to The easiest way to do this in our example is to
1 .
take the bitwise complement of the region. Thus, the mask to remove NORTH
would have the bit pattern, 1111 1111 1111 1110.
The bitwise AND operator can then be used to remove the region. The
434 Using QuickC
following illustration carries out the operations in the assignment statement,

showing the resulting bit patterns along the way:
0000 0000 0000 1111 (terrl)

I 0000 0000 1111 0000 (terr2)
0000 0000 1111 nil

The bitwise XOR operator
The XOR operator {) shares properties with the other bitwise opera-
bitwise
tors. The XOR (for exclusive OR) operator, fits somewhere between the
bitwise AND and bitwise OR operators. It combines corresponding bits in its
left and right operands, returning if the two bits have the same values, and
returning 1 if the two bits have different values. That is, the XOR operator
returns a 1 when either the left bit is 1 or the right bit is 1, but not both.
Whereas the bitwise OR operator includes the cases where both bits are 1 , the
XOR operator excludes the cases where both bits are 1. For example,
1101010101010101 1010101010101010 would produce 0111111111111111. This is
almost identical to the result for the OR operator, except that the leftmost bit in
this result is 0, because both operands had a 1 in this position.
The truth table for the bitwise XOR operator is shown in the following
illustration:
lalt
bit
436 Using QuickC
#deflne
*define
;
438 Using QuickC
merits, which have the same low precedence as all the other assignment
statements. The XOR operator, on the other hand, has a precedence between
that of the bitwise AND operator and that of the bitwise OR operator. This is
reasonable considering the fact that this operator seems to share properties
with each of these other operators.
Let's look at one more example, to illustrate that you can toggle on
multiple bits at a time.
/* Program to illustrate bitwise XOR operator for toggling values. */
define QDD.FLIP OxAAAA /• 1010 1010 1010 1010 */

define EVEN.FLIP 0x5555 /* 0101 0101 0101 0101 •/
main
<
int 11 - 32787. 12 • 32767;
void toggle.val ( int * int)
,
prlntf ( "il "

Xx; 12 -- Xx\n" 11. 12); .
toggle.val (til. ODD.FLIP);

toggle.val ( W2. EVEN.FLIP);
prlntf ( "11 odd -- Xx; 12 even -- Xx\n",
/• Toggle the specified bits in val. •/

void toggle.val ( int 'val, int bits)
{
*val *• bits;
}
11 •• 7fff; 12 "
7fff
11 odd - d555; 12 even • 2aaa
This program simply flips the even numbered bits in one number and the
odd numbered bits in a second number. Toggling is a very common type of
program change. For example, many printers have controls that simply toggle
between on and off Keeping various printer settings in distinct bits on a
variable can be a compact way of storing the information, just as changing
settings by making bitwise changes to the variables can be an efficient way of
controlling the printer.
; ; ; ; ;; ; ; ; ;
; ;
Shift Operators
C also provides operators for simply shifting a sequence of bits to the left or
right by a specified number of positions. When bits are shifted to the left, the
bits at the left end are "pushed off" the variable and discarded. Positions being
vacated (that is, postions to the right, in this case) are filled in with zeros as the
shifting process occurs.
The left shift operator («) lets you carry out such bit moves. The
following program illustrates the use of the left shift operator.
/* Program to illustrate use of lelt shift operator. */
#include <stdlib.h>
•define NULL.CHAR AO'
fdefine MAX.STR 80
main ()
int value
int make_bin_8tr ( char », int);
int shifted.val, shift.amt;
/• get value to shift and amount to shift */

printf ( "\n? "):
gets ( val_str)
value - atoi ( val.str)
printf ( "Shift by? ")
gets ( val_str)
shif t_amt - atoi ( val_str)
/» bring shift.amt within valid bounds */

shift.amt - bound.int ( shift_amt. 0. 15);
printf ( "Xd " :value) ,
if ( make.bin.str ( curr.str, value))

put.nibble ( curr_str)
else
printf ( "string not built correctly:
curr.str)
/* now apply the left shift operator. */

shif ted. val value << shift.amt;
printf ( "\nvalue Xd Xd « -
", shift.amt, shifted.val):
if ( make.bln.str ( curr.str, shifted.val))

; ;; ; ;; ; ;; ; ; ; ;
440 Using QuickC
printf { "string not built correctly: : XsXn"

curr.str)
/* get value to shift and amount to shift */

printf ( "\n\n? ");
gets ( val.str)
value " atoi ( val.str)
if ( value 1-0) /* atop if entered */
<
printf ( "Shift by? ");
gets ( val_Btr)
shif t.aiiit atoi ( val.str)
shift.ant bound.int ( shift amt, 0, 15);
>
y
while ( value I- 0)
/* build a string consisting of binary digits, based on value passed in •/

Int make.bin str ( char 'str, int value)
{
#define MAX.PWR 32768L /* largest bit in an unsigned 16 bit int */
unsigned index;
int outcome, bin.place 0:
for ( index - MAX.PWR; Index > 0; index /- 2)

{
if ( (outcome 1) (outcome I I
" -1))
str [ bin.place++] " '1';
else
str [ bln_place++] '0';
value % index;
>
str [ bin.place] - NULL. CHAR;
if ( bin.place — 16) /* if 16 bits were processed :

-- 15 */
return ( 1 )
else
return ( 0)
/* write a string, in groups of four letters */

void put.nlbble ( char *str)
<
int index
for ( index - 0; str [ index] I- HULL.CHAR; index++)

{
if ( ( index % 4) -- 3)
printf ( "Xc " str , [ index] )
else
/* bring an integer value between the specified bounds */

int bound.int ( int val, int lower, int upper)
{
if val < lower)
(
return ( lower)
else if ( val > upper)
return ( upper)
else
return ( val)
>
; ; : ; ; ; ;
A sample session with this program produces the following:
7 100
Shift by? 5
100 0000 0000 0110 0100
«
:
value B -- 3200 0000 1100 1000 0000:
? 18
Shift by? 5
16 0000 0000 0001 0000
«
:
value 5 612 0000 0010 0000 0000

:
? 2000
Shift by? 8
2000 0000 0111 1101 0000 j
«
:
value 8 -- -12288 1101 0000 0000 0000 :

5
t
? 2000 i
Shift by? -5 5
2000 0000 0111 1101 0000
« "
:
value 2000 0000 0111 1101 0000:

|
'{
?
i
5
This program lets you specify the value you want to change and the i
number of places you want to shift the value to the left. The program then .:
and displays the results.

carries out the left shift, S!
The main( ) function has been changed somewhat from earlier versions of i'l
the program to present the left shift operator. In addition, the function
bQund_int( ) has been added to make sure the program doesn't try to shift by
more than the allowable amounts. This function brings any values entered for
shift_amt within the range through 15.
When the left shift operator is applied, the bits on the left simply disap- li|
pear as they are overwritten by the bits coming from the right. As the positions la
on the right are vacated, those bits are replaced by 0. The following version of
the program makes this even clearer. The middle part of main( ) has been
changed from the previous program -to loop through the left shift process,
one place at a time.
/* Program to illustrate uae of left shift operator, step by step. */

include <stdlib.h>
define HULL CHAR '\0'
define MAX.STR 80
main ()
•
int value index,
int make_bin_str ( char *. int);

int shifted.val, shift_amt;
char curr.str [ MAX.STH]
char val_str [ MAX_STR] /* value to convert, read as string */
;
void put_nibble ( char *)
printf ( "\n? ")

gets ( val_str)
value atoi ( val str)
; ; ;;;;; ; ; ,;
; ; ; ; ; ; . , ; , .
442 Using QuickC
getB ( val.Btr)
8hif t.ant - atoi ( val.atr)
hif t.amt bound.int ( shllt.ant
printf ( "Xd " value) : ,
11 ( make.bln.Btr ( curr.atr, value))

else
printf ( "string not built correctly:: '/.s\n"
curr.Btr)
/* because will need to shift one place at a time in loop */

shifted. val - value
/* now apply left shift operator, one place at a time */

lor ( index • 1; index <= shift.amt; index++)
shif ted.val «- 1
printf ( "\nvalue %d Xd " « " :
index, shif ted_val)

if ( make.bin.str ( curr.str, shifted_val))
else
curr.str)
printf ( "\n\n? ");

gets ( val.str)
value " atoi ( val str)
if ( value I- 0)
{
gets ( val.str)
shift.amt atoi ( val. str)
shift.amt - bound.lnt ( shift amt, 0, 16);
}
}
while ( value I 0)

int make.bin.Btr ( char *8tr, int value)
{
»def ine MAX.PWR 32768L /• largest bit in an unsigned 16 bit int */
unsigned index;
int outcome, bin.place • 0;

{
outcome - (int) ( value / index)
if ( (outcome -• 1) (outcome I I
— -1))
str [ bin.place++] - '1'
else
Btr [ bin.place++] • '0"
value X" index;

>
Btr [ bin.place] - NULL.CHAR;
If ( bin.place - 18) /* if 16 bits were processed

return ( 1)
else
return ( 0)
/• mask off the specified bit patterns •/

int mask ( int value, int the mask)
{
; ; ; ; ;
return ( value t the. mask)
/* write a string, in groups of four letters */

void put nibble ( char 'str)
{
Int index
for ( Index - 0; str [ index] I- NULL.CHAR; index++)

<
if ( ( index 51 4) -- 3)
else
>

int bound.int ( int val, int lower, int upper)
<
if val < lower)

(
return ( lower)
return ( upper)
else
return ( val)
For an input of 127 as the value and 6 as the number of places to shift, the
program produces the following output:
127 0000 0000 0111 1111

value
:
« 254 "
0000 0000 1111 1110
value «
1
2 608 • :
0000 0001 1111 HOO

value « 3 1016 - :
0000 0011 1111 1000

«
:
value 4 -- 2032 0000 0111 1111 0000

«
:
value 6 -- 4064 0000 1111 1110 0000

«
:
value 6 -- 8128 0001 1111 1100 0000 :
In this version of the program, you can literally see the bits marching across
the number.
^REMEMBER When the left shift operator («) is applied, the bit pattern
is always filled in with O's on the right.
There is also a right shift operator (») that moves bits towards the right
end of the number. Bits at the right end disappear as they are overwritten by
the new bits. The bits at the left end are not necessarilyfilled in with zeros,
however. The action taken at the left of a number to which the right shift
operator is being applied is implementation dependent.
Logical and Arithmetic Shifts There are two strategies that can be used
when filling in bits at the left end of a number to which the right shift operator
is being applied. A logical shift always fills in these bits with 0. An arithmetic
shift may fill them in with or 1, depending on the value and type of the
;; ; ; ; ; ;; ; ; ; ; :
444 Using QuickC
variable being shifted.

If the variable is an unsigned int, the bits are always filled in with 0. On the
other hand, if the variable is a signed int, the bits are filled in with whatever
value was currently stored in the sign bit.
Testing the Right Shift You can take advantage of QuickC's integrated
environment to experiment quickly and easily with the way the implementa-
tion handles right shifts. The following program currently defines the variable
shifted val as an unsigned int.
/* Program to Illustrate use oJ shift operators. */
#include <8tdlib.h>
#define MAX.STR 80
main ()
{
int value, index;

int maie_bin_8tr ( char *, int);
unsigned shilted_val
int shift_amt;
printf ( "\n? ")

gets ( val.str)
value » atoi ( val.str)
gets ( val.str)
shift. amt » atoi ( val.str)
shift.amt bound. int ( shift. amt, 0, 15);
do
printf ( "Xd " value)

: ,
if ( make.bin.str ( curr.str. value))

else
printf ( "string not built correctly:
curr.str)
shifted.val " value;
/* now apply the left shift operator. */

for ( index » 1; index <- shift.amt; index++)
{
shifted.val »• 1;
;
; ; ; ;
; ; ; ; :
printf ( "\nvalue Xd » Xd —
". :
Index, shlf ted.val) :
if ( make_bln_8tr ( curr.Btr. shifted.vaD)

put.nlbble ( corr.str)
else
printf ( "string not built correctly:: Xs\n"
curr_str)
printf ( "\n\n? ");

gets ( val_str)
value " atoi ( val_str)
if ( value I- 0)
<
gets ( val.str)
shif t.amt " atoi ( val.str)
shift.amt - bound.int ( shift.amt, 0, 15);
}
>
while ( value ) 0)
/* build a string consisting of binary digits, based on value passed In */

int make_bin_str ( char •str, int value)
{
•define MAX.PWR 32768L /* largest bit in an unsigned 16 bit int */
unsigned index;
int outcome, bin_place » 0;
for ( index • MAX_PWR; index > 0; index /- 2)

J
?
outcome (int) ( value / index) {,
if ( (outcome "= 1) II (outcome »= -1))

else
value X" index;

>
if ( bin.place - 16) /* if 16 bits were processed :

-- 15 */
return ( 1);
else
return ( 0)
/• write a string, in groups of four letters •/

void put_nibbla ( char tstr)
{
int index
; ;
; ;
446 Using QuickC
lor ( index - 0; str [ index] 1= HULL.CHAH; index++)

{
if ( ( index X 4) 3)"
printl ( "%c " Btr , [ index] )
else
printf ( "He", str [ index]);
}

Int bound.int ( int val, int lower, int upper)
{
11 val < lower)
(
return ( lower)
return ( upper)
else
return ( val)
Start up QuickC with this program

working file by selecting the
as your
Start option in the Run menu. Try tracing 35 and —35, for example. When
you've finished running the program, QuickC will put you back in the program
source Change the type of shifted— val to int and start the program again
file.
using the same values as before. Notice the difference in the bit patterns that
result.
QuickC uses an arithmetic shift, so that signed numbers get shifted by

filling in the left bits with whatever value was stored in the sign bit.
^ CAUTION Be careful when using the right shift operator. If your imple-
mentation uses an arithmetic shift (as does QuickC), then the left bits may
sometimes fill with and sometimes with 0.
1
Another way of seeing the differences between signed and unsigned

values when applying the right shift operator is to perform the same operations
on two different variables, one an int and the other an unsigned int. Add the
following three lines to the preceding program;
int shifted.int.val: /* add to variable definitions in mainO */
8liifted_int_val - value; /* add after shifted_val value; »/
Bhilted.int.val »- 1; /* add after shifted.val »- 1; */

.
Try the following to see how QuickC handles signed and unsigned vari-
ables when right shifting:
1 Start up QuickC with this revised program as your working file.
2. Clear all breakpoints and watch variables.
3. Compile the program with the Debug option on.
4. Add the following watch variables:
shifted— val,x
shifted_int_val,x
index
5. Set a breakpoint at the first call to printf( ) after the right shifts in the
for loop.
6. Step through this program, comparing the values of shifted— val and
shifted_int val as the right shift proceeds.
Because the bitwise shift operators have a precedence just below the
arithmetic addition operators, and just above the relational operators, the shift
operators have a higher precedence than the other binary bitwise operators.
^REMEMBER The precedence of the bitwise shift operators is between the

precedences of the arithm.etic operators and the relational operators.
Shift Operators and Powers of Two

As you probably know, the easiest way to multiply a number by 10 is to add a
at the right end of the number. To multiply by 100, add two zeros, and so on.
For example, 35 * 10 == 350, 35 * 100 = 3,500, 35 * 1000 = 35,000. To muhiply

by a power of ten, you move the number over one digit to the left, and add a
zero in the one's position.
Similarly, there is a direct relationship between the left shift operator and
multiplication by powers of two. Shifting a value's bits left by one place
amounts to muhiplying by 2; shifting by 2 bits amounts to multiplying by 4,
and so forth.
; ; ; ; ; ;
448 Using QuickC
The following listing shows this relationship:
/• Prograa to illustrate relationship between left shift operator

and Dultlplication by two.
*/
înclude <Btdio.h>
#inelude <stdlib.h>
*deflne MAX.SHIFT 12
*define HAX.STK 80
•define NULL.CHAR •\0'
Dain
unsigned value, index, shift;

char 'info, bit.str [ MAX.STR]
int make.bin.str ( char * int) ,
void put .nibble ( char *);
printf ( "Value to shift? »);

gets ( info)
value atoi ( info)
for ( index - 0; index < MAX.SHIFT; index++)
shift - value << index;

printf ( "X2u: XBu -- ", index, shift);
if ( make.bin.str ( bit.str, shift))
put. nibble ( bit.str)
/* else do nothing •/
printf ( "\n");

int make.bin.str ( char »8tr, int value)
{
#deflno MAX.PWR 32768L /• largest bit in an unsigned 16 bit int */
unsigned index;
int outcome, bin.place • 0;

<
outcome " (int) ( value / index);
if ( (outcome ""1) II (outcome • -1))
str [ bin.place++] - '1'
else
str [ bin.place++] "O"
value X" index;

}

if ( bin.place -- 16) /* if 16 bits were processed
return ( 1);
else
return ( 0)

groups of 4 makes It easy to determine hexadecimal digits.
void put.nibble ( char 'str)

<
;
int Index
lor ( index • 0; str [ index] I- NULL.CHJUl; index++)

<
11 ( ( index X 4) -- 3)
printl ( "Xc ", str [ index]);
else
printl ( "Xc", str [ index]);
This program produces the following bit shift values for a starting value of 5:
Value to shilt? 5
; : ; ; ; ; : ; . ;
450 Using QuickC
nain
imsigned value, index, shift;

char •info, blt.etr [ MAX.STR]
Int make.bin.str ( char •, int)
printf ( "Value to shift? »);

gets ( info)
value atoi ( info)
for ( index - 0; index < MAX. SHIFT; index++)

{
shift value index; »
printf ( "X2u: XSu -- " index, shift); ,
if ( make.bin.str ( bit.str, shift))

put.nibble ( blt.str)
/* else do nothing */
printf ( "\n");

int make bin str ( char *str, int value)
{
#def ine MAX.PWR 32768L /* largest bit in an unsigned 16 bit int */
unsigned index;
int outcome, bin.place » 0;
for ( index ' MAX PWR; index > 0; index /= 2)

{
outcome - (int) ( value / index)
if ( (outcome 1) II (outcome " -1))
str [ bin.place++] -
else
str [ bin.place++] «
value % index;
)
str [ bin.place] NULL.CHAR;
if ( bin.place - 18) /* if 16 bits were processed

return ( 1)
else
return ( 0)

groups of 4 makes it easy to determine hexadecimal digits.
—
*/
void put nibble ( char *str)
{
int index
for ( index - 0; str [ index] I- NULL.CHAR; index++)

{
if ( ( index X 4) •- 3)
Value to shift? 40060

40960
452 Using QuickC
of the conditional operator, and identifies the elements:
structure of Conditional Operator:
condition ? alternative! : alternatives
alternativel
alternative2
I I
z - (x < 0)
operator
The conditional operator takes three operands. The first is an expression

that evaluates to true or false. If the condition is true, the second operand is
used; otherwise, the third operand is used.

Since the ?: operator has precedence just above that of the assignment
operators, we don't need parentheses in the above statement.
The conditional operator is often used in defining macros for the prepro-
cessor. The following are some examples:
#define ABS_VAL(x) ( (x) >- 0) ? (x) : ( (x))
#define MAX2(x.y) ( (x) > (y)) ? (x) (y) :
#deflne MAX3(x.y,z) ( (x) > (y)) ? MAX2(x.z) : MAX2(y.z)
#define HIN2(x.y) ( (x) > (y)) (y) : (x)

#define MIN3(x.y,z) ( (x) > (y)) MIN2(y,z) : MIN2(x.z)
#deline PR.NICE(v.w,x.y,z) ( ( ((v) % M) M) (y) : (z))
The last macro can be used to display information with a specified

number of entries per line. So far, we've been using an if statement to
accomplish this. The following program illustrates the use of the macros:
/* Program to Illustrate use of conditional operator */
#define MAX2(x,y) ( (x) > (y)) ? (x) :

(y)
*define MAX3(x.y,z} ( (x) > (y)) ? MAX2(x.2) HAX2(y,z)
•define MIN2(x.y) ( (x) > (y)) 7 (y) (x) :
•define MIN3(x,y.z) ( (x) > (y)) 7 MIN2(y.z) MIH2(x,z)
•define PR_NICE(v,w.x,y,z) ( ((v) X (w)) -- (x)) 7 (y) ; (z)

: ; .
main ()
Int rand (void)

int array [ MAX.VALS] ;
int index;
for ( index - 0; index < MAX.VALS: index++)

array [ index] • rand ( )
lor ( index - 0; index < MAX_VALS -3; index++)

{
printf ( "%7d",
MIN3 ( array [ index]. array [ index + 1]
array [ index + 2]));
PR NICE ( index, 10, 9. printf ( "\n"), printl ( ""));
>
41
; ; ;
454 Using QuickC
#(lefine MAX3(x.y.z) ( (x) > (jr)) ? MAX2(x,z) : MAX2(y,z)
*deflne MIN2(x.y) { (x) > (y)) ? (y) : (x)

*deflne MIN3(x.y.z) ( (x) > (y)) ? MIN2(y,z) : MIN2(x,z)
•define PR.NICE(v.w.x.y,2) ( ((v) X M) — (x)) ? (y) : (z)
main ()
{
int rand (void)
int array [ MAX.VALS] , val
int index:
for ( index - 0; index < MAX.VALS; index++)

array [ index] » randO;
for ( index - 0; index < MAX.VALS; index++)

{
val array [ index]
val - ( (val >- 0) tt ( val <= 255)) ? val val ft 255; :
printf ( "X7d". val);

PR.NICE ( index. 10. 9. printf ( "\n"). printf ( ""));
)
41
Table 15-1. Precedence Hierarchy for G Operators
Operator Comments
()[] function and array operators

!
~&= * (cast) +- sizeof( ) ++ unary operators
* / % arithmetic (multiplication)
+ -
« »
arithmetic (addition)
shift operators
relational operators
equality operators
& bitwise AND
bitwise XOR
bitwise OR
&& logical multiplication
logical addition
conditional operator
= += -= *= /= %= &= ^= 1= «= »= assignment operators
comma operator
Summary
This chapter covered some miscellaneous operators. In particular, it examined
the bitwise operators, which can be very useful for situations involving collec-
tions of objects or for systems programs, which often have to manipulate
individual bits.
You have also learned about the conditional operator, which allows you to
select between two alternatives in a compact manner. This operator can be
used to write very powerful macros.

We've covered just about all the operators there are in C. Table 5-1
summarizes these operators and their precedences.
structures,
Unions, and
Other Types
So far, the data types you Ve seen have contained only one type of information.
Even arrays, which contain multiple elements, store only one type of informa-
tion. Sometimes, however, it's convenient to group different types of informa-
tion together — either because the information is logically related or because
the items are components of a larger unit. In this chapter, you'll learn about
all
the structure and union data types, which allow you to group different types of
inforrnation together in one variable. You'll also learn about the bit fields
available in structures. Finally, you'll find out about enumerated data types,
which are available in many implementations, but won't become an official
part of C until the Draft Proposed ANSI Standard is adopted.
457
458 Using QuickC
Structures
Suppose you want to represent information about a day's weather in January.

To record the average temperature and average windspeed for the day, you
could use C's structure type to store the data so that the two items are grouped
together.
A structure is an aggregate variable that consists of several components,
or members. Members can be of different types. In the weather structure
example, you might want to use two members, temp and wind, to record the
information. The following listing specifies a structure named weather, having
two members, or components, temp and wind. In this case, both members are
of type double. Note that the members of a structure are stored in consecutive
storage locations.
struct weather {
double temp;
double wind;
};
This declaration merely creates a structure description, or template,

based on the members specified; it does not allocate any storage for such a
structure. Let's look at the components of this template. The declaration
begins with the keyword struct, which identifies what follows as a structure.
The word weather is the tag, or tag name, of the structure being created.
The material between the matching left and right curly braces represents
the structure's members. Each of these members is declared as if it were a
variable of the specified type. Thus, temp and wind are both specified as being
of type double. The right brace ends the declared structure, and the semicolon
ends the declaration statement. The following illustration shows the compo-
nents of a structure declaration:
Structure tag
i
i
structure \
'*"'"=* weather {
'*° """ ^""'P' Structure
declaration { I
double wind; / members
I
; ,
Structures, Unions, and Other Types 459
you think of struct weather together as specifying the variable's name,

If
then, to define a variable of this type, you could enter the following:
struct weather {
double temp
double wind;
malnO
{
struct weather today;
/• main function body here */
The preceding listing describes a global structure named weather. A local

variable of that type is defined in main( ). The definition contains the keyword,
struct, the tag name associated with the structure (weather), and an identifier
for the variable itself (today).

Let's look at a few more structure declarations and definitions, in
mathematics, complex numbers are aggregates with two components: a real
part and an imaginary The following listing creates a local complex
part.
number structure, complex, and, at the same time, defines two variables of this
type, compl and comp2:
main ()
{
struct complex {
double re
> compl, comp2;
/• code here */
This Structure has the tag name complex, and has two members, re and im.
Both members are of type double. Notice that you can allocate storage for
structure variables at the same time you create the structure itself In this
listing, only function main( would know about the structure of type complex.
)
The storage allocated for the two variables of this type would also be local to
main( ).
The following example specifies a more elaborate structure, which con-

tains various types of information about an adult, including name, age, and
income. The example also defines an array of such structures:
;; : ; ;:
460 Using QuickC
^define MAX NAME 25

*define MAX.PERSONS 10
struct person <

char first, last [ MAX.NAME]
int age
double income:
};
main ()
{
struct person sample [ MAX.PERSONS]
/* code here •/
The person structure declared here has four members — a char( first), a
string (last[]), an int (age), and a double (income).
The preceding listing also defines an array of type person which contains
—
MAX PERSONS elements of this structure. Each element in this array
refers to an entire structure. That is, each array element contains first initial (a
char variable) and name, age, and income information. Thus, sample[ 0]
last
refers to the first person in the array, and sample[ 9] would refer to the last
person. The following listing shows you how much storage each array element
takes up:
«deflne MAX NAME 26

#dellne MAX.PERSONS 10
struct person {
char first, last [MAX.NAME];
int age
double income:
}:
main ()
{
struct person sample t MAX.PERSONS]
int index
printf ( "Each person requires %d bytes\n", sizeof ( sample [ 0]));
If you compile and run this program, you'll find that a person structure
requires 36 bytes of storage — 1 byte for the person's initial (char), 25 bytes for
the last name (char []), 2 bytes for age (int), and 8 bytes for income (double).
Notice the use of the sizeof( ) operator with a structure as an argument here.
How would you determine the amount of storage allocated for the entire array,
sample[]?
In this example, the structure template is global, so any function in the
program could have variables of structure type person. The storage allocated
for sample[] is local, however.
; :
structures, Unions, and Other Types 461
Accessing Structure Members

Once you've allocated space for a structure, by defining a variable of the
appropriate type you can use the structure member operator (.) to access
individual members of the structure. This operator takes two operands. The
left operand name of a variable of the structure's type and the right
is the
operand is a member within that structure. The result of applying the operator
is the specified structure element itself, or its value — depending on the con-
text. In the following program, the structure member operator identifies the
members to which specific values will be assigned. This structure member
operator is sometimes called the dot operator, to distinguish it from another
member operator that you'll learn about later in this chapter. The dot operator
is in the highest category of precedence, along with the array subscripting and
the function call operators.
/* Prograo to show how to access a structure member */
struct weather {
double temp;
double wind:
malnO
{
struct weather today:
today. temp 84.5;

today wind • 10 1
. .
prlntl ( "Temp -- XlO.211: wind

today temp today wind)
. , .
In this program, today.temp is assigned the value 84.5, and today.wind is
assigned the value 10. 1 . Notice that no space has been left between the variable
name, operator, and member identifier. This is common programming prac-
tice, but is not required. Thus, the following assignment statement would also
be valid, although it is rarely seen:
today . wind 10.1:
The following program uses the sample[] array defined in a previous

example to get information about five persons from the user, and then to
display this information.
/• Program to read and display contents oi an array of structures •/

: ;; ; ; ;
462 Using QuickC
«deflne MAX NAME 25

#define MAX.PERSONS 5
#defiiie MAX.STH 80
struct person {
char first, last [ MAX.NAME]
Int age
double income;
};
main ()
struct person sample [ MAX.PERSONS] ;
int index;
char inlo [ MAX.STR] ; /* used to read info for conversio
/* get information about each structure in the array */

for ( index - 0; index < MAX.PERSONS; index++)
printf ( "First initial? ");

gets ( info)
sample [ index]. first " info [ 0];
printf ( "Last name? ");

gets ( sample [ index] .last)
printf ( "Age? ");

gets ( info);
sample [ index], age - atoi ( info);
printf ( "Income? ");

gets ( info)
sample [ index] .income atof ( info);
/• display information about each structure in the array *l

for ( index - 0; index < MAX.PERSONS; index++)
printf ( "Xe. Xs: age •• Wd; income -- $y,6.21f\n",

sample [ index] .first sample [ index]. last,
,
sample [ index]. age, sample [ index] .income)
This program prompts the user for values for each of the person elements
in the sainple[] array. Notice the use of gets( ), in conjunction with a conversion
function (atoi( ) or atof( ), in this case), to read the information. This is often
safer than using scanf( ), which is sensitive to entries of the wrong type. The
info[] string is used solely for the purpose of getting the strings for conversion,
so it can be used for each entry.
Rules for Structures

A structure declaration will have three elements:
1. The keyword, struct

; :;
; .
,
2. A tag name for the structure being created
3. A member list
Tag Names The tag name specifies the identifier for the structure. Once it
has been created, you can think of the structure as being of type struct <tag
name>, although it will beeasiertospeaksimply of type<tagname>. In our
earlier examples, tag names included: person, complex, and weather.
You can refer to the structure as a unit by using its tag. For this reason,
you can assign an entire structure to another, provided the structures have the
same members. Thus, the following assignments are all valid:
/* Progran to illustrate assignments using structures

assigning individual members and entire structures
•/
struct card {
char suit
int val;
};
nain ()
{
struct card hand [ 5]
/* assign values to individual members */

hand [ 0] suit .
hand [ 0] val « .
hand [ 1] . suit
hand [ 1] .val =
hand [ 2] . suit
hand [ 2] . val •
hand [ 3] . suit "

hand [ 3] . val - 3
hand [ 4] . suit
hand [ 4] . val
/• assign entire structures at once */

hand [ 0] - hand [ 1]
hand [ 1] - hand [ 2]
hand [ 2] - hand [ 3]
hand [ 3] - hand [ 4]
/« display structure contents */

prlntf ( "\n\nHand [ 0]: suit •- Xc val -- Xu\n" ,
hand [ Ol.suit, hand [ 0].val);

printl ( "Hand [ 1]: suit -- Xc val •- Xu\n". .
hand C l].sult, hand [ l].val);

prlntf ( "Hand [ 2] suit -- Xc val -- Xn\n"
: , ,
hand [ 2]. suit, hand [ 2]. val);

printf ( "Hand [ 3] suit y.c :
-
val -- y.u\n" ,
hand [ 3], suit, hand [ 3]. val);

printf ( "Hand [ 4] suit -- %c val
: y,u\n" . "
suit "
. ; ;
The preceding listing shows examples of nested structures, that is, struc-
tures declared within other structures. Notice how the naming process works.
When you want to access a member of a structure, use the structure
member operator. For example, you would use this operator when you access
pers.first, pers.last, and so on. You would use the same operator to access the
learning member: pers.learning.
Once you've accessed you can access any of its members,
pers.learning,
since pers.learning is a structure. To access its members, use the dot operator.
For example, pers.learning.id and pers.Iearning.yr_grad are valid members.
Again, you can access school in the same way: pers.learning.school.
Once you've accessed that, you can access its members as follows:
pers.leaming.school.major, pers.leaming.school.degree, and pers.leaming.school.gpa.
The access rules for nested structures can get long-winded, but they are
straightforward.
Structures and Addresses Structures are aggregate variables, like

arrays. Unlike arrays, however, the structure's tag refers to a variable rather
than to a pointer. However, you can ask C for the address of a structure. This
address is same as the location of the structure's first member. The
the
following program shows how the addresses of structures and their members
are related:
/* Program to provide Information about storage for structures. */
struct card {
char suit;
int val :
>:
main (}
<
struct card hand [ 6]
/• assign values to individual members */

c
hand [ 0] suit . ' '
hand [ 0]
hand [ 1] suit - 'd';

hand [ 1] val - 1;
hand [ 2} suit - 'li

hand [ 2] val - 2;
hand [ 3] suit
.
, ; ; ; .
, .
466 Using QuickC
hand [ 3] .val - 3;
hand [ 4] .suit = "s"

hand [ 4] .val " 4;
/* assign entire structures */

hand [ 0] » hand [ 1]
hand [ 1] = hand [ 2]
hand [ 2] • hand [ 3];
hand [ 3] = hand [ 4];
/* display storage required for entire structure */

printl ( "A card requires Xd bytesNn", sizeof ( struct card));
/• display atructure contents */

printf ( "\n\nHand [ 0] suit Xc val -- Xu\n"
: " ,
hand [ 0].suit, hand [ 0].val);

printf ( "Hand [ 1]: suit -- Xc val Xu\n". . ~
hand [ l].suit. hand [ l].val);
printf ( "Hand [ 2] suit -- Xc val -- Xu\n"
: .

printf ( "Hand [ 3] suit Xc:val Xu\n" ~ . ~
hand [ 3] suit hand [ 3] val)
. . .
printf ( "Hand [ 4] suit Xc:val -- Xu\n" " .
/* display location information */

printf ( "\n\nHand [ 0] ft Xu. tsuit -= Xu. ftva:1
: " " Xu
thand [ 0] fthand [ 0] suit fthand [ 0] va . , .
printf ( "Hand [ 1] ft Xu, ftsuit

: Xu, ftval *»
fthand [ 1] fthand [ l].suit, fthand [ l].va
printf ( "Hand [ 2] ft :
•
Xu, ftsuit "» Xu. ftval -•
fthand [ 2] fthand [ 2] suit fthand [ 2] va . , .
printf ( "Hand [ 3] ft "" Xu, ftsuit "" Xu. ftval --

:
thand [ 3] fthand [ 3] suit fthand [ 3] va .
"
. .
printf ( "Hand [ 4] ft Xu, ftsuit

: Xu, ftval" —
fthand [ 4] fthand C 4]. suit, fthand [ 4] .va
; ; : : ; : ; ;
This program displays the values and addresses of five cards. Notice that
the locations of a structure's members are consecutive. The C compiler guar-
antees this. Similarly, the compiler guarantees that successive array elements,
which are structures in this case, have consecutive addresses.
Structures as Function Parameters You can pass structures as parame-

ters to functions. The prototypes and declarators follow the same general rules
as for storage class specifiers. That is, to declare a structure as a parameter, you
need to put struct before the name of the structure. The following program
shows how to pass structures as parameters:
/• ProErun to get and display various information about education,

students, and persons.
Program illustrates use ol nested structures and structures as parameters
to functions.
»/
înclude <stdlo.h>
include <Btdlib.h>
#define MAX.STR 80
fdeflne MAX NAME 26
«deflne MAX.EDUC 15
struct education {
char major [ MAX.EDUC]
char degree [ MAX.EDUC]
double gpa;
};
struct student {
struct education school:
char id [ MAX.EDUC]
int yr.grad
};
struct person <

char first;
char last [ MAX.HAHE] ',
int age
double income:
struct student learning:
};
main ()
struct education ed;

struct student stu:
struct person pers;
char info [ MAX.STR]
void show.ed ( struct education) ; /* show education structure •/
void show. stu ( struct student) ; /• show student structure */
void show.pers ( struct person): /• show person structure •/
/* Gat information for education structure. •/

printf ( "Major? ");
gets ( ed. major)
printf ( "Degree? ");
gets ( ed. degree)
:;;; ; : : ;: ; : : ; ; ; ;
468 Using QuickC
prlntf ( "GPA? ");

gets ( info)
•d.gpa - atof ( Info);
/* DlBplay values for atructure's members */

show.ed ( ed)
/* Get information for student structure. */

prlntf ( "Student ID? »);
gets ( stu.ld)
printf ( "Graduated what year? ");
gets ( info)
Btu.yr.grad • atoi ( info):
Btu. school ed:
/• Display values for structure's members */

show.stu ( stu)
/* Get Information for person structure. •/

printf ( "First Initial? ")
gets ( info)
pers. first • info [ 0]:
printf ( "Last name? "):
gets ( pers. last)
printf ( "Age? "):
gets ( info):
pers. age atoi ( info):
printf ( "Income? "):
gets ( info)
pers. income atof ( info);
pers. learning • stu;
/* Display values for structure's members */

show.pers ( pers)
/• Display values of education structure.

Illustrates function declarator for structure parameters.
void show.ed ( struct education edu)
printf ( "Xb, Xb, X6.21f\n", edu. major, edu. degree, edu.gpa);
/* Display values of student structure, including education structure */

void show.stu ( struct student stdnt)
void show.ed ( struct education)
printf ( "Xb, X5d\n" stdnt. id, stdnt yr.grad) .

.
show.ed ( stdnt. school)

}
/• Display values of person structure.

Including values of student structure
•/
void show.pers ( struct person pers)
void show.stu ( struct student)
printf "Xc. Xb, age X3d. income -- $X6.21f\n".

(
pers. first, pers. last. pers. age. pers. income)

show.stu ( pers learning) .
;
This program produces the following session:
Major? Cfl
Degree? bs
GPA? 3.85
cs, bs, 3.86
Student ID? 1234667890
Graduated what year? 1964
1234667890. 1964 t
C8, bs. 3.86

First initial? q
Last name? werty
Age? 67
Income? 63600
q. werty, age 67, income •• $63600.00
1234667890, 1964
cs, bs, 3.86
Notice the function prototypes. You must include the keyword, struct, in the
prototype and in the function declarator.

Because structures are ordinary variables, you are just passing a copy of
the structure when you use the structure as an argument in a function call. In
other words, unless you take special actions, structures are passed by value.
Functions Returning Structures In the Draft Proposed ANSI Standard,

C functions can also return structures. The following program uses a function
that returns a structure after doing its work:
/• Program to illustrate functions returning structures. */
#include <stdlo.h>
#include <stdlib.h>
•include <math.h> /* for sqrtO •/
define MAX.STR 80
struct weather {
double temp, wind;
>;
struct chill i
struct weather weath;
double windchill:
};
/• Compute the windchill factor for the given temp and wind values */
struct chill get chill ( struct weather today)
<
double numl nuiii2
,
struct chill wch;
numl - 10.46 + 6.68 • sqrt ( today. wind) - 0.447 » today. wind;

num2 " 457 - 5 * today. temp;
wch. windchill - 91.4 - (numl * num2 / 110);
; : ; ; ; ;
470 Using QuickC
wch.weath.tenp • today. temp;

wch.weath.wlnd - today. wind;
return ( wch)
main ()
struct weather todays.weather;

struct chill todays_chill:
struct chill get.chill ( struct weather)
printf ( "Temperature? ");

gets ( info)
todays.weather.temp = atol ( info);
printf ( "Wind? ");

gets ( info)
todays.weather.wind " atol ( info);
todays.chill = get.chill ( todays.weather)
printf ( "Temp -= y.6.21f. wind = X6.21f , windchill == y.6.21f\n"

today s.chi 11 .weath.temp,
todays.chill weath.wind,
todays.chill.windchill)
This program computes the windchill factor, or index, when given a

temperature (in degrees Fahrenheit) and a wind speed (in miles per hour). The
windchill index is the temperature with no wind at which you would feel as cold
as you do in the given wind and temperature combination. For example, when
the temperature is 0° Fahrenheit and the wind is blowing at 20 mph, the
temperature seems as if it's almost —39° F. The program produces the follow-
ing sessions:
Temperature? -10
Wind Speed? 10
Temp —
-10.00, wind •- 10.00, windchill - -33.62
Temperature? -10
Wind Speed? 20
Temp ~
-10.00, wind 20.00, windchill
Temperature?
Wind Speed? 10
Temp " 0.00, wind - 10.00, windchill -- -21.20
Temperature?
Wind Speed? 20
Temp " 0.00, wind - 20.00, windchill - -38.90
Temperature? 10
Wind Speed? 10
Temp —10.00, wind -- 10.00, windchill --
Temperature? 10
Wind Speed? 30
Temp -10.00. wind - 20.00, windchill
; ; ; ; ;, ; ; ;
Pointers to Structures
As you learned earlier, structures are ordinary variables, not pointers. If you
pass a structure as an argument, you are passing by value, not by reference.
The contents of the structure are not changed by the function called, because
only a copy of the structure is passed.
To change a structure directly within another function, you need to pass
the address of the structure, and declare a parameter that is a pointer to the
structure. The following program shows this:
/• Progran to illastrate use of structure pointers as parameters. */
Include <Btdio.h>
Înclude <stdllb.h>
•include <niBth.h> /• for sqrtO */
#define MAX.STR 80
struct weather {
double temp, wind:
};
struct chill {
struct weather weath;
double windchill
};
/» Compute the windchill factor for the given temp and wind values */
struct chill get.chill ( struct weather today)
<
double nuffll num2
,
struct chill wch:
numl - 10.45 + 6.68 • sqrt ( today. wind) - 0.447 * today. wind;

num2 - 457 - 5 • today. temp;
wch. windchill - 91.4 - (numl » num2 / 110);
wch. weath. temp today. temp;
wch. weath. wind • today. wind;
return ( wch)
main
{
struct weather todays.weather;
struct chill todays.chill;
struct chill get.chill ( struct weather)
void get.temp ( struct weather *)
void get_wlnd ( struct weather •)
get.temp ( ttodays_chill. weath)

get.wlnd ( ktodays.chlll. weath)
todays.chill get.chill ( todays.chill. weath)
printf ( "Temp -- Ifi.lli. wind -- y,6.21f, windchill -- y.6.21f\n"

todays.chill weath temp .
todays.chill weath wind . .

;; ;
472 Using QuickC
todays.chill.windchill)
/* Get temperature from user.

Illustrates passing pointers to structures.
•/
void get temp ( struct weather *w ptr)
<
prlntf ( "Temperature? ");
gets ( info)
(•w_ptr) .temp " atol ( Info);
}
/* Get wind from user.

Illustrates passing pointers to structures.
*/
void get.wind ( struct weather *w ptr)
<
printf ( "Wind Speed? ");
gets ( info)
(•w.ptr) .wind atol ( info):
}
Notice the use of the address operator when passing the structure. This
ensures that the function will work directly in the structure's storage.
The syntax for specifying a pointer to a structure is straightforward. You
simply use the indirection indicator to specify that the variable is a pointer
rather than a structure. Notice also the declarations in the function prototypes
in niain( and the parameter declarations in get_temp( ) and get_wind( ).
)
The parentheses around the pointer names in functions get_teinp( ) and

get wind( ) are necessary, because the structure member operator (.) has
higher precedence than the indirection operator (*). You will rarely see this
notation used, however, because C provides another operator that accom-

plishes the same thing, but is simpler to write: the arrow operator.
A Structure Member Operator for Pointers If your programs require the

use of structures, you may very well find yourself working with pointers to
structures, would quickly become tedious to use parentheses around the
it
indirection operator whenever you wanted to access a structure member, so as

always, C provides an easier way of doing things — another structure member
operator ( — >), for accessing structure members indirectly via pointers. This
operator is sometimes known as the arrow operator, to distinguish it from the
dot operator used for accessing structure members directly. Use the arrow
operator when you need to access a member in a function to which a pointer to
structure is pointing.
: ;
The arrow operator, — >, takes two operands, and returns the value of the
structure member accessed or this member as an lvalue, depending on the
context in which the operator is used. The right operand is a member of the
appropriate type of structure. This operand is thus the same as for the dot
operator. The left operand is the structure pointer that references the structure
whose member you want to access. The following version of get_temp( ) uses
the arrow operator. This version is equivalent to the function used in the
preceding program. The only difference is in the operators used in the last
lines.
/* Get temperature Irom user.

Illustratee passing pointers to structures.
*/
void get temp ( struct weather *w_ptr)
{
prlntl ( "Temperature? ");
gets ( Into)
w ptr->temp atol ( info)
>
The left operand here is a pointer, namely, the node referencing the structure
whose member you want to access. For the dot operator, the left operand is a
target structure, rather than a pointer.
Most C programs use the arrow operator when pointers to structures are
involved. The precedence of the arrow operator is the same as that of the dot
operator, the highest precedence of any operator in C.
Structure Arrays and Structure

Pointer Arrays
There an important difference between an array of structures and an array

is
of pointers to structures. This difference is easy to see if you need to sort a

collection of structures based on one of the members. Let's look at two
versions of a program that illustrate this difference.
The following program sorts an array of structures based on the gpa
member of the structure:
/• Program to "sort" an array ol structures —

based on value ol gpa members.
Program exchanges only the gpa members, not the entire structures —
because an array ol structures has been used.
*/
; : ; ; ; : ; ; ;; ;
474 Using QuickC
#lnclude <stdio.h>
#lnclude <stdllb.h>
#dellne MAX.EDUC 15
#dBline MAX.ELEM B
define MAX.STR 80
struct ed <
double gpa;
> struct.arrayl [ MAX.ELEM]
/* get values for members of an ed structure */

void get. struct ( struct ed *stuff)
{
char Info [ MAX.STR]
printf ( "Major? ");

gets ( Btuff->ma]or)
printf ( "GPA? ");

gets ( info)
stuff ->gpa - atof ( info);
fflainO
void get. struct ( struct ed *);

void bbl.sort ( struct ed [] int) ,
void show. struct ( struct ed)

int index
/• initialize structure array /

for ( index = 0; index < MAX.ELEM: index++)
get.struct ( Itstruct.arrayl [ index] )
/* display values of structures in array */

for ( index • 0; index < MAX ELEM; index++)
{
printf ( "Xd: ", index);
show struct ( struct arrayl [ index]);
>
/* sort structures */
bbl.sort ( struct.arrayl . MAX.ELEM)
/• display values of structures in sorted array */

printf ( "\n\nAfter sorting array of structures\n")
for ( index - 0; index < MAX.ELEM; index++)
<
printf ( "Xd: " index); .
show. struct ( struct.arrayl [ index] )
/• void bbl.sort ( struct ed stru [] int size) ,
Sort an array of structures by letting the "largest" remaining structure

work its way to the top of the array on each pass.
•/
void bbl.sort ( struct ed stru [] . int size)

<
double temp; /* for exchanging pointers */
int low. hi. top; /* for looping through array */
top size; /• highest element that will need to be compared */

while ( top > 0)
for ( low - 0, hi - 1: hi < top; low++, hi++)

{
/• if stru [ low].gpa > stni [ hi].gpa. exchange */
if ( stru [ low] .gpa > stru [ hi].gpa)
{
/• NOTE: only the gpa members are being
swapped.
•/
temp " stni [ low]. gpa;
stru [ low] .gpa - stru [ hi]. gpa;
stru [ hi]. gpa temp;
}
/» END for hi < top »/
}
top--; /* another string has been placed. */
} /* END while top > •/
} /* END bbl.sort () */
/• display contents of an ed structure */

void show.struct ( struct ed stru)
printf ( "Xs major, gpa -- y,6.21f\n". stru. major, stru. gpa);

)
In a sample session, this program produces the following:
Major? astron
GPA? 3.5
Major? bio
GPA? 2.7
Major? chem
GPA? 3.7
Major? math
GPA? 3.65
Major? psych
GPA? 3.4
0: astron major, gpa -- 3.50
1: bio major, gpa 2.70 "
2: chem major, gpa -- 3.70
3: math major, gpa 3.65 •
4: psych major, gpa •• 3.40
After sorting array of structures

0: astron major, gpa -- 2.70
1: bio major, gpa 3.40 —
2: chem major, gpa 3.50 -
3: math major, gpa ** 3.65
4; psych major, gpa 3.70 —
This program is supposed to sort structures based on the values of the gpa
member in each of the structures. Unfortunately, the result is not what you
want; the sorting function has simply exchanged the gpa members in the
structures it compared.
To sort properly, it is easier to use an array of pointers to structures. The
: ; ; ; : : . ; ; : :
476 Using QuickC
sorting routine would then exchange pointers and actually change the order in
which the structures are referenced. The following program accomplishes this,
and illustrates the use of structure pointer arrays:
/* Program to sort an array of structures —

based on the value of the gpa members
Program uses structure pointers, so the structures themselves
are reordered.
*/
«define MAX EOUC 16

*deflne MAX ELEM 6
«deflne MAX.STR 80
struct ed <
double gpa:
} Btruct_array [ MAX.ELEM] /* array ot structures */
,
*ptr_array [ HAX.ELEM] /* array of pointers to structures •/

;
void get.struct ( struct ed "stuff)

{
char info [ MAX.STR];
printf ( "Major? ")

gets ( stuff->major);
printf ( "GPA? ");
gets ( info)
stuff ->gpa atof ( info):
mainO
void get.struct ( struct ed •)
void bbl.sort.ptr ( struct ed *[] . int)
void show. struct ( struct ed)
int index
/• initialize structure array */

for ( index - 0: index < MAX.ELEM; index++)
get.struct ( tstruct. array [ index]):
/* make pointers reference the structure array elements */

lor ( index - 0: index < MAX.ELEM: index++)
ptr.array [ index] tstruct.array [ index]
/• display the structures referenced by the pointers */

for ( index - 0: index < MAX.ELEM: index* +)
<
printf ( "Xd: ". index):
show struct ( *ptr array [ index]):
}
/* sort the 8truct<ires referenced by the pointers */

bbl.sort.ptr ( ptr.array MAX.ELEM) ,
/* display the sorted structures. */

printf ( "\n\nAfter sorting array of pointer to structuresSn")
for ( index - 0; index < MAX.ELEM: index++)
; ; .
prlntf ( "Xd: ". index);

show.struct ( 'ptr.array [ index]);
/* void bbl_sort_ptr ( struct ed *stru [] int size) ,
Sort an array oi structure pointers by letting the "largest" remaining

structure work its way to the top of the array on each pass
*/
void bbl sort ptr ( struct ed *Btru [] . int size)

{
struct ed *teiiip; /• lor exchanging pointers */
int low, hi, top; /» for looping through array */
top size; /* highest element that will need to be compared */

while ( top > 0)
<
for ( low 0, hi " 1; hi < top; low++, hi++)
{
/• if *Btru [ low] gpa > *stru [ hi].gpa, exchange */
if ( Btru [ low] ->gpa > stru [ hi] ->gpa)
{
temp " stru [ low]
stru [ low] - stru [ hi]
Btru [ hi] " temp;
}
}/• END for hi < top •/
top--; /* another string has been placed. */
} /• END while top > */
} /* END bbl. sort _ptr () */
/• display contents of an ed structure •/

void show.struct ( struct ed Btru)
{
printf ( "Xb major, gpa - y,6.21f\n", Btru. major, stru. gpa);
}
This program produces the following, for a session with the same responses as
in the previous example:
Major? astron
GPA? 3.6
Major? bio
GPA? 2.7
Major? chem
GPA? 3.7
Major? math
GPA? 3.86
Major? psych
GPA? 3.4
0: astron major, gpa 3.60 •
1: bio major, gpa 2.70
2: chem major, gpa 3.70 •
3: math major, gpa 3.66 •
4; psych major, gpa •• 3.40
;
478 Using QuickC
After sorting array of pointer to structures

bio major, gpa 2.70
psych major, gpa « 3.40
astron major, gpa 3.60
math major, gpa •• 3.66
chem major, gpa - 3.70
This program sorts the structures properly. The entire structure is moved by
making a different pointer reference the structure.
Notice that the arrow operator is only used for the comparison in the test
condition, in function bbl_sort ptr( ). After the comparison has been made,
addresses, not structure members, are transferred. On the other hand, when
showing the array, you need to use the indirection operator to get the actual
structure, because the array element is a pointer. Inside the show_struct( )
function, the arrow operator is not needed, because the entire structure, rather
than a pointer to the structure, has been passed.
In this program, the information was first read into a static array of
structures. Then the locations of these structures were assigned to the structure
pointers in ptr_array[] in order to allocate storage for the structures. In the
next section, you'll learn how to allocate storage dynamically for structures.
When using multiple structures in a program, think carefully about what
you want to do with these structures. The answer to this question may
determine whether it makes more sense to work with an array of structures or
with an array of pointers to structures.
Self-Referential Structures
Often, a program will use multiple elements of the same type, where the
number of elements needed is determined at run time. A dynamic storage
allocation strategy is advisable here. Structures are essential in such situations.
Look at the following template:
/* A structure that points to another structure like itself. •/

struct Inode {
double data:
struct Inode *next
};
: ;
This structure has two members. The data member contains the actual
information to be stored in the node. The next member is a pointer to another
Inode. Such nodes can be used to make arbitrarily long chains of structures,
linked together by the next members of each Inode.
Such chains of structures are called linked lists. The first Inode in a linked
list is often referenced by a pointer to Inode — that is, an ordinary pointer, not
a structure member member
This pointer will reference an Inode, whose next
may, in turn, reference another Inode. The list may contain as many Inode
elements as your implementation can handle. The next member of the last
Inode in the list should be a null pointer.
The following program includes functions for adding an Inode to a linked
list. You can add the element to the front or back of the list, or at the position
corresponding to the relative position of the new structure's data member in

the existing list.
/* Progran to build and display linked listB */
*include <atdio.h>
«include <Btdllb.h>
#include <nalloc .h>
«define MAX STR 80

«define FALSE
#define THUE 1
#define TOLERANCE le-7
/• Node for a linked list.

Two members: data, and a pointer to another node like this one.
•/
struct Inode {
doable data;
struct Inode *next; /* pointer to another Inode */
};
/* allocate space for and initialize a structure; return pointer to it */

struct Inode 'get.node ( struct Inode 'item)
<
void 'malloc ( size.t)
/• allocate enough space to store an Inode */

item (struct Inode *) malloc ( sizeof ( struct Inode)):
/* if allocated, initialize the structure */

if (item I- NULL)
{
item->next - NULL;
item->data - 0.0;
}
else
printf ( "Nothing allocated\n")
; ; ;
;;; ; ; ; ; ; ;
480 Using QuickC
return ( item) /• return the pointer •/
/• add the structure pointed at by new to the front of the list pointed
at by list.
•/
struct Inode • front.of.list ( struct Inode *new, struct Inode *list)
{
new->next • list;
list new;
return (list)
}
/* add Inode to which new points to end of list to which list points. •/
struct inode tback.of.llst ( struct Inode *new, struct Inode (list)
{
If ( list " NULL)
{
list • new;
return ( list)
}
else
<
/* return results of most recent search. */
li8t->next " back_of_list ( new, li8t->next)
return ( list)
/* add Inode to list at position corresponding to data member's

relative position
*/
struct Inode »mlddle_of_llst ( struct Inode *new, struct Inode *list)
{
if ( list ~ BULL)
{
list • new;
return ( list);
>
else if ( llst->data > new->data)
{
new->next " list;
list new;
return ( list)
}
else
<
/• return results of most recent search. •/
list->next mlddle.of.list ( new, list->next)
return ( list)
/* display contents of the list •/

void show.llst ( struct Inode *llst)
{
if ( list I- MULL)
{
prlntf ( »X6.21f\n", list->data)
if ( list->next I- NULL)
show.list ( llst->next)
main ()
{
struct Inode *front_of.list ( struct Inode , struct Inode *)
struct Inode 'back.of _list ( struct Inode ». struct Inode *);
struct Inode «middle_of .list ( struct Inode *, struct Inode *)
; ;; ; ; ; ;
: ; ;
Btruet Inoda *get_node ( struct Inode *)

void show.llBt ( struct Inode •);
Btz-uct Inode "teap, *root ITOLL;

Int selection;
Int done • FALSE;
int non.zaro ( double) ;
printf ( "Add to 1) front; 2) middle; or 3) back of list? ");

gets (info);
selection • atoi ( info)
temp get.node ( temp) ;
while ( (temp I- NULL) kt ( !done))

<
printf ( "Data? ");
gets ( info)
temp->data " atof (info)
if ( non.zero ( temp->data))
<
switch ( selection)
{
case 1
root = front_of_list ( temp, root);
break;
case 2:
root = middle_of_list ( temp, root);
break;
default:
root = back_of_list ( temp, root);
break;
} /* END switch */
} /* END if data is nonzero */
else
done - TRUE;
temp get node (temp)

}
if ( root I- NULL)
show_list ( root)
/* return true if val differs from zero by more than a predefined amount. */
if ( (( val - 0.0) > TOLERANCE) II ((val - 0.0) < -TOLERANCE))

return ( TRUE)
else
return ( FALSE)
}
This program produced the following three sessions, when instructed to add to
the front, middle, and back of the list, respectively:
Add to 1) front; 2) middle; or 3) back of list? 1

Data? 3
Data? 7
Data? 3
Data? 8
Data?
8.00
3.00
7.00
2.00
482 Using QuickC
Add to 1} front; 2} middle; or 3) back of list? 2

Data? 2
Data? 7
Data? 3
Data? 8
Data?
2.00
3.00
7.00
8.00
Add to 1) front; 2) middle; or 3) back of list? 3

Data? 3
Data? 7
Data? 3
Data? 8
Data?
2.00
7.00
3.00
8.00
The program lets you build lists using three different insertion methods.
The following illustration shows the sequence of steps for adding to the front
of the list. The names in parentheses are the names that correspond to root and
temp, respectively, in the front— of _list( ) function.
The basic strategy in front— of _list( ) is to make the next member of the
new structure point to the beginning of the list — that is, to the same place as
Once this is accomplished, the contents of list are modified to point to the
list.
same Inode as new. Thus, the list is built as follows: 2, then 7, 2, then 3, 7, 2,
then 8, 3, 7, 2. The process is illustrated here:
Add nodes to front of list
/* get data for first Inode */
root — HULL
temp - H 2| -I
— NULL
/* pass root and temp to front of listO */

(list) —
ITOLL
(new)- f2r^ NULL
/* new->next " list;

make the new node's next member point to the same place as list
•/
tWNULL
(llstrvNULL
(new)-
/ llBt new;
new and list both point to the same Inode
•/
(llstV^^Q* N^t-
(new)
/• back to malnO */
root H 2[ -K NULL
temp
/• get next Inode */
root -— I 21 -t— mJLL
temp -H 7| + - NULL
/* pass root and temp to front.ol.listO •/
(listJ-TanV- NULL
(new) -fyP^- NULL
/* new->next list;
make new node's next member point to the same Inode as list
•/
(list Hm— NULL
(new MTH
/• list new;
make list point to same Inode as new
*/
(list)> nT^ I 2| -t - NULL
(new)^
/• back to main */
root—i-{2Q— I 2| -K NULL
temp /
/• get next structure »/
root—^tQ— I 2| —
-t NULL
temp —H 31 +- NULL
484 Using QuickC
/* etc. */
(new) -H 31 +> NULL
/* new->next « list
(list)HTnf> on- NULL

(new) ->r3ln
/* list - new */
(iist)*ciE3^
(new)
"^
m - nn- null
root -H 3| -K 013* CO* null

temp
root
temp —-
-H3| +*
I 81 -f —
["Til
NULL
- m - HULL
(ii8t)H"3ri->
(new) -fsln
m ->
nph null
/* new->next - list */
(list)*[2]3*
(new)— rsTl
m - CO- NULL
/* list - new */
(listKJCB-
/*
[13* QQ- ran- NULL
(new)
root H1E3^ [33* [ICB^ CO* null

temp
The next illustration provides a similar map of the assignments when

adding new structures in their "size places" in the list. The basic strategy in
middle_of_list( ) is as follows:
Add in middle of list
/* get first structure */
root — NULL
temp -H 2| -( - NULL
/• pass root and temp to middle_of _liBt() */
(list)— NULL
(new) H 2l + - NULL
/ list " new;

make list point to same node as new, since list is empty
(list)-Q]3-- NULL
(new)
/• back to main •/
root -HUO-' NULL

temp
/• get new structure and information */
root -H 21 + NULL
temp -H 71 -K NULL
/* pass root and temp to middle_ol_list() */
(liBt)-^5C3- NULL
(new) -^TQ*- NtJLL
/* llst->next • middle. of. list ( new, list->next);

since 7 > 2, can't add new structure yet:
call Biddle.of.listO with the list starting at list->next ---
that is, with the (empty) list right after the Inode containing 2.
•/
;
486 Using QuickC
(list)— NULL
(new)— [7Q- NULL
/• list new;
make list point to sane node as new, since list is empty
(list)- 4Tr^ NULL
(new)''^
/* returning to the calling function, and to the longer list */
(listKlHQ- I 7| -t - NULL
(new) /
/* back to main */
root -H 2| -I— I
7| -K NULL
temp
/
/* get new structure and information */
root—r2r^ I 7l -K NULL
temp —H 31 +- NULL
/* pass root and temp to middle.of .list */
(listj-TzTl - I 7| -K NULL
(new) -H 31 +- NULL
/* llst->ne3ct = middle.of .list ( new, list->next)

since 3 > 2. can't add new structure yet;
call middle.of.listO with the list starting at list->next —
that is. with the (one element) list right after the Inode containing 2.
•/
(li8t)- ^Tn- NULL
(new)— on -' NULL
/* new->ne3ct list:
make new structure's next member point to same Inode as list.
*/
(list)- fTn- NULL
(new)—13^
;;
/* list - new;
Insert the new structure before the start of the shortened list,
since 3 < 7
•/
(llst H3 1 4- I 7| -f- NULL
(new)'^
I* returning to the calling function, and to the longer list */
{ii8t)«OD-" CzD* ""^^
(new)' y IIII3-"
I* back to main */
root -> 2|
) +— riTT— FtPI— null
teap
/* get new structure and information */
root —H 2| +~ I 3: -I
— I 7| -1 — HULL
tenp — I 81 —
-I - NULL
/• pass root and temp to middle_of_list() */
(iist H~2n-> XK3r r^PH - null
(new) - I 81 +- NULL
/• list->next - middle.of.list ( new. Ii8t->next)

since 8 > 2, can't add new structure yet;
call Biddle_of_list() with the list starting at liBt->next —
that is, with the (two element) list right after the Inode containing 2.
(listj-TiP^ — VlV\- NULL
(new) — I 81 -t
— NULL
/* list->next middle.of.list ( new, list->next);

call middle.of.listO with the list starting at list->next —
that is, with the (one element) list right after the Inode containing 3
•/
(list)> rTn— NULL
(new) H 81 4- NULL
/• list->next - middle.of.list ( new, list->next)

^
;;
488 Using QuickC
call middle.ol.llBtO with the list starting at list->next —

that is, with the (empty) list right after the Inode containing 7.
(list)— NULL
(new)-— ran— NULL
/* list - new;
make list point to same node as new, since list is empty
*/
(ll8t) ^^n— NULL
/* return ( list)
returning to the calling function, and to the longer list
*/
(liBt>-Q]3— fen— NULL
/* return ( list)
•/
(list)—TaPl — I 7| -I
— I 8| -K NULL
(new) ^
/* return ( list)
»/
(list H 2 I ^1 3l 4 — 1 7 I +— I 8 -I NULL
(new) ^
/* back to mainO */
root — ^ 2| —
-|
- 1 3|-| H 7 |-[ — FbTI
-
NULL
temp '
If the end of the list has been reached, makelist point to the same Inode as
new, and return this value. Otherwise, the function will need to do some more
processing. If the function is not at the end of the list, then list— >data exists
(since list is pointing to an Inode). If the data member of list is greater than the
data member of new, the new structure should be inserted just before the Inode
to which list is pointing. Once accomplished, the value of list is changed to
point to the Inode referenced by new. The new address stored in list is returned
to the calling function.
;
If list is pointing to something, but the data member of this Inode is less
than the new— >data, then the function must keep searching for the proper
place to insert the Inode to which new points. The function accompUshes this
by calling itself with a shortened version of the list — namely, one starting with
the Inode referenced by list— >next. The idea is that, if list — >data is still too
small, the data member of the next Inode in the list may be larger.
When the recursive call returns with the modified list referenced by
list— >next, the new structure has been inserted at the appropriate point. The
current version of the function can then return its value, list, to the calling
function. Once that's done, the various versions of the function will return the
appropriate values to their calling functions.
There are several important points to notice about the program under
discussion. First, each inode is allocated as it's needed. The get_node()
function is responsible for getting this storage, initializing the structure, if
possible, and returning a pointer to the storage allocated. By calling the

function get_node( ) only when you need another Inode, you can minimize the
storage required to run your program.
A second point concerns the returns from the list-building functions.
Notice that the same variable is used twice in expressions involving a list-
building function — once as the lvalue to which a returned pointer is assigned,

and once as argument to the function. Let's see why this is necessary. The
following program shows why this returned value is needed in this particular
situation.
/• Program to add to the front of a linked list, and to display

Information about the locations where things are occurring.
Program helps illustrate importance of return values for certain
functions.
>/
#lnclude <stdlo.h>
•include <stdlib.h>
•include <malloc.h>
•define MAX.STR 80
•define FALSE
•define TRUE 1
•define TOLERANCE le-7
/» Node for a linked list.

Two nembers: data, and a pointer to another node like this one.
•/
struct Inode {
double data
struct Inode 'next; /* pointer to another Inode */
>;
/• allocate space for and initialize a structure; return pointer to it /

tract Inode 'get.node ( struct Inode 'item)
<
^
; ; ; ; ;; ; ; ; : ; ;
490 Using QuickC
void *malloc ( Bize.t)
/* allocate enough space to store an Inode */

item - (struct Inode *) malloc ( sizeof ( struct Inode));
/* if allocated, initialize the structure */

it (item I- NULL)
<
item->next • NULL;
item->data 'CO;
}
else
printf ( "Nothing allocated\n")
return ( item) /* return the pointer */
}
/* add the structure pointed at by new to the front of the list pointed
at by list.
•/
struct Inode * front_of list ( struct Inode *new. struct Inode *list)
{
printf ( "FRONT: ftlist == y,u; list == y,u; ", tlist, list);
printf ( "tnew == */,u: new == 5tu\n", Imew, new);
new->next = list;
list = new;
printf ( "front: ftlist == y,u; list *- y,u; ", frlist. list);
printf ( "toiew == %u; new == y,u\n", ftnew, new);
return (list)
}
/* display contents of the list /

void show.list ( struct Inode »list)
<
if ( list !- NULL)
{
printf ( "X6.21f\n". list->data)
if ( list->next l« NULL)
show.llst ( list->next);
>
main ()
struct Inode *front.of .list ( struct Inode *, struct Inode •)

struct Inode *get.node ( struct Inode *);
void show.llst ( struct Inode *)
struct Inode »temp, •root - NULL;

int selection;
int done - FALSE;
temp " get_node ( temp)

while ( (temp !- NULL) tck ( I done))
printf ( "\n\nData? ");

gets ( info)
temp->data atof (info);
if ( non.zero ( temp->data))
printf ( "MAIN: kroot -- Xu; root -- Xu; ".

ftroot root)
printf (
,
"ttemp -- Xu; temp •

Xu\n" ttemp, temp); ,
; ; ; ;
root front.of.list ( temp, root);

prlntl ( "main: fcroot Xu; root •
Xu; ",
feroot, root):
prlntf ( "ttemp Xu; temp "" XiiXn" &temp, temp); ,
>
else
done TRUE;
get_node (temp)
it ( root I- NULL)
8how_ll8t ( root)
/* return true il val dillers from zero by more than a predefined amount. •/
if ( C( val - 0.0) > TOLERANCE) II ((val - 0.0) < -TOLERANCE))

return ( TRUE)
else
return ( FALSE)
}
When run with the same data as in our previous example, this program
produces the following.
Data? 2
MAIN: troot - 4972; root -• 0; ktemp 4074; temp "
5182 —
FRONT: kllst - 4882; list -- 0; tnew -- 4880; new •- 6182
front: tllst - 4882; list "
5182; tnew 4880; new 6182 " "
main: troot 4972; root -- 6182; ktemp -- 4974; temp -- 5182
Data? 7
MAIN: kroot - 4972; root -- 6182; frtemp -- 4974; temp •5194
FRONT: felist - 4882; list 5182; tnew — •• 4880; new -- 5194
front: tlist • 4882; list 5194; tnew — -- 4880; new "5194
main: ftroot 4972; root -- 5104; ttemp -- 4974; temp -- 5194
Data? 3
MAIN; kroot - 4972; root -- 6104; ktemp 4074; temp -- 5206 -
FRONT: tlist - 4882; list -- 6104; toiew -- 4880; new -- 5206
front: tlist - 4882; list -• 5206; tnew -- 4880; new 6206 -
main: troot 4072; root -- 6206; ttemp -- 4974; temp 5206 -
MAIN: troot -• 4072; root •• 6206; ttemp -- 4974; temp -- 5218

FRONT: tlist ~
4882; list "
5206; tnew -- 4880; new -- 5218
front: tlist —
4882; list -- 5218; tnew -- 4880; new -- 5218
-
main: troot "- 4072; root -• 5218; ttemp 4074; temp -" 6218
Data?
8.00
3.00
7.00
2.00
Let's see how this program does its work. The goal of each call to
492 Using QuickC
front _ of _list( add a new Inode to the front of the list. This means that
) is to
root will point at a new Inode after each call to front _ of _list(). More
specifically, this means that the contents of storage location 4972 (the location
at which root's value is stored) should be different after each call to
front_of_list( ).
Let's look at the output within front. of _list( ) to see whether this can
happen. First, notice the address and contents of list, the parameter corres-
ponding to root in the function. This variable has the same contents as root,
but this address is stored at a different location, because all that has been
passed to the function is a copy of the address stored in root — that is, stored at
location 4972. The address of root itself (4972) has not been passed.
Because the value passed is an address, you can make changes in the
variable located at that address. For example, after making list point to the
same place as new, you could make changes in *list, the variable at which list is
pointing. Because *list is an alias for *root, these changes would remain after
you left the function.
However, you cannot change the contents of root itself, even though you
can change the address stored in list. This is because root and list are not
aliases.By returning the desired address from the function, and assigning this
address directly to root in the calling function, you make root point to a new
Inode after the function call. (You could also have accomplished this by passing
a pointer to a pointer to structure, struct Inode **, but that's another topic
altogether.)
Bit-Fields
Sometimes it's convenient to have different bits in an int represent different
settings or options. You saw examples ofthis in Chapter 15, when you assigned
regions to territories in some programs, and learned to define manifest con-
stants to represent mutually exclusive regions. These constants were all pow-
ers of two, so that exactly one bit was one in any constant.
C also lets you declare and manipulate a variable number of bits as a

member in a structure. Such a member is called a bit-field. A bit-field is a
collection of adjacent bits, usually in an int. Bit-fields give you easy access to
storage areas smaller than a byte, and let you refer to these areas by name.
. ; :
Bit-fields are particularly useful in programs that need to keep track of settings
or options that are in effect — such as driver programs (for controlling things
like printers or screens) and operating systems.
Suppose you have a program that needs to keep track of the settings on a
printer. In particular, let's assume the program needs to maintain information
about the following:
1 Current font ( 16 possibilities)
2. Boldface (on / ofO
3. Italic (on / off)
4. Font size (3 values)
5. Single spacing (on / off)
6. Emulation mode (10 possibilities)
7. Print quality (4 modes)
8. Paper dimensions (6 possibilities)
You could define each of these as a separate variable. In that case, each would
take up at least one byte, and more likely two bytes because it would be more
convenient to represent most of them as integers rather than characters. That
means you might use as many as 16 bytes to store this information.
Bit-fields let you represent all of these variables in two bytes. The follow-
ing program shows you how.
/• Program to illustrate declaration and use of bit fields */
/* This structure consists of two bytes.

The number following each unsigned declaration represents the number of
bits to be allocated for that structure member.
*/
struct printer {
unsigned font 4; :
unsigned bold 1 :
unsigned italic 1 :
unsigned size 2: :
unsigned single.space : 1;
unsigned emulation 4; :
unsigned quality 3; :
unsigned paper 3; :
>;
^
;; , ;;
494 Using QuickC
main ()
struct printer laser;
/* assign values to Individual members. •/

laser. font 8;
laser. bold 0;
laser. Italic - 1;
laser. size > 2;
laser .slngle.space - 0;
laser emulation • 0;
.
laser. quality 0;
laser. paper • 0;
/* Display values of the bit-fields */

prlntf ( "font "
Xu; bold =
Xu; italic •= Xu; size "= XuNn"
laser. font, laser. bold, laser. italic, laser. size):
prlntf ("spacing •= Xu; emulation •« Xu; ",
laser single.space laser emulation)
. , .
prlntf ( "quality == Xu; paper •» Xu\n",

laser quality laser paper)
.
,
.
/* assign iin out of range value to a member */

laser. font 17;
/* Display the result. Did It affect the next member? */

prlntf ( "\n\nAfter giving font too high a value (17)\n");
prlntf ( "font "
Xu; bold •- Xu; italic -- Xu; size »" Xu\n"
laser. font, laser. bold, laser. italic laser. size);
prlntf "spacing
( -
Xu; emulation Xu; ", "
,
laser. single.space, laser. emulation)

prlntf ( "quality Xu; paper Xu\n"
laser quality laser paper)
.
,
.
font "8; bold —

0; Italic -- 1; size ~ 2
spacing 0; emulation 0; quality 0; paper •
After giving font too high a value (17)
font •1; bold -• 0; italic 1; size - -
spacing 0; emulation -
0; quality 0;
2
paper
The preceding program declares a structure whose members are all

bit-fields. Each member declaration includes the base type of the member
(unsigned, in this case), an identifier for the member, and the number of bits to
be allocated for the member.
^REMEMBER Bit-fields can only be declared within a structure. When

declaring a bit-field in a structure, you must provide a base type for the
member, an identifier, and the number of bits to be allocated for the field.
When you declare bit-fields, the compiler stores the members in adjacent
bits, subject to some constraints. That is, the compiler does not start each
; :
member on a new byte or word boundary. For example, in the preceding

program, four bits were allocated for fonts. The next was allocated for bold,
bit
and the next bit for italic. Then two bits were allocated for size. At this point,
only one byte of storage had been used.
The next byte was and the four after that for
allocated for single_space.
emulation. Notice that four bits were allocated for this member, since ten
values cannot be stored in three bits. This means that several possible values in
this bit-field will be unused. The two bits following were allocated for quality.
So far, 15 bits of storage have been allocated.

The next field requires three bits. If the compiler continues allocating
storage consecutively, this variable would straddle two words of memory. Not
all compilers will do QuickC and Microsoft C 5.0, for example, will store
this.
paper completely in the next word. Check your compiler to see how bit-fields
are handled when they cross word boundaries.
You can also use padding to control how the compiler handles fields that
cross word boundaries. You can pad the storage allocation in a structure by
declaring a nameless bit-field. If you specify just a type and the number of bits,
the compiler will skip the specified number of bits. The special width, 0, tells
the compiler to pad to the nextboundary appropriate to the variable type. For
example, the following version of the printer declaration would assure that
paper did not straddle a word boundary, regardless of how the compiler would
handle this situation by default:
I* This structure consists of two bytes.

The number following each unsigned declaration represents the number of
The nameless member —

bits to be allocated for that structure member.
before paper pads the structure to a
word boundary, before allocating storage tor paper.
—
*/
struct printer {
unsigned font 4;:
unsigned bold 1 :
unsigned italic 1; :
unsigned size 2;:
unsigned single.space : 1
unsigned emulation 4; :
unsigned quality 2; :
unsigned : 0; /• pads to end of word */

unsigned paper : 3:
The Draft Proposed ANSI Standard says that bit-fields can be declared
as having int, unsigned int, or signed int types. If you declare a bit-field as
being signed, the action taken if you assign an out-of-range value is implemen-
tation dependent. In QuickC and Microsoft C 5.0, the value is treated as if it
496 Using QuickC
were unsigned, for purposes of computing the overflow. In the preceding

program, the effect of assigning too large a value to font was confined to that
bit-field. The overflow did not affect the bold member.
In addition to the base types allowed in the Draft Proposed ANSI
Standard, QuickC and Microsoft C 5.0 also allow you to declare bit-fields of
type char and long — either signed or unsigned. If you declare a bit-field as a
long, and then pad the structure, the padding will extend to the next long
address boundary. Thus, in QuickC the following structure would take 14
bytes, 12 for the three long variables, and 2 for the int.
struct size. test {

long one
long
long two
0; :
6;
B;
:
/* pad to first long boundary

:
4 bytes */ —
long 0; : /• pad to second long boundary */
long three 3; :
Int not_a_field;
};
The two nameless members each pad the structure to the next long
address boundary. The first one pads 26 bits (32 bits allocated for long, less the
6 bits for one). The second one pads 27 bits. The compiler pads to the end of
the third long, ensuring that structure members that are not bit-fields will be
aligned at the proper address boundaries. You can have both bit-field and
other members in the same structure.
Restrictions on Bit-Fields
While bit-fields can be convenient for certain types of tasks, there are several
restrictionsand implementation dependencies associated with them. Because
of these restrictions, you should be very careful about making assumptions
concerning the particular locations at which you will find specific fields.
Some implementations allocate storage to bit-fields from left to right
(high-order to low-order bit), while others allocate them in the reverse direc-
tion. This can be a crucial difference if you're reading data generated by a
program.
Bit-field locations are not accessible, so you can't apply the address
operator, &, to a bit-field. This means that you can't have arrays of bit-fields
(since arrays are actually pointers) or pointers to bit-fields. Nor can functions
return bit-fields.
: ;
Unions
Unions are aggregate types that have members, Hke structures. Unhke struc-
tures, however, unions may hold different types of information at different
times. That is, the same variable may be used to store different members at
different times. For example, the union variable, number, defined below may
contain an int at some and a complex number
times, a double at other times,
on other occasions. At any one time, however, only one of these types is stored
in the union variable.
struct complex {
double re, Im:
};
union value {
int int.val;
double dbl.Tal;
struct complex comp.val;
> number
This data structure can store the value for either an int, or a double, or a
struct complex variable at any one time. The union cannot have more than one
member present at any given time. Rather, the union has a certain amount of
space allocated, and this space can contain information that may be inter-
preted in any of three ways, depending on context.

The following program makes clear that the members of a union occupy
the same storage:
/• Program to display amount and location of storage allocated to

a union.
•/
«include <8tdio.h>
*include <8tdlib.h>
/* create a template for a complex number •/

struct complex {
double re, im;
>.;
/* create a template whose storage can be interpreted in any of three

ways at a given time —
depending on context.
•/
union value {
int int.val
double dbl.val;
- - ;;
498 Using QuickC
struct complex conip_val;
main ()
<
union value number;
printf "Size of entire union

( """" == Xd\Ti"
*a\n ,
=<,,.„*
sizeof /
( union value));
printf "Size of int member == IdKn" =<,.»* i
(
Drintf
pranti
*i"o* ( number. int -"aa-yy.
val))-
( blze »*
"<!<,• of J
•
..,
(,
double "ember =- Vj\«h
memhpT' 33 Xd\n". sizeof- (* number.
Drintf
print! f
c Size of complex union member =-
"<!,-,o „<. , dbl val))
-^^'n, •
y.d\n".
sizeof ( number. comp val))-
printf ( "Size of complex
re"-- y,d\n».
sizeof ( number. comp_ val re))-
printf ( "Size of complex
im -• y.d\n"."
sizeof ( number. comp. val. im)),'
printf ( "\n\n&number == y,u\n". taiumber)

:f"'^^"-i"t--'>l " I^Vn". dumber, int.val)
printf
rrl'ntf \
( "tnumber.dbl.val - y.u\n"
. taumber.dbl val)
;
;;*"'^^""'»P-^''l -- Xu\n", tnumber.co^p vai)

printf ( "tnumbercomp val re »- «ii\„"
P-â-t-re t_ v
Su\n 4number.comp.val. re)
Drintf
printf "t„„-K
-
.
I
( tnumber.comp.val.im Xu\n" ftnumber.comp.val.im)
.
^
This program produces the following

output:
Size of entire union == 16

Size of int member == 2
Size of double member == 8
Size of complex union member == 16
aize of complex re == 8
Size of complex im == 8
tnumber == 4256
tnumber.int.val == 4256
tnumber.dbl.val =- 4256
tnumber. comp. val == 4256
tammber.comp.val.re »» 4256
tnumber.comp.val.im == 4264
'' ''' '^° " '° '''^'^ ""--• -^ how to

store'^ttem^The'r," '""T^'^^ ^°
' ''^" ^^^^'arations of the same sort

dedarat.onT Th!
declarations. rf
These declarations are surrounded
as in structure
by left and right curly braces
bit fields. You can have pointers to a

union of the type being declared.
;; ;;
In this case, we have three different types declared, with one of these being
a structure. In a structure, these three different types would coexist. In a union,
however, only one can be represented The compiler allocates enough
at a time.
storage for the largest union member declared. In our example, this means 16
bytes, since the complex is the largest union member. The program displays
this value as the size of the structure. If you're storing an int, the compiler
would use only two of the bytes.
The storage allocated for the union will be interpreted differently, depend-
ing on the union member being accessed. Storage for all members will start at
the same location, as the program shows. This means that the union members
overwrite each other. You are responsible for making sure your program asks
for the kind of information that was last stored there. If you overlook this,
you'll get erroneous results.
Unions of Structures
A very common use of unions is to store either of several structures, depending
on the context. For example, the following declarations would let you record
information about either a book or a journal article:
•include <Btdio.h>
«deflne HAX.SMALL 40
struct book {
char author [ HAX.SMALL]
char title [ HAX.SMALL]
}:
struct article {
char author [ HAX.SHALL]
char title [ HAX.SMALL]
char journal [ HAX.SMALL];
};
union entry {
struct book bk;
struct article art;
};
With these declarations, you could build entries for a data base, where
some entries would be for books and some for articles. In the next chapter,
you'll learn how to use some unions declared in QuickC and Microsoft C 5.0 to
access DOS functions, such as getting the system time.

;
500 Using QuickC
Enumeration Types
C you provide names for values that
lets
certain variables can take on For
example, suppose you wanted to
create a template for a deck of cards
It would
be convenient to have meaningful
names for the mdiv.dual cards. C's enumer-
ation type gives you this
capability. The enumeration
type will officially
become part of the C language when the Draft Proposed
ANSI Standard is
adopted. This type is already available in many
implementations, so you'll
probably run across programs that
use it.
The following declaration shows how

to define a deck of cards:
#deflne MAX.CARDS 52
enua suits { clubs, diamonds,
hearts, spades};
enum lace { ace two. three, four.
five. six. seven, eight, nine
ten. Jack, queen, king}; * '
struct card {
enum suits suit;
enum face value-
} deck [ MAX.CARDS]
^" '""•" '^P'' y° " ^'' specifying names for the range of
vph-e^'"
values T, 'Tu
a variable of that type can have.
Thus, in the example, variables of enum
type suits can take on the named
values clubs, diamonds, hearts, or
spades
Similarly, variables of enum
type faces can take on any named
values in the list
between ace and kmg, inclusive.
Enumerations are really nothing more than
names for integer constants that represent
specified values. They are useful for
specifying actions in a more
memorable way, however
When you declare an enumeration type,
you specify a set of names to use
when referring to particular values such
variables could take on. Internally the
compiler numbers elements in order,
starting from 0. Thus, the values
ciubs
through spades would correspond
to the numerical values through 3- the
values ace through king would
correspond to through 12. You worry
about
the names, the compiler will
take care of the values.
You can use these enumeration values
in expressions wherever an int
value IS allowed. When the compiler sees such a value
in your program it
substitutes the value it has associated with the name into '
the expression
Although, by default, the compiler
starts numbering enum values from
you can override the default by
simply associating a new number with
an
; ;: ; ;; ; ;
identifier. The following program illustrates this:
/• Program to display a playing card.

Program also illustrates use oi enujn type and how to override the .
default values assigned to the enum type values

*/
*define HAX.CARDS 62
•define MAX.SUIT 4
•define MAX.FACE 13
enun suits { clubs, diamonds, hearts, spades};
enum faces { ace - 1, two, three, four, five, six, seven, eight, nine,
ten, jack, queen, king};
struct card {
enun suits suit
enum faces value;
} deck [ HAX.CARDS]
main ()
{
int rand ( void)
enum suits suit_val, face.val;
/• get and display face value. randO returns -- 12, so add 1 */

faee.val - rand () X MAX.FACE 1;
switch ( faee.val)
{
case ace:
printf ( "A ");
break;
case jack:
printf ( "J ");
break;
case queen:
printf { "Q ")
break;
case king:
printf ( "K ") ;
break
default
printf ( "W " . faee.val) ;
>
/» get and display suit value */

suit.val - rand () X MAX.SUIT;
switch ( suit.val)
<
case clubs:
printf ( "clubs")
break;
case diamonds:
printf ( "diamonds");
break;
case hearts:
printf ( "hearts");
break
case spades:
printf ( "spades");
break:
}
502 Using QuickC
In this program, the values

associated with faces variables range
from I
through 13, rather than from through
12. This is because the
first value was
set to I, overridmg the
compiler's default of 0.
You can specify any integer value, positive
or negative, for an enun, value
name. The compiler will associate
subsequent names in the list with successive
values, startmg with the value
you specified. The followmg declaration
shows
an example of this.
enujB example < a. b, c, d, e • -2. 1, - -4.

g, h. i j k i „,
n - 14. o. p. q. r. s. t - 6, u, v, "w. 'x. 'y. '- 6};
in this declaration, the following

values can be found:
Value Names
b. h, u
The first few names, a through d, use the

compiler's default values. Since e
specified to be ~2, the counting for
IS
subsequent names continues from this
value. This means f is -1,
g is 0, and so on. The name is specified as i
representing -4, which starts the
counting from this value.
Notice that several names can be associated
with the same value Notice
also that you can start renumbering
from any point, and that numbering will
continue from that value until you specify a new renumbering or until the
end
01 the list.
Summary
Congratulations, you've done it! You've mastered all the
fundamental topics in
the C
language. This chapter has covered
the last major topics -
the structure
and union aggregate types and the "new"
enumerated type
Many of the concepts covered in this chapter (such as self-referential

structures and linked lists) are fundamental to writing certain types of pro-
grams. You may want to explore other data structures (such as trees), which
you can build using self-referential structures.
You should now be ready to write programs to do just about anything you
want. In the next chapter you'll learn more about some of the functions
available to you in the QuickC Run-Time library. You'll also find some
additional functions for specialized tasks, such as checking the time or date on
the system.
QuickC Library
Functions
This chapter provides more tools and information for your C programming. In
it, you'll find brief discussions of some of the more commonly used Run-Time
library functions. You'll also find useful functions for doing things such as
getting the time and date, determining elapsed time, and using DOS com-
mands in your programs. Although it presents a great deal of information, this
chapter should be enjoyable and helpful — especially if you take time to play
with the programs.
The discussions you whether a given function is built into QuickC. If
tell
it is, you can use the function anywhere in your program without declaring the
function or including any header files. If a function is not built into QuickC,
you may simply need to include the header file in which the function is
declared. Or, the function may be included in the Quick library, qcstuff.qlb,
505
^
506 Using QuickC
used for some of the programs in this book.

If it is, you need to use the /I option
with qcstuff as argumem when calHng
QuickC, as shown in the following
command line:
qc /Iqcstuff myprog
The discussion of the library functions is organized around

some of the
major header files provided with QuickC and
Microsoft C 5.0. The contents of
many of these files are specified in the Draft Proposed
ANSI Standard Some
files are "extras," provided to make certain types of functions (such as those
thatwork directly with the operating system) easier
to write. The Microsoft
Run-Time library contains over 200 functions, and
QuickC includes over 30
header files you can use. We'll only be able to cover a small
that
portion of
these. Check your Run-Time library documentation
for more information
about the functions presented here, and for
additional functions not discussed
here.
stdio.h
This header file comains definitions for manifest

constants, macros, and new
types -for stream input/ output activity.
Many of the functions we've been
using rely on this header file for definitions
and other information The stdio h
file includes definitions of
NULLas or OL. to represent a null pointer,
and of
EOF, the value to be returned when the end
of a file has been reached or an
error has occurred.
You've already seen many of the functions declared in this header file The
I/O functions supported include: fclose( ), fgetc( ), fgetchar(
), fgets( ), fopen
fprintfO, fputcO, fputcharO. fputs(), fscanf().
gets(), printf(), puts() and
scanfO. All of these are built into QuickC
except fgetchar() and fputchar()
which are in the qcstuff.qlb Quick library. In
addition, you've seen the follow-
ing macros; feof, ferror, getc( getchar(
), ), putc( ), and putchar( ).
The Familiar Functions

Because the following functions are discussed
elsewhere in this book they are
described only briefly here.
QuickC Library Functions 507
int fclose (FILE *f_ptr) This function closes the specified file. Before
closing, the buffers associated with the file are flushed and written to the file. If
the file is successfully closed, fclose( ) returns 0. The function returns EOF if
there is an error.
f eof (FILE This macro determines whether the end of the file has
*f _ptr)
been reached. The macro returns a if the end-of-file has not been reached,
and a nonzero value if the end-of-file has been reached.
terror (FILE *f_ptr) This macro determines whether an error has

occurred in relation to the specified Such errors can occur if you try to
file.
read from a file that has been opened for writing. The macro returns a if «o
error has occurred, and a nonzero value if an error has occurred. The error
indicator remains set until you use clearerr() (discussed later) to reset the
indicator, close the file, or move back to the beginning of the file.
int tgetc (FILE *t_ptr)

Int tgetctiar (void) These two functions read one character at a time, and
return each character as an int. The functions return EOF if an error occurred.
The fgetcliar( ) function reads from stdin, and fgetc( ) reads from a specified
file.
char *fgets (char *str, Int size, FILE *f_ptr) This function reads a string
from the specified file, The string's maximum length is
and returns this string.
specified by size. Newlines are included in the string read, and the function
terminates the string with a null character. The function returns the string read
if successful, or a null pointer if unsuccessful.
FILE *fopen (char *name, char *mode) This function opens a file and
returns a pointer to the stream associated with this The function also
file.
associates a disk file, called name, with the stream. The mode parameter
specifies how the file is to be used. The function returns a file pointer if
successful, or a null pointer if unsuccessful.
int tprintf (FILE M—ptr, const char *str, . . .) This function works just like
printf( ) except that fprintf( ) writes to the file specified by f_ptr. The function
has the same string argument as printf( ), and can contain optional arguments
of types specified in the string argument. In addition, fprintf() takes a file
pointer as its first argument and returns the number of characters printed.
508 Using QuickC
int fputc (char ch, FILE *f_ptr)

int fputchar (char ch)
These two functions write one character at a
time
and return the character written as an int. They
return EOF if an error occurs'
Note that fputchar( ) writes to stdout, and fputc(
) writes to the file specified by
'
i_ptr. '
int fputs (char -str, FILE *f_ptr)

This function writes the character
string, str, to the specified
file. The function copies the
entire string except for
the terminating null character. The
function returns the last character written
as an int, as is common
in C. The returned character will
be a newHne
character, the string was read using fgets(
if
). Unlike puts( ), fputs(
) does not
add a newhne character before writing the string.
The fputs( ) function returns
if str IS empty, and EOF
if there is an error.
int fscanf (FILE *f_ptr, const char*str, .) This function reads from the
. .
specified the types of information indicated in

file
the string argumem This
function works like scanf(), except that
the source for fscanf() is a specified
file rather than stdin. The
function comains additional argumems
specifying
addresses for storing the input read. The
function returns the number of items
that were read and assigned, or
EOF if the end-of-file has been reached A
return value of indicates that an error has occurred,
since no items are
assigned.
int getc (FILE *f_ptr)

int getchar (void) These are the macro versions of fgetc( ) and
fsetchar( )
respectively.
char *gets (char *str) This function reads a string from stdin and
returns
this string in a modified form. The
newline character read is replaced by a null
character, which terminates the string
returned. If the function is unsuccessful
at reading a string, it returns
a null pointer.
int printf (char *str, . .

.) This function displays the specified information
on stdout. contains at least a string argument, which
It
may contain place-
holders indicating other arguments to
be written. If str contains such place-
holders, the function will contain
additional arguments consisting of the
variables or values corresponding
to the placeholders. This function returns
;
the number of characters written.
int putc (FILE *f_ptr)

int putchar (void) These are the macro versions of fputc( ) and fputchar( ),
respectively.
int puts (const char This function writes a string to stdout, replacing
*str)
the null character that terminates str with a newline character. The function
returns the last character written (usually the newline character), or EOF if
there is an error.
int scant (const ctiar *str, . . .) This function reads the types of informa-
tion indicated in the string argument. Itmust include additional arguments
corresponding to any placeholders in the string arguments. These additional
arguments must be addresses so that the information can be assigned directly
to these locations. The function returns either the number of items that were
read and assigned, or EOF if the end-of-file has been reached. A return value
of indicates that an error has occurred, since no fields have been assigned.
New Functions
The following functions have not appeared in the programs so far, but you may
want to use them in your programs.
void clearerr(FILE *f_ptr) When a file access returns an end-of-file or an

error, an indicator is set — to warn that file access is not going smoothly. You
need to clear this indicator when the error has been fixed or is no longer of
consequence and can be ignored.
The clearerr( ) function lets you reset the error indicator when you wish.
This function takes a file reference as its argument and simply changes the
file's error indicator
The following call resets the error indicator for the file referenced by
f_ptr.
/* Assume f.ptr has been defined as FILE *f_ptr. */
clearerr ( l_ptr)
; )
510 Using QuickC
int fcloseall (void) This function closes any open streams, or files,
except
those opened by the system-that is, except
stdin, stderr, stdout, and so on
The function returns the number of files closed
successfully, or EOF if there is
an error. The following listing shows how to call fcloseall( ).
nr.closed = fcloseall ();
FILE *freopen(const char *new_name, const

char mode, FILE *f_ptr)
This function closes the file referenced by
f_ptr, and reassigns this stream to a
new file. Such a capability can be very useful if you
need to write the output of
a standard stream, such as stderr, to a
disk file.
For example, you could use the following call to freopen() to send the
messages going to stderr to a disk file named
error.tex instead.
new.f.ptr = freopen ( "error.tex", "w+". stderr);
This function call effectively accomplishes two things, it opens a file and
It redirects the output of a stream to
this file. The variable new_f_ptr
references the newly opened file, which is associated with the disk file error.tex
The effect of the w+ option is to create a new file that can be read from and
written to. Note that freopen( not buih into QuickC.
) is To access the function
you need to include the stdio.h file at the top of
your program. If you intend to
compile and run your program within the
QuickC environment, you need to
add freopenO to a Quick library, as described in
Appendix B.
void perror (const char .str) This function writes a specified error mes-
sage to stderr. You pass the message to the
function, as a string argument In
addition, perror( ) prints a system error
message appropriate for the nature of
the error encountered.
For example, you want
if to delete a file using a C function, but no file
with the specified name is found, the following line at the appropriate poim
in
your program will write the message below it to stderr.
perror ( "Deletion ujisuccessful")
/* output from preceding statement */
Deletion unsuccessful: No such file or

directory
The perror( ) functionoften used after errors are detected using the
is
ferror(
or feofO macros. Call perror()
immediately after the error has occurred.
;
Otherwise, subsequent errors will overwrite the error you wanted to report.
Note that perror() is not built into QuickC.
The "Deletion unsuccessful" message (passed as argument to perror( ) ) is
stored in the appropriate header file. The "No such file or directory" message is
an internal one associated with the error type encountered when attempting to
delete the file.
intremove (const char *name) This function removes the disk file speci-
fied in the name parameter. If successful, the function returns 0; if not
successful, the function returns - 1 . The function does not give you a chance to
change your mind. So before calling this function make sure your program is
not about to remove a file you want to keep.

The following statement would delete the disk file zzzzgone.bye.
remove ( "zzzzgone.bye");
void rewind (FILE *f_ptr) Every file has a pointer associated with it. This
pointer indicates the current position in the file. Generally, the next action will
occur at this position. Thus, if the file position pointer is at the second element
in the file, the next read process would read this element into the program. The
file position pointer would then move to the third element. If your program
writes to the file at this point, it and the file
will overwrite the third element,
position pointer will move to the fourth element. (These actions assume that
your program has been opened in a mode that allows the actions, and that the
specified elements exist.)
The rewind( ) function moves the file position pointer to the beginning of
the file. The function also clears any end-of-file or error indicators. It does not
return a value. The following would move the file position pointer to the
beginning of the file referenced by f — fptr:
rewind ( l_ptr)
A Program to Exercise
the I/O Functions
The following program shows how these functions work. The program, which
basically reads and writes files, uses each of the functions you've just read
about.
; ; ;
; ; ; ; : ; ; ; ; ;
512 Using QuickC
The program first redirects the stderr stream to the file referenced by
err_ptr, which is written to disk as zzzztest.log. (In the unhkely event that you
have such a file, please change the name of your file or the file name in the
program before you compile it.)
/* Program to exercise some of the functions declared in stdio.h */
include <stdio.h>
include <stdlib.h>
define MAX.STR 80
define MAX.ENTRY 50
mainO
void 6how_error_file ( FILE *)
void get.src.file ( FILE •)
void build.new.f lie ( FILE *)
void test_new_f ile ( FILE *)
int outcome, nr.closed;

FILE *err_ptr, *f_ptr. *src
/* reassign stderr to err.ptr aka zzzztest.log */ —

err_ptr = freopenC "zzzztest.log". "w+". stderr);
/* open and read source file, if possible */

src = fopen ( "zzzztest .src" "r") ,
if ( src != NULL)
{
/* read and display contents of src */
get_src_file ( src);
fclose ( src)
/• remove disk file associated with src */

printf ( "Removing current version of source file")
remove ( "zzzztest .src")
}
else /* if source file could not be opened */
{
perror ( "Source file not opened");
printf ( "Creating a source file for next time.Nn");
/* try to create new version of the source file */

f_ptr fopen ( "zzzztest .src" "w+"): ,
if ( f ptr)
{
/* generate a new source file */
build.new.f ile ( f _ptr)
/* test newly created file, by displaying a line */

printf ( "zzzztest src created. Test line below. \n"):
.
test_new_f ile ( f _ptr)
fclose ( f _ptr)
} /* END if successfully created new file */
else
perror ( "Could not create a new ztestsrc");
} /* END if could HOT open source */
/* display contents of file to which error output was written */

show_error_f ile ( err_ptr)
/* close any files still open */

nr.closed f closealK) ;
printf ( "%d files closedXn", nr.closed);

; ; ; : ; ; ;; ;
I* display contents of error file */

void show_error.fi le ( FILE *e_ptr)
char *iiif o , line [ MAX.STR] ;
printf ( "\n\nContents of error file:\n");

rewind ( e.ptr) /* move to beginning of file */
while ( ( info = fgets ( line, MAX.STR, e.ptr)) != NULL)
printf ( "%B\n" line) .
/* display first line of newly created file. •/

void test new file ( FILE *f.ptr)
{
char *info, line [ HAX.STR]
rewind ( f _ptr) /* move to beginning of file */

;
if ( ( info - fgets ( line, MAX.STR, f .ptr) ) != NULL)

printf ( "%s\n" line) ,
else /* if unable to read from file */

<
perror ( "Couldn't read. Clearing error.");
clearerr ( f.ptr)
}
/* create a new source file •/

void build.new.flle ( FILE *f.ptr)
{
int index, value;
/* generate MAX.ENTRY random values, write them to file, 5 / line */

for ( index - 0; index < MAX.ENTRY; index++)
{
value = randC)
if ( (index 5) == 4)
*/,
fprintf ( f.ptr. ""/.lOdNn" , value);

else
fprintf ( f.ptr, "'/.lOd" , value);
\
/* read each line of source file as a string.
*/
—
get a number from the string
and display the number.
which discards 4 numbers on the line
void get.src.file ( FILE *src)
<
char *info, line [ MAX.STR];
int value
while ( ( info » fgets ( lir MAX.STR, src)) != NULL)

{
value - atoi ( line)
printf ( "y,d\n" value) . ;
/• report on why the reading process ended */

if ( feof ( src))
perror ( "End of source file reached")
else if ( f error ( src))
perror ( "Error in source file");
/* else do nothing */
514 Using QuickC
This program will run in either of two different ways, depending on the files
that exist when the program executes. If the program is run when you do not
have a file named zzzztest.src in your current directory, it will create such a file
and produce the following output:
Contents of error file:

Source file not opened: Ho such file or directory
files closed
This creates a source file for next time. The complete contents of the
zzzztest.src file that has been created are shown here.
5705
The following listing shows the output from this version of the program;
41
15724
5705
491
32391
12382
5447
19912
28703
4664
Removing current version of source file
files closed
This version displays ten numbers, then writes various items, including
the contents of the error file. Notice that the program only displays ten
numbers, even though the file contains fifty. This is because of the way atoi( )
works.
The program reads the entire line (with five values) as a string. Note that
atoi( ) processes from the beginning of the string until it has built a number. In
our example, the number buih will be the first number on the line. Once a
number has been returned, the rest of the string is discarded, and the program
reads the next line of the file. When the string is discarded, the remaining four
numbers on the line are also discarded. (To get around this, you could use the
remove_wd() function defined in Chapter 12.)
The "Error 0" in perror( ) indicates that no error was encountered.
stdlib.h
This header file contains declarations for several commonly used functions,
including the conversion functions such as atoi( ), the rand( ) function, and the
dynamic storage allocation functions, such as malloc( ). (The allocation func-
tions are also defined in the header file malice. h.) In addition, stdlib.h con-
tains the declaration for errno, a global variable whose value is set by various
functions to a number representing a specific error.
516 Using QuickC
Familiar Functions
We've used several of the functions declared in stdlib.h in example programs.

Of these, the most useful have been the conversion functions and the pseudo-
random integer generating function, rand( ).
int abs (int val) This function returns the absolute value of an int, val. If
val is negative, the function returns —val, otherwise the function simply
returns val. The abs( ) function is not built into QuickC.
double atof (const char *str)

Int atoi (const char *str)
long atol (const char *str) These functions convert the string, str, to a
number of the appropriate type, and return this number. The string is assumed
to contain characters that could be read as numerical input. The function
builds a number until it encounters a character it does not recognize as
belonging to the desired type of number. The functions return the value built,
or if no number could be built.
void *calloc (size_t nr_elems, size_t bytes_per_elem) This func-

enough storage to hold an array containing nr elems elements,
tion allocates
each of which is a data structure that requires bytes per__elem bytes of
storage. In short, calloc( ) allocates nr elems * bytes per elem bytes of
storage. The function returns a pointer to the beginning of that storage. This
pointer should be cast to the appropriate type of variable. The function returns
a null pointer if the space could not be allocated.
void exit (int outcome) This function ends the program, closing any open
files The outcome value indicates the conditions under
before terminating.
which the program ended. Usually, an outcome of indicates a normal
termination, and a nonzero outcome indicates an error condition on termina-
tion. This outcome information is accessible to other programs, and also to
DOS batch files, as you saw in Chapter 12.
void free (void *buff) This function deallocates the specified area of
memory. This area must have been allocated using calloc( ) or malloc( ). Note
that buff points to the beginning of the storage that will be released.
void *malloc (size_t nr_bytes) This function allocates the specified

amount of storage, and returns a pointer to the beginning of the storage
)
allocated. As with calloc(), the function returns a pointer to void, which

should be cast to the desired type. If the function cannot allocate the storage, it
returns a null pointer.
int rand (void) This function returns a pseudorandom integer within the
range of values allowed by an int, to 32767 in QuickC and Microsoft C 5.0.
Note that rand( ) is not built into QuickC.
void *real!oc (void *buff, size_t size) This function lets you change the
size of a block of memory previously allocated with calloc() or malloc( ). The
contents of buff are unchanged up to the original size of buff. The function
returns a pointer to the new location of buff if buff was moved, or to the
current location if the additional storage was available right after the end of
buff. The function returns a null pointer if the additional storage cannot be
allocated.
New Functions
The following functions are also declared in stdlib.h, and may be useful for
your programming tasks.
div_t div (int numerator, int denominator) This function returns a struc-
ture containing the results of using integer division to divide numerator by
denominator. Two items of information are returned, the whole number
quotient and whole number remainder. The returned type, div t is a typedef
that specifies a structure containing two int members, quot and rem, for
storing the quotient and remainder, respectively. Look at the stdlib.h file to see
the exact definition.
Essentially, div( ) returns the results of applying both integer division and
the modulus operator to numerator. Be aware that div( ) is not predefined in
QuickC. The following statement would assign the structure returned by div(
to thediv_t variable, outcome.
/* assume num and denom are int variables,

and outcome is a div t
•/
outcome - div ( num. denom);
char *getenv (const char *str) This function reads environment informa-
tion stored by the operating system. You can set various environment variables
; ;; :
518 Using QuickC
when using your computer. In DOS, these include path, lib, include, and
others.
Calling getenv() with an environment variable name tells the
function to
check the system's environment table to determine
the current value of the
specified environment. The function returns
a pointer to the string associated
with the environment, or a null pointer if the
environment variable is not
defined at the time or if the variable name is not
one the system recognizes. The
following call would assign the contents of the
include environment string to
whats_included.
/* asBiune whats.included is a string variable */
whats.included = getenv ( "INCLUDE"): /* upper case needed */
whats.included = getenv ( "include"); /. produces different result */
In this function, the case of the string

argument does make a difference. The
program will give two different results for the two calls. Try the two versions of
the call on your machine.
char Mtoa (int nr, char radix)

.str, int This function converts an integer
value to a string, returning the resulting string.
The value you want converted
IS the first argument, nr;
the second argument is str, the string built
(and
eventually returned). The third argument, radix,
is the number base you want
the function to use when building the string.
This base can be any value
between 2 and 36.
The following statements would convert the value -2300 to strings
containing binary, octal, decimal, and hexadecimal
forms of the number,
respectively;
/* Program to illustrate use of itoa() function */
#include <8tdlib.h>
#define MAX.STR 80
mainO
{
char *result. temp [ MAX.STR]
result itoa ( -2300, temp, 2);
-
printf ( "base 2 '/.sXn" :result) ,
result - itoa ( -2300, temp, 8);

printf ( "base 8 "/.sVn" :result) ,
result - itoa ( -2300, temp, 10):

printf ( "base 10 '/,a\n" result)
:
,
;
result - itoa ( -2300, temp, 16):

printf ( "base 16 '/.s\n" result)
: ,
; )
base 2 : 1111011100000100
base 8 : 173404
base 10 : -2300
base 16 : f704
Notice that only the base ten representation still has a minus sign in the
resulting string. For other bases, the number is handled as if it were unsigned,
and the bit pattern for the number is merely converted. You can see this if you
look at the bit pattern from the binary representation and then translate these
bits into hexadecimal digits: 1111 == F; 0111 == 7; 0000 = = = 0; 0100 = = 4.
You need to make sure that the second argument is a string for which
enough storage has been allocated to build a value up to 17 bytes long— 16
bytes for the int and 1 byte for the null terminator.
long labs (long val) This function returns the absolute value of a long
argument. It is used in the same way as abs( ), but with long variables instead of
int. The labs( ) function is not built into QuickC.
Idlv_t Idiv (long int numerator, long int denominator) This function
returns a structure containing the results of using long integer division to
divide numerator by denominator. Two values are returned, the whole
number quotient and the whole number remainder. The returned type, ldiv_t
isa typedef that specifies a structure containing two long int members, quot
and rem, for storing the quotient and remainder, respectively. Look at the
stdlib.h file to see the exact definition.
Essentially, ldiv( ) returns the results of applying both integer division and
the modulus operator to numerator. Note that ldiv() is not predefined in
QuickC. The following statement would assign the structure returned by ldiv(
to the ldiv_t variable, l_outcome. This function is not built into QuickC.
/* assume num and denom are long int variables,

and l_outcome is a ldiv_t
*/
l_outcome Idiv ( num, denom)
char *ltoa (long nr, char *str, int radix) This function converts a long
integer value to a string. The resulting string is returned. The value you want
converted is the first argument, nr; the second argument is str, the string built
(and eventually returned). The third argument, radix, is the number base in
; ;
520 Using QuickC
which you want the function to represent the value. This

base can be any value
between 2 and 36.
The following statements would convert the value -2300L
to strings
containing binary, octal, decimal, and hexadecimal
forms of the number,
respectively.
/* Program to illustrate use of ItoaO */

#include <stdlib.h>
#define MAX STR 80
mainO
char *result . temp [ MAX.STR]
result = Itoa ( -2300L, temp, 2);
printf ( "base 2 "/.sU" :
result) ,
;
result = Itoa ( -2300L. temp. 8);

printf ( "base 8 '/.sNn" :
result) .
;

printf ( "base 10 '/,s\n" result);
:
,

printf ( "base 16 Xs\n" result)
:
.
base 2 : lllllUlllllllllUlloiUOCOGOlOO
base 8 : 37777773404
base 10 : -2300
base 16 : fffff704
Notice that, as with the itoa( ) function for int arguments, only the base ten
representation has a minus sign in the resulting string. For other

still
bases, the
number is handled as if it were unsigned, and the bit pattern for
the number is
merely converted. You can see this if you look at the bit
pattern from the binary
representation and translate these bits into hexadecimal
digits.
Compare this output with that for the integer version of-2300. You
need
to make sure that the second argument is a string
for which enough storage has
been allocated to build a value up to 33 bytes long
-32 bytes for the long int
and 1 byte for the null terminator.
int system (const char *str) This function passes the string argument to
the operating systemcommand interpreter, which takes this string as an
command line. Thus, the effect of a call to system() with a DOS
ordinary
command can be the same as if you had typed the string at a regular
DOS
prompt outside your program.
;; ; : ; ;
; ;; ;
If you call the function with a null pointer, the function returns a nonzero
DOS command and if the command
processor present,
value if the is
processor cannot be found. Otherwise, if you pass a nonempty string, the

function returns if the string is successfully executed, and
- 1 if there is an
error. Check your documentation for a discussion of the types of error this
function can report.

The following instruction in a program would do a directory listing while
your program was running, and would redirect this listing to a file named
syslist.zzz:
/* assume result is an int */
result = system ( "dir > syslist.zzz");
The system( ) function is not built into QuickC.
Exercising the stdlib.h Functions
The following program illustrates the use of the functions that are declared in
stdlib.h and described in this section:
/* Program to exercise some of the functions declared in stdlib.h */
#include <stdio.h>
#include <stdlib.h>
#deiine HAX_STR 80
mainO
<
void show_system C void)
void show_itoa ( void)
void show_ltoa ( void)
void show_div ( void)
void show_ldiv C void)
void Bhow.setenv ( void)
show_setenv ()
system ( "pause")
show_system ;
system ( "pause");
show_itoa ()
Bhow_ltoa ();
show.div ();
show.ldiv ()
void Bhow_itoa ()
char *info, *result, temp [ MAX.STR]

int value, radix;
; ; ;; ; ; ;; ; .
522 Using QuickC
printl ( "itoa Value to convert? (0 to stop)

:
') •
info = gets ( temp) V' > >
value = atoi ( inlo);

while ( value)
<
do
<
printl ( "Base? ")
info = gets ( temp)
radix = atoi ( info);
while ( ( radix < 2) || ( radix > 36));
result = itoa ( value, temp, radix)-
printf ( "value '/.Sd; base == •/.2d,' result == - '/.sXn"
value, radix, result);
printl ( "itoa Value to convert? (0 to stop) :

")
inlo = gets C temp) v> >
.
value = atoi ( info);
void Bhow_ltoa ()
char *inlo, *result, temp [ MAX - STR]^

int radix;
long int value;
printf ( "Itoa Value to convert? (0 to stop) ")•

:
mlo gets ( temp);

= ^ ''
value = atoi ( info)
while ( value)
do
{
printf ( "Base? ");
inlo = gets ( temp)
radix = atoi ( info);
while ( ( radix < 2) I | ( radix > 36));
result = Itoa ( value, temp, radix)-
printf ( "value == '/.Sid; base == •/.2d;
result == -/.sU"
value, radix, result);
printl ( "Itoa Value to convert? (0 to stop) :

")
inlo = gets ( temp); ^ '
value = atoi { inlo);
void show div ()
char *inlo, temp [ MAX STR]

dlv.t results;
int numer denom ,
printf ( "div Numerator? (0 to stop)

: ")
info = gets ( temp);
numer = atoi ( info)
while ( numer)
do
; ; ; ; ;;; ;; ; ;; ;: ; ;; ;; ,
prlntf ( "Denominator? ")

info gets ( temp)
denom - atoi ( info)
>
while ( denom •- 0)
results div C numer, denom)

prlntf ( "numer */,6d: denom y,5d; ", nujner. denom):
» printf ( "quotient -- '/.5d; remainder =- '/,Bd\n".

results. quot, results. rem)
printf ( "Numerator? (0 to stop) ");

info gets ( temp)
numer atoi ( info)
void 8how_ldiv ()
<
char *info, temp [ MAX.STR]
ldiv_t results:
long int numer, denom;
printf ( "Idiv Numerator? (0 to stop) ");

:
info = gets ( temp)

while ( numer)
{
do
printf ( "Denominator? ")

info = gets ( temp)
denom = atoi ( info)
while ( denom 0);
results = Idiv ( numer, denom);

printf ( "numer == VilOld; denom == y,101d\n" numer, denom); .
printf ( "quotient == '/.lOld; remainder == V.lOldXn"

results. quot results .rem) ,
printf ( "Numerator? (0 to stop) ");

info - gets ( temp)
void Bhow.systemO
char *8trl = "dir /p";
printf ( "Calling system with : VoS\n" , strl);

system ( "pause")
system ( strl)
8how_setenv ()
char *what8_included;
printf ( "setenv :\n");

whats.included - getenv ( "INCLUDE");
printf ( "include == '/,s\n" whats.included); ,
whats.included = getenv ( "PATH");

printf ( "path == y,s\n" whats.included); ,
524 Using QuickC
This program produced the following

session:
setenv :
include == \qc\inc :\c\inc
Calling syetem with dir /p ;
Strike a key when ready .
Volume in drive C has no label

Directory of C:\BK\SRC
<DIR> 5-13-87 2:34p

<DIR> 5-13-87 7-^/ii^
SoH
DETEX EXE
^l
9776
lilt;
7-01-87
^d
lO^Bla
WFPREP H 902 7-08-87 12:56a
rSlR iSJP ^-16-87 4:19p

CH16 <D1R> 7-23-87 3:55p
14 File (s) 2975744 bytes free
btrike a key when ready
.?fr-iv
.
*° "'"'*'^*' (° ^° stop) -6
Base? S^*'"'"^
l?or° v=i„ »
''*" ° " ? "^"" == 10022220002
convert? (0 to stop) -5
Base? 10
T?i"^ ° u ,
'^'- ''^^ "
1° : "îiit == -5
Base?' 16* *° ''° "^^''*- ^° *» ^top) "5
Tti"*
itoa 7, Value
1
"^' ''*"
to convert? (0 to stop)
:
"
18; result == fffb
1*° »,' Value to convert? (0 to stop) -5
Jtoa;:;Value1i ôn:e;;? ?6 Il^lll--,l0200202220,22nur22

value == -5; base == 10; result -5 "
*° "^""^'^ '° *° stop) -5
Base?' 16
ltor° v.i„/^
itoa "J^/'
Value to convert?
**" "S"" == fffffffb
.
(0 to stop)
div Numerator? (0 to stop) -57
:
Denominator? 23
Nrra;:r? (o"o f^^p^ ''•

"^^""^"^
T " "^^ "-i"<'" " -"
Idiv Numerator? (0 to stop) -57
:
Denominator? 23
numer == -57; jeno^ ==, ,„
quotient "
-2; remainder ==
-n
Numerator? (0 to stop)
Let's look at some of the functions in this program. The show _setenv()
function checks the current path
and the directories that your programs will
search for mclude files. The calls to
systen,( ) invoke the DOS pause
command
which waits for the user to press a key
before proceeding
h
The show_system( ) function provides a directory listing, and also uses

system( ) to pause. The /p switch tells DOS to pause after each screenful,
which is unnecessary in the example but convenient if you have many files in a
directory.
The other functions exercise the functions for converting int and long
variables. Notice that itoa( ) and ltoa( ) retain the minus sign only for base ten
values. Notice also that the same number produces different strings for the int
and the long values. This is because the sign bit creates a very large number in
bases other than ten.
The results are identical for both int and long variables when computing
integral division structures (div t and Idiv_t).
String.
This header file contains declarations for the string handling functions de-
scribed in Chapter 11. In addition, the file contains declarations for several
functions useful for handling arbitrary data stored in memory.
Familiar Functions
Before moving on to some new functions, let's look briefly at the functions
described in Chapter 11.
char *strcat (char *str1, const char *str2)

char *strncat (char *str1, const char *str2, slze_t nr) These functions
append one string (str2) to the end of the other string (strl ). Note that strcat( )
appends the entire str2, whereas strncat( ) appends only the specified nr of
characters. The function removes and adds terminating null characters at the
appropriate places, before returning the newly built string.
int strcmp(const char *str1, const char *str2)

intstrncmp (const char *str1, const char *str2, size t nr) These func-
tions compare the two strings passed as arguments. The strcmp( ) function
compares the entire strings, whereas strncnip( ) compares only the specified nr
;
526 Using QuickC
of characters. The functions return — 1 if strl < str2, if the strings are equal,
and 1 if strl > str2.
char *strcpy (char *str1, const char *str2)

char *strncpy (char *str1, const char *str2, size_t nr) These functions
copy one string (strl) into another (strl). The strcpy() function copies the
entire str2, whereas strncpy( ) copies only the first nr characters. The functions
return the newly created string.
If you instruct strncpy( ) to copy less than all of str2, you will need to
terminate the newly built string, since the function will not do so automatically.
size_t strlen (const char *str) This function returns the number of
characters in the specified string. The value returned does not include the
terminating null character in its count.
New Functions
The next group of functions (those whose names begin with mem) are useful
for moving data around in memory. Rather than working only with strings, the
functions can manipulate arbitrary data types. Some of the functions are mem
counterparts to some of the string handling functions briefly described earlier.
void *memchr (const void *target, int ch, size— t nr) This function
searches target for any occurrence of ch. It will search up to nr bytes or until it
finds ch, whichever comes first. Note that target is declared as a pointer to
void, which you can cast to a different type of pointer. The memchr( ) function
returns a pointer to the location of ch in target, or a null pointer if ch is not
found in the first nr bytes of target.
The following statement returns a pointer to int, after searching the first
nr bytes of int_buff[] for the character with ASCII value 37.
/* Assume int.ptr has been defined as (int *),

and that Int.buf f [] la an array of int.
•/
int.ptr " memchr ( Int.bujtf . 37, nr)

; ; ;
int memcmp (const void *buffer1, const void *buffer2, size_t nr) This
is a comparison function, like strcmp( ); memcmp( ) compares the first nr bytes
of the two buffers. The function returns — 1 if bufferl is less than buffer!, if
the two buffers are equal, and 1 if bufferl exceeds bufferl. You can cast the
buffers to the type of pointers you need in your program. The following listing
shows how to call menicnip( ).
/• assume buflerl and bufler2 have been defined as pointers to int,

and result has been defined as an int.
»/
result = memcmp ( bufferl. buffer2, nr)
void *memcpy (void *target, const void *src, size— t nr) This function
copies the first nr bytes of src to target, and returns a pointer to the target
buffer. Be very careful using this function if the two buffers overlap. For
example, suppose src starts at address 4000 and target starts at address 4050. If
you want to copy 100 bytes of src to target, the compiler may overwrite the
contents of src starting at location 4050 before copying them to target. The
next function described, memniove( ), is better suited for transfers involving
overlapping storage sections.
The following listing copies nr bytes from src to target and returns a
pointer to the resulting buffer:
/* assume target, src, and result have been defined as pointers to int. */
result = memcpy ( target, src. nr)
void *memmove (void *target, const void *src, size_t nr) This function
number of bytes from src to target. Unlike memcpy( ),
also copies the specified
however, menimove( ) moves overlapping bytes before writing over them. The
function returns a pointer to the target buffer.
The following call moves nr bytes from src to target:
/* assume target, src, and result have been defined as pointers to int. */
result « memmove ( target , src , nr)

528 Using QuickC
void *memset (void *target, int ch, size t nr) This function copies ch
into the first nr bytes of target, and returns a pointer to this target buffer. The
following call puts *w' into the first 50 bytes of target. The memmove()
function is not built into QuickC.
/* Assume target and result have been defined as pointer to char. */
result - memset ( target, 'w'. BO);
char *strchr (const char *str, int ch) This function searches for the first
occurrence of the character, ch, in str, and returns a pointer to the first
occurrence of ch in str, or a null pointer if ch is not found.
The following listing finds the first 'a' in str:
/* Assume str is a pointer to char, and result is an int */
result = strchr ( str, 'a'):
char *strdup (const char *str) This function makes a duplicate of str, and
returns a pointer to this duplicate. If the function can't allocate storage for a
copy of the string, the function returns a null pointer. Otherwise, the function
returns a pointer to the newly allocated space containing the string.
The following call assigns a duplicate of "hello there" to the string,
message:
/* Assume message is a string */
message = strdup { "hello there");
char *strlwr (char *str) This function converts any uppercase characters
in str to lowercase, then returns a pointer to the resulting string. The following
listing converts "HELLO THERE" to lowercase, returning "hello there."
/* Assume lower is a string */
lower = strlwr ( "HELLO THERE");
char *strpbrk (const char *str1 const char *str2) , This function looks for
the first occurrence, in strl, of any character from str2. If one is found, the
function returns a pointer to this character — which effectively returns the rest
of the string. If no matching character is found, the function returns a null
pointer.
The following listing searches for any character from "hello" that appears
in "California." The value of str will be "lifornia" after the function call.
/• Assunie str Is a string •/
str strpbrk ( "California", "hello");
char *strrchr (const char *str, int ch) This function looks for the last
occurrence of the character ch in str, and returns a pointer to this character, if
it is found. If the character is not found in the string, the function returns a null
pointer.
The following listing finds the last T in "Walla Walla," and returns a
pointer to this character. In the example, this would result in the string "la"
after the call.
/• Assum str is a string */
str - strrchr ( "Walla Walla". '1');
char *strrev (char *str) This function reverses the characters in str (except
for the null terminator) and returns a pointer to the reversed string. The
following listing shows how to call strrev( ). You also have reverse _str( ) in
your function collection from earlier.
/• Assume str is a string */
str - strrev ( "Walla Walla");
char *strset (char *str, int ch) This function fills str with the character ch,
except for the null terminator, which the function leaves as is. The strset( )
function returns a pointer to the newly initialized string.

The following listing shows how to call this function:
/* Assume str is a string •/
str - Btrset ( str, 'w');
char *strstr (const char *str1, const char *str2) This function looks for
the first occurrence instrl of str2, and returns a pointer to the beginning of this
first occurrence. If str2 is not found instrl, the function returns a null pointer.
The following listing looks for "law" in " Wallawalla" and returns a pointer
to the beginning of its appearance.
; ;
530 Using QuickC
/* Assume str is a string */
str = strstr ( "Wallawalla" , "law"):
Char *strupr (char *str)

This function converts any lowercase
characters
in str to uppercase, and then returns a pointer to the resulting
string The
''"^ '° "'"''' "^''''^ '''"'" '" "PP^'-'^^^^' ^^'"^ning "HELLO
THER?"
/* Assume upper is a string */
upper = strupr ( "hello there");
Exercising the Functions

The following program lets you exercise the functions discussed in this section:
/* Program to exercise some of the functions

declared in string, h */
înclude <string.h>
#include <stdlib.h>
*include <stdio.h>
•define MAX.STR 80
•define MAX NR 80
•define MAX MENU 15
•define NULL.CHAR 'XO'
int buff [ 80]

char cbuf f [ 80]
void wait ; /* function to let pause until user presses

a key •/
/* array with menu selections for this

program */
char *menu [ MAX.MENU] - { "O) Quit",
"l) Semchr".
"2) memcmp", "3) memcpy",
"4) memmove", "5) memset",
"6) strchr", "7) strdup".
"8) strlwr", "9) strpbrk",
"10) strrchr", "11) strrev",
"12) strset", "13) atrstr"
"14) strupr">;
void wait ()
system ( "pause");
/* void show.oenu ( char *menu Int menu.size)

[] .
Display the specified menu, which

is an arrav of strinira
*•"' '"^''" "^ Btrings^n^the men^
*
?^c??^f
runctlon .i'"""*""
Function also prompts
DromDta im»»-
user f^-,- _v_j..°
for a. choice
CALLS : prlntf ()
GLOBALS :MAX.MENU
;; ;
;; .;; ; ; ; ; ;
PARAMETERS :

:
Int menu.size nunber of Items in menu.

:
USAGE : show menu ( menu array, Nr.of .entries)

*/
void show menu ( char *menu [] , int menu.size)

<
Int count;
printf ( "\n\n");
/* If programmer claims menu has more than maxlmun allowed Items,
bring the value Into line.

•/
if ( menu.size > HAX.MENU)
menu.size - MAX.MEKU;
/• display the Individual strings In the array •/

printf ( "%s\n" menu [ count]); ,
printf ( "\n\n");
/« prompt user */
printf ( "Your choice? (Xd to Xd) ", 0. MAX.MEHU - 1);
main
<
void show.menu ( char * []
void show.memchr ( void)
void show.memcmp ( void)
void show.memcpy ( void)
void show.memmove ( void)
void show.memset ( void)
void show.strchr ( void)
void show.strdup ( void)
void show.Btrlwr C void)
void show.strpbrk ( void)
void show.strrchr ( void)
void show.strrev ( void)
void show.strset ( void)
void show.strstr ( void)
void show.strupr ( void)
int selection;
do
show.menu ( menu HAX.MENU) ,
gets ( info)
selection atol ( info)
switch ( selection)
{
default:
break;
case
break;
case 1:
show.memchr ();
break;
show.memcmp ()
break
; ; •• ; ; ;; ; ; ;;; ;;;;;•; ; ;
532 Using QuickC
case 3:
show_memcpy ()
break;
case 4:
show.memmove ()
break
case 5:
show.memset ()
break;
case 6:
show.strchr ()
break;
case 7:
show.strdup ()
break
case 8:
show.strlwr ()
break
case 0:
show.strpbrk ()
break;
case 10:
show.strrchr ()
break
case 11:
show.strrev ()
break;
case 12:
show_strset ()
break;
case 13:
show.strstr ()
break;
case 14:
show.strupr ();
break
>
while ( selection I- o)
void show.memchr ()
int index, i.byte;

int *result src [ MAX NR]
.
j
char *cresult - •
.
char csrc [ MAX.STR:

info . [ MAX.STR]
Int rand ( void)
•"'' ""»*"'" lirstXn");

for"f*iiH"''"*i"«
for ( index - 0; index < MAX.STR;
ore [ index] - rand () index ;+)
printf ( -Byte to find' -)
gets { info);
i.byte - atoi ( info) t
Oxff
result . aenchr ( src.
i.byti. MAX NR)
if ( result •- NULL)
^''^"** ^ ""° ""^ fonnd\n". i.byte);
else
<
printf -Xd found; retux„ value -
(
J Xd\n". i.byte, *result)
for { index - O; index < 10; index++)
printf ( -X7d as bytes: high --
X7d: low X7d\n" -
src [ index] * Oxff);
4
;
;: : : ; ; ; ; ; ; ; ;
prlntf ( "\n\nStrlng to search? ");

gets ( care):
prlntf ( "Character to find? ");
gets ( Info)
ch - info [ 0]
craanlt - BaBchr ( care, ch, 80);
it ( craanlt •- ITOLL)
printf ( "no Xc f ound\n" ch) ,
•laa
<
printf ( " Xc found: return value Xa\n", ch, cresult)
for ( index 0; (index < 16) kt ( care [ index] l> NULL.CHAR)

index* +)
printf ( "X4c", care [ index]):
printf ( "\n"):
wait ():
void ahow.memcmp ()
{
char Btrl [ MAX.STR] , atr2 [ MAX.STR]
Int reault
printf ( "String 1? ");

gets ( Btrl):
printf ( "String 2? "):
gets ( Btr2)
reault memcmp ( Btrl, atr2, strlen ( atrl)):
printf ( "For Xd bytes: result " Xd\n" strlen , ( atrl), reault);
wait ():
void ahow.memcpy ()
<
char atrl [ MAX.STR] , *Btr2 , *reBnlt , temp [ MAX.STR]
printf ( "String? (At leaat 20 charactera, please) ");

geta ( atrl)
if ( atrlen ( atrl) < 20)
<
printf ( "aubstituting abcdefghijklmnopqratuvwxyzVn")
Btrcpy ( strl, "abcdefghijklnnopqrstuvwxyz")
atrcpy ( teap, atrl):

atr2 - atrl + 10;
printf ( "atr2 XaNn", Btr2) —
reault • memcpy ( atr2, atrl, atrlen (Btr2)):
printf ( "After copying to overlapping string: XsVn", result);
/* atrl tenp:
printf ( "restored Btr2 XaNn" atr2) */ , :
reault • memcpy ( str2, temp, strlen (str2)):

printf ( "After copying to NON-overlapping string: Xs\n" result); ,
wait ():
void ahow.aemmove ()
{
char strl [ MAX.STR], *str2, *result, temp [ MAX.STR];
printf ( "String? (At least 20 charactere, please) ");

gets ( strl);
if ( strlen ( atrl) < 20)
{
; ; ; ; ;•
534 Using QuickC
Btrcpy Btrl.
( "abcdefghljkl„mopqrstuv^z"r
Btrcpy ( temp, strl)
str2 - strl + lo
prlntf ( "str2 •- Xs\n".
strj)
result memfflove ( str2 atrl nt-yi.. / ^ nw
prlntf^C After copying to NON-overlapping

string: y.s\„" . result);
void Bhow_memset ()
char str MAX.STR]

Info [ HAX.STE]
[
ch,
.
, .result;
prlntf ( "String to initialize' ")•
gets ( str); '•
printf ( "Initialization
character' ")
gets ( info) '
ch = info [ 0]
snjrriii?jî,^VJ5-<^-) 1)^
' "'^ " '• ^""It);
'
wait 0;
void show_strchr ()
char strl [ MAX.STR]. info

[ MAX.STR]. ch.
*result;
printf ( "String to search? ")•
gets ( strl):
printf ( "Character to find' ")
'
gets { info)
ch - info [ 0]
result . strchr ( strl. ch)
printf^ "For first occurrence,
( result - %B\n". result);
void show.strdup
()
char strl f MAX.STR]. *result;

prlntf ( "String to duplicate? ")^'
gets ( strl);
result = strdup ( strl)-
""=""- Xb^-^". result);
Salfo;
void show.strlwr ()
nr?^tf f-L^."*^-^™^- result:

gets" itrO;'"* '° """"* *° '"'" "" '^
result - Btriwr ( strl)-
printf ( "result - Xs\n", result);
wait ()
; ;
::; ;; ; ; ; ; ; ;; ;
void show.strpbrk
{
char Btrl [ MAX.STR] . Btr2 [ HAX.STR] . *result
printl ( "String to search? ");

gets ( strl)
print! ( "String to compare? "):
gets ( str2)
result • strpbrk ( strl str2) ,
print! ( "result - Xs\n" result) ,
ait ();
void show strrchr

<
char strl [ MAX.STR] , info [ MAX_STR] , ch. *result;
printl ( "String to search? ");

gets (strl);
printf ( "Character to find? ");
gets ( info)
ch - info [ 0];
result strrchr ( strl ch) ,
printl ( "result Xs\n" result) ,
wait ():
void show Btrrev ()

{
char strl [ MAX.STR] , tresult;
printf ( "String to reverse? ");

gets ( strl):
result - strrev ( strl);
printf ( "result Xs\n" result); ,
wait ():
void show.strset
char Btr [ HAX.STR]. info [ MAX.STR], ch. *result;
printf ( "String to initialize? ");

gets ( str)
printf ( "Initialization character? ");
gets ( info)
ch - info [ 0]
result " strset ( str. ch)
printf ( "Initialized result • XsXn", result);
wait ():
void show.Btrstr
char strl [ MAX.STR] . 8tr2 [ MAX.STR]
printf ( "String to search? ")

gets ( strl)
printl ( "String to lind? ");
gets ( str2)
result - Btrstr ( strl Btr2) .
; ; ; ;
536 Using QuickC
printf ( "result = %s\n" , result)

wait ();
void show strupr ()

<
char strl [ MAX.STR] , *result;
printf ( "String to convert to upper case? ")

gets ( strl)
result = strupr ( strl)
printl ( "result = 7,s\n" result) ,
wait ():
The best way to become comfortable with the way these functions work is
to play with this program, trying various values for each of the available
functions to see the results.
The session with meinchr( ) may need a word or two of explanation. This
function lets you look for a particular byte in an array of pseudorandom in!
values (generated using rand( )), and then in a string. To emphasize the fact
that memchrO works with bytes rather than 16-bit in! values, the program
displays the array values in two ways: as a regular int (all 16 bits at a time) and
by displaying the high and low bytes, which must add up to the 16-bit value.
Remember that inenichr( ) compares the specified byte against the two bytes
that make up each array element, not against the entire array element.
ctype.h
This file contains information about several character handling routines,

which can make string handling and parsing easier. The routines generally
serve to determine whether the character passed to the routine is of a particu-
lar type. In QuickC and in Microsoft C 5.0, these routines are defined as
macros rather than functions.
The format and returns for most of these routines are similar. The routines
return a nonzero value if the specified character meets the conditions tested by
the routines, and a otherwise. All these routines take an int argument and
return an int.
Table 17-1 summarizes the routines, and includes the conditions the int
argument must meet for each routine to return a nonzero value.

Table 17-1. Character Type Routines
Routine
538 Using QuickC
The tolower( ) routine converts an uppercase character to lowercase. If

the character is not uppercase to begin with, the routine leaves the character
untouched. The toupper( ) routine converts a lowercase character to upper-
case, and leaves other characters untouched.
Both toupper( ) and tolower( ) are defined as macros in ctype.h, but they
are also declared as functions in stdio.h. You are probably better off using the
function versions of these routines, because the macros can cause certain side
effects.
If you are going to use theisXXX macros defined in ctype.h, but wish to
use the tolower( ) and toupper( ) functions built into QuickC, you need to use
the #undef preprocessor directive to undefine the macros. The next program
will provide an example of how to do this.
two conversion functions, Microsoft has included a

In addition to these
toascii( ) function in QuickC and Microsoft C 5.0. This function takes an int
argument and returns an int containing only the seven rightmost bits of the
—
number that is, an int with a value in the ASCII range of 0x00 to 0x7F.
Essentially, this function masks the argument with 0x7F, that is, argument &
0x7F.
^CAUTION The toascii( ) function is not specified in the Draft Proposed

ANSI Standard; using this function will make your programs less trans-
portable.
Exercising the Character Routines
The following program you explore the behavior of these character

lets
routines, and also shows how to undefine tolower( ) and toupper( ).
/* Program for exercising the character checking macros and functions •/
#lnclude <8tdio.h>
#lnclude <ctype.h>
/* undefine the toupper and tolower macros, so that the functions

declared in stdio.h will be used instead.
•/
#ifdef toupper
#undef toupper
#endif
#ifdef tolower
thuidef tolower
«endif
*define MAX STR 80

«define HAX.HENU 10
; ;; : ; ; ; ; ; ;
/* array with menu selections for this program */

char 'menu [ MAX.MENU] - { "0) Quit". "1) isalnum",
"2) isalpha" "3) isascii" , ,
"4) iscntrl". "6) isdiglt",

"6) isgraph", "7) islowar",
"8) isprint", "0) ispunct",
"10) isspace", "11) isupper",
"12) isxdigit". "13) toascii".
"14) tolowor" "IB) toupper"}; ,
/* void show.menu ( char 'menu [] , Int menu.size)
Display the specilied menu, which is an array ol strings,

nenu.slze indicates the number of strings in the menu.
CALLS printf
:
GLOBALS MAX.MENU
:
PARAMETERS :
char tmenu [] array of strings, containing menu.

:
int menu.size number of items in menu.

:
USAGE show.menu ( menu_array, Nr.of .entries)

:
*/
void show.menu ( char *menu [] , int menu.size)

<
int count;
printf ( "\n\n");
/* if programmer claims menu has more than maximum allowed items,

•/
if ( menu.size > MAX.MEHU)
menu.size MAX.MEHU;
/• display. the individual strings in the array •/

printf ( "Xs\n" menu [ count] ) ,
printf ( "\n\n"):
/* prompt user */
printf ( "Your choice? (W to Xd) ", 0, MAX.MEHU - 1);
main ()
<
void report ( int)
int ch, selection, result;
selection 0;
show.menu ( menu, MAX.MEHU);
gets ( info)
selection - atoi ( Info)
if ( ( selection > 0) bti selection < MAX MEHU)) (.
<
printf ( "Character to test (enter int value)? ")
gets ( info)
ch - atoi ( info)
}
switch ( selection)
<
default
break;
; : ;; ; ; ; ; ; ;;;;;;;;;; ; ;;;;•;;;;;;;;
540 Using QuickC
case 0;
break;
case 1
result - isalnun ( ch)
report ( result)
break
case 3:
result • Isalpha ( ch)
report { result);
break;
case 3:
result - isascil ( ch)
report ( result)
break
case 4:
result - iscntrl ( ch)
report { result)
break;
case 6:
result - isdigit ( ch)
report ( result)
break
case 6:
result isgraph ( ch)
report ( result)
break;
case 7:
result = islower ( ch)
report ( result)
break;
case 8:
result = isprint ( ch)
report ( result)
break;
case 9:
result = ispunct ( ch)
report ( result)
break
case 10:
result = isspace ( ch)
report ( result)
break;
case 11:
result = isupper ( ch)
report ( result)
break;
case 12:
result - Isxdigit ( ch)
report ( result)
break
case 13:
result « toascii ( ch)
printf ( '7.c\n", result);
break;
case 14:
result - tolower ( ch)
printf ( "Xc\n'', result);
break
case 16:
result - toupper ( ch)
printf ( "XcXn". result);
break i
while ( selection !- 0)
iôid report ( int val)

{
if ( val " 0)
prlntf ( "FalBe\n");
else
print! ( "True\n");
dos.h
This file, which is not part of the Draft Proposed ANSI Standard, provides
information and data structures for taking advantage of some of the services
DOS can provide. In this file, QuickC and Microsoft C v5.0 provide a REGS
union type that you can use to access the machine registers in your computer.
You can access entire (16-bit) registers at one time, or you can access the
individual bytes of a register. This union is used when you want to call DOS or
the BIOS (Basic Input Output System) to perform a particular task.
In addition to this union declaration, dos.h also contains the function
declarations you need to access the registers. In this section, you'll learn about
one of these functions, and how you can use it to get various types of
information from DOS.
Background
You don't really need to know the details of how things operate internally when
you ask the operating system to do something. A few words about how the
hardware and software interact to provide DOS services might be helpful,
however.
Registers Machines based on the Intel 8086 family of processors (includ-

ing the 8088, 80286, and so on) do much of their work in machine registers of
various sorts. These registers are 16 bits wide, and are used to store various
pieces of information while a program runs. When a program is run, much of
the action either takes place in these registers or is controlled by values stored
in them.
542 Using QuickC
Four general-purpose known as AX, BX, CX, and

registers,
DX respec-
used by the function we'll be using. You can
tively, are
access an entire' register
at once, or you can access the
high and low-order bytes of the register
separately. When you are accessing an entire register, you refer to AX,
BX, and
so on. When you are accessing individual bytes, you refer to the AH (high-
order byte) and the AL (low-order byte)
of AX, for example. Look at the
declaration of the REGS union in dos.h, to
see how these elements are used as
union members.
Interrupts An interrupt is from the program (or from

essentially a signal
elsewhere) to the CPU. When an interrupt is made, the current activity
stops
temporarily, while the new task is carried out.
Each interrupt has a numerical
code associated with it. This identifies the
interrupt for the hardware, which
then finds the code required to carry out the
task specified by the interrupt.
There are two general ways of interrupting DOS
via software. The first
uses a function call to pass an interrupt
number to the operating system. The
number passed corresponds to the interrupt requested.
For example, software
interrupt 0x25 isa request to do an absolute disk read
particular section of the disk, regardless of
that — is, to read a
whether this section is part of a file
or not.
The other way to interrupt DOS is to call a special software interrupt
0x21, which provides access to additional
DOS services. This interrupt is
sometimes known as ih^ function dispatcher,
since its job is to access the
appropriate DOS service. To use interrupt 0x21,
you need to pass another
value, which corresponds to the DOS
service that you want. For example
DOS service 0x36 tells you the amoum of free disk space, and
service 0x30
returns the DOS version number. The
requested service number must be
placed in a particular register before you
call interrupt 0x21.
The examples we'll look at can all be accomplished
using interrupt 0x21
Therefore, we'll discuss only the library function
that gives you access to this
interrupt. For more information on DOS
interrupts and DOS services, consult
more specialized books, such as Kris Jamsa's DOS:
The Complete Reference
(Osborne/ McGraw-Hill, 1987) or Ray Duncan's
Advanced MS D05 (Micro-
soft Press, 1986).
; ; ;
int intdos( union REGS *inreg, union REGS *outreg) This function
initiates a DOS software interrupt, 0x21, to request a specified operating
system service. Before you you need to put a value corresponding
call intdos( ),
to the desired service in one of the members of the inreg union. You may also
have to provide other information, depending on the service requested. In all
cases, this information should be stored in the appropriate union member,
before calling intdos( ). Note that intdos( ) returns the value in register AX
after the requested DOS service has done its work. Let's look at an example, to
see how this works.
Determining Availabie DIsIc Space The following program tells you how
much storage space is available on the default drive of your computer. The
function get _ free _ space( ) calls intdos() for software interrupt 0x21 and
requests DOS service 0x36, which ascertains free disk space.
/* Program to determine available disk space.

Program also illustrates use of DOS interrupts.
*/
union REGS inreg, outreg;
main
long get_lree_space ( void)

long result;
result = get_lree_space ()
printf ( "y,ld total bytes f ree\n" , result) ;
long get lree_8pace ()

{
long sectors, clusters, bytes, clusters_per_drive
long total.free, disk.capacity;
/* prepare inreg with the required information.

The AH byte contains the DOS service requested;
the DL byte contains the drive about which you want information
*/
inreg. h. ah = 0x36; /* to ask for DOS service 0x36 */
inreg. h.dl = 0x0; /* to ask for current drive */
/* Call the DOS interrupt 0x21, using intdos */

intdos ( tinreg, ftoutreg) /• to use interrupt 0x21 */
;
; - -
544 Using QuickC
/* results are stored in the registers

Total available space can be computed
f rom
Sectors per cluster . Bytes per sector *
^^ Available Clusters
sectors - outreg.x.ax; /* sectors per cluster returned in
clusters - outreg.x.bx; AX */
/* available clusters returned in BX*/
bytes . outreg.x.cx; /. bytes per sector returned in ?X */
'* ^^"° ' ""<^«<* *° compute FREE space

IJ^»°
It is n=!?.^?^"'"°
useful for ''"
computing disk capacity, however.
^^
clusters.per.drive = outreg.x.dx; /* clusters on drive in DX ./
printf ( "sectors == '/.dNn" sectors):
.
printf ( "clusters == '/,d\n". clusters)-

printf ( "bytes -= y.d\n" bytes)-
.
total'fr.?iTr^-P"-'^"*
total.free - bytes * sectors * clusters;
"
''•^^''"- clusters.per drive) ,-
disk.capacity = bytes * sectors * clusters

per drive
P""!i \ "1° '*^ ''"'' capacity == '/.IdXn" disk capacity)
,
printf "Total bytes free == '/.IdNn" total fêe)- ^
- .
i
return ( total.free)
sectors -4
clusters - 1204
bytes " 612
clusters.per.drive —
16318
Total disk capacity ~
33418264
Total bytes free —
2466792
2466782 total bytes free
Once the DOSservice has been performed, the data

needed to compute
available disk space are returned in
members of the union outreg The number
of sectors per cluster is returned in the
AX
member; the number of free clusters
IS returned in BX; the
number of bytes per sector is returned in CX; and the
total number of clusters on the
disk is returned in DX. (See your DOS
documentation, or Jamsa's DOS: The Complete
Reference, for more infor-
mation about how disks are organized into sectors
and clusters.)
Notice that bytes were manipulated before
calling intdos( ), whereas entire
register values are returned. This is
not uncommon when dealing with DOS
mterrupts and services. Generally, the number
of the DOS service requested
will be stored in AH, the
high-order byte of AX. Additional information
needed by a particular service may be stored
in other bytes.
Getting Date and Time The following program adds three new functions
to the preceding program. Two of these use DOS services to do their work; the
third, how _ Iong( ) is used to compute the time elapsed between any
starting
and finishing points.
; ; ; ; ; ; ; ; ; ;
/* Program to get current date

and to time how long it takes to do this 1000 times.
Program also illustrates use oi DOS interrupts.
»/
union REGS Inreg, outreg;
main ()
long get_free_space C void)

long result
double get_time ( void)
double how.long ( double, double);
void get.date ( int *. int •, int *)
double start, finish;
int index, month, day, year;
start " get.time ();

for ( index - 0; index < 1000; index++)
{
get. date ( 6month, tday, tyear)
y
finish get.time ();
printf ( "Xd / Xd / y,d\n" month, day, year);
,
printf ( "XlO.Slf seconds elapsedXn" how. long , ( start, finish));
long get free_8pace ()

{
long sectors, clusters, bytes, clusters_per_drive;
long total.free, disk.capacity;
/* prepare inreg with the required information.

The AH byte contains the DOS service requested;
the DL byte contains the drive about which you want information
*/
inreg. h. ah - 0x36; / to ask for DOS service 0x36 «/
inreg. h.dl = 0x0; /• to ask for current drive */
/• Call the DOS interrupt 0x21. using intdos */

intdos ( ftinreg, toutreg) /• to use interrupt 0x21 */
;
/* results are stored in the registers.

Total available space can be computed from:
Sectors per cluster * Bytes per sector * Available Clusters
*/
sectors outreg. x. ax; /* sectors per cluster returned in AX *,'
clusters = outreg. x.bx; /* available clusters returned in BX */
bytes • outreg. X. ex; /* bytes per sector returned in CX */
/* The following number is not needed to compute FREE space.

It is useful for computing disk capacity, however.
•/
clu8ters_per_drive outreg. x.dx; /* clusters on drive in DX */
printf ( "sectors *== %d\n" sectors); ,
printf ( "clusters =• %d\n" clusters); ,
printf ( "bytes == y,d\n" bytes) ,
printf ( "cluBterB_per_drive =" y,d\n", clusters_per. drive)

total_free bytes * sectors * clusters;
disk. capacity - bytes » sectors * clusters_per_drive
printf ( "Total disk capacity =» '/,ld\n" disk_capacity) ,
;
printf ( "Total bytes free == Xld\n" total.f ree) .
return ( total.free)
; ;; ,
546 Using QuickC
/* lunction to get current date, and to pass information back

in three pieces month, date, year.
:
Notice that month and date are stored in bytes, whereas year
is stored in a 16 bit register value.
*/
void get_date ( int *month, int *day, int *year)
{
/* Ask lor DOS service Ox2a */
inreg.h.ah = Ox2a;
/* Call DOS interrupt 0x21

intdos ( &inreg, &outreg)
month = outreg.h.dh; / current month returned in DH (byte) /

day = outreg.h.dl; / current day returned in DL (byte) /
year = outreg.x.cx; / current year returned in CX (register) /
/ Function to get the number of seconds elapsed since midnight on the

system clock.
*/
double get time ()
{
unsigned int hrs, mins, sees, hundredths;
/ Request DOS service 0x2c /

inreg.h.ah = Ox2c
/* Call interrupt 0x21 with the appropriate unions /

intdos ( &inreg, Icoutreg)
hrs - outreg.h.ch; / hours elapsed returned in CH /

mins = outreg.h.cl; / minutes elapsed returned in CL /
sees = outreg.h.dh; / seconds elapsed returned in DH /
hundredths = outreg.h.dl; / l/lOO's seconds returned in DL /
/ Total elapsed time (in seconds) =
3600 (sees / hr) hrs +
60 ( sees / min) mins +
1 ( sees / sec) sees +
.01 ( sees per 1/lOOth see) hundredths.
•/
return ( (double) hrs 3600.0 + (double) mins 60.0 +
(double) sees + (double) hundredths / 100.0);
/ Function to compute the number of conds elapsed between

start and finish
/
double how_long ( double start, double finish)
{
#define FULL.DAY 86400.0 /• seconds in a 24 hr day •/
/ start == first elapsed time measurment;

finish == second elapsed time measurement
If start > finish then the time must have pa idnight
between start and finish of process.
In that ease, a formula adjustment is necess
*/
if ( start > finish)
return ( FULL_DAY - start + finish);
els
return ( fi ish start)
The function get_date( ) is used to determine the current date on your

machine. The DOS service to provide this information is number 0x2a. The
service returns the information in three pieces, corresponding to month, day,
and year. Notice that month and day are returned in bytes, whereas the year is
returned in an entire 16-bit value. (This service also returns the day of the week
in numerical form. This information is returned in AL, with Sunday == 0, and
so on. You can modify the function so that it also provides this information to
your program.)
The get_time() function uses DOS service 0x2c to get information
about the amount of time elapsed on the system clock since midnight. This
amount is reported in units ranging from hours down to hundredths of a
second. Again, each of these data is returned in a different byte: hours in CH,
minutes in CL, seconds in DH, and hundredths of a second in DL.
To time something in your program, call get_time( ) before starting the
portion of the program that you want to time. This call assigns the amount of
time elapsed up to the time the program portion begins. When the timed
portion is finished, call get_time( ) again. The difference between the values
returned by the two calls to get_time() represents the amount of time the
program portion took, provided you were not running this program around
midnight.
If your first time reading is before midnight and your second reading is
after midnight, the results will be incorrect ifyou simply subtract one value
from the other, because elapsed time starts from again at midnight. The
how _ long( ) function returns the amount of time elapsed between two calls to
get_time( ), and corrects the computations for the cases where you cross the
midnight boundary.
The program uses these three functions to determine how long it takes to
call DOS for the current date 1,000 times.
Cautions When Using DOS Interrupts
Be careful when using DOS interrupts, especially if you are using interrupts or
services that will actually change something on the disk. Before you use
services that will reset the current date or write to particular parts of a disk,
make certain that you understand exactly how the interrupt or service works,
thatyou know exactly what values you want to change, and exactly what new
values you want. You can get into lots of trouble if you are sloppy here. Again,
548 Using QuickC
the references mentioned earlier can provide more details about the interrupts
and services.
io.h
This file, which is not specified in the Draft Proposed ANSI Standard,
contains definitions and declarations for doing lower-level input and output,
and file handling.
Familiar Functions
You've already learned about one of the functions declared in io.h: the
remove( ) function, which deletes the specified filefrom disk. The function
takes a string argument, which specifies the file's disk name, and returns if
the file has been removed, or a negative value if it has not been removed.
New Functions
The following functions provide additional ways to use and change files:
int access ( char *file_name, int mode) This function determines

whether the specified file, file _ name, exists and whether the file can be
accessed in the mode specified. The function returns if the file can be
accessed in the specified mode, and — 1 otherwise.
modes refer to the manner in which you can interact with the file. The
File
most common modes are read only, write only, and read and write. In DOS all
files can be read, so effectively there are only two modes: read only or read
and write. You also can tell the access( ) function simply to check whether the
file exists.
The following listing shows how to call acces$( ):
/* AsBiune result is an int */
result " access ( "mylile.tex", 00); /* just test for existence */

;
The mode argument can take the following values: 0x00 (check for
existence only), 0x02 (check for write permission), 0x04 (check for read
permission), or 0x06 (check for read and write permission).
Int chmod( char *file_name, int mode) This function changes the file
access setting associated with a particular file. For example, the function lets
you make a read only file out of one that you could previously read and write.
The function does not open the file; it only changes the file's status in the disk's
directory.
As noted in the previous function, there are essentially three modes for
interacting with a file: read only, write only, and read and write. The chmod( )
function lets you specify a new setting for the file you pass as the first
argument. The possible values are represented by manifest constants:

S_IWRITE, S_IREAD, or S_IREAD|S_IWRITE. In DOS, the first
and third are equivalent, since all DOS files have read permission.
The following statement shows how to call chmod( ):
/* Assune result is an Int •/
result cJunod ( "mylile.tex", S.IWRITE)
This Statement will modify the status ofmyfile.tex so that it will be possible to
write to the disk file with that name. Note that chmod( ) returns if the change
was successful, and — 1 if there was an error.
int rename ( const char *old, const char *new) This function lets you
rename an existing disk file or directory, from old to new. The two arguments
are strings that specify the file name, including any necessary path informa-
tion.The function returns if the name change is successful, and a nonzero
value if there is an error. The rename( ) function is not built into QuickC.
There are some restrictions on this function. First, old must exist, and
new must not exist. If a file with the same name as new exists, the function will
return an error value. Another restriction is that you can't transfer files from
one drive to another. For example, you could not use this function to transfer a
file from drive B: to drive A:.
The following listing illustrates the use of rename( ). The statement would
effectively move the file 17.5 from the \bk \src directory to the \bk directory.
; ; ; :
550 Using QuickC
/* asBUffle result Is an int */
result • rename ( "\bk\src\17.B", "\bk\17.5");
Exercising Some of the io.h Functions
The following program shows how some of the functions declared in io.h
work. The program checks whether a file named zzzztest.io exists. If not, the
program creates such a file, opening it as write enabled. The program then
changes the access mode to make this file read only. Notice that one conse-
quence of this is that the DOS command to delete the file fails, as it does in the
calls to system( The "Access denied" message comes from DOS.
).
Notice the way access( ) is used in the tests. You are always looking for the
negation of the value returned. This is because access( ) returns a if the
outcome is as you expected. So, you need to make this true, which you can do
by negating it.
/• Program to Illustrate use ol some functions declared in io.h •/
•include <Bys\typeB.h> / needed for chmod () */
•include <sy8\stat.h> /* needed for chmod () */
•include <io.h>
•include <stdllb.h>
main ()
FILE *f.ptr;
/* chmod ( "2zzzteBt.io2", S.IWRITE)

exit (0); */
if ( I access ( "zzzztest.io", 0x00))

prlntf ( "File already exists. \n");
else
{
f.ptr fopen ( "zzzztest.io", "w");
printf ( "File opened as write enabled. \n")
fprintf ( f.ptr, "Hello there");
fcloseallO:
if ( I access ( "zzzztest.io", 0x02)}
{
chmod ( "zzzztest.io", S.IREAD);
printf ( "File changed to read only\n");
}
else
printf ( "File is already read only.\n");
printf ( "Trying to delete zzzztest.io, a read only file.\n");

system ( "del zzzztest.io");
printf ( "Renaming zzzztest.io to zzzzteBt.io2.\n")

rename ( "zzzztest.io", "zzzztest .io2")
printf ( "Trying to delete zzzztest. io2, a read only file.Nn");
; ; :
system ( "del zzzztest.lo2")
If ( I access ( "zzzztest.io2", 0x04))

{
chmod ( "zzzzteBt.io2", S.IWRITE)
prlntf ( "File changed to read / write\n");
}
11 ( I access ( "zzzztest io2" 0x00)) . ,
printi ( "New file is in director/An");

else
{
printf ( "Hew File NOT in directory, checking old nameAn");
if ( I access ( "zzzztest lo" 0x00)) . ,
printi ( "Old tile is in current directory An")
printi ( "Old file NOT in directory, either An");

}
}
File already exists.

File is already read only.
Trying to delete zzzztest. lo, a read only file.
Access denied
Renaming zzzztest. io to zzzztest. lo2.
Trying to delete zzzztest lo2, a read only file. .
Access denied
File changed to read / write
New file is in directory.
Notice the preprocessor directives to include sys\types.h and sys\stat.h.

These are needed for the second argument to chmod( ), because elements of
S — IREAD, and so on are defined in these files.
You should remove the zzzztest.io2 file, since we won't be using it
anymore.
math.h
This file contains the declarations for many functions useful for mathematical
work. The file also includes a structure declaration for complex numbers. The
math functions are not built into QuickC.
Familiar Functions
You've seen a few of the functions declared in math.h in some of the example
programs.
552 Using QuickC
abs()
labs( ) These functions compute the absolute value of an int and a long,
respectively. Recall that the absolute value is the positive form of a number.
Thus, abs( 5) == 5, and abs( —5) == 5, as well.
pow( ) This function takes two arguments, raises the first argument to the
power specified by the second argument, and returns the result as a double.
sqrt() This function returns the square root of the value passed in. The
argument to sqrt( ) must be or greater. If you pass the function a negative
value, the function will return and will set errno to the appropriate error
value.
New Functions
The following math functions represent only a few of the functions declared in
the math.h header file:
double acos (double value)

double asin (double value)
double atan (double value) These functions return the angle correspond-
ing to the value passed to the function. For example, acos(— 1 ) would return
the angle whose cosine was — 1. This angle is 180° , or tt in radian measures.
Saying that the arcos of (— 1) is tt means that the cosine of tt equals — 1.
The acos() function can only handle arguments between —1 and 1,
inclusive. This means the function will return values between and tt inclu-
sive. If the argument is outside this range, the function returns a 0, sets the
value of errno (a global variable containing a code for the last error encoun-
tered), and prints an error message to stderr.
Note that asin( ) also handles only arguments between — and In this 1 1 .
case, the function returns a value between — tt / 2 and n- / 2. The asin( ) function
behaves just like acos( ) in the case of an invalid argument.

The atan() function returns a value between —njl and 7r/2, which
corresponds to the angle whose tangent is the argument value.
/• Prograua to Illustrate use of inverse trigonometric functions */
Înclude <stdio.h>
#include <math.h>
«define INCREMENT 0.1
main ()
double counter:
prlntf ( "ValueUNtACos ONtXtAsin ()\t\tATan ()\n");

lor ( counter - -1; counter <» 1; counter += INCREMENT)
/* display acos, asln and atan for each value •/

prlntf ( "%B.31f\t\ty,B.31f\t\t'/.B.31f\t\t'/.B.31f\n".
counter, acos ( counter), asin ( counter),
atan ( counter) ) ;
Value
; ; ; ; ; ; •
554 Using QuickC
/* Program to illustrate ceilO and floorO functions */

#include <Btdio.h>
#include <math.h>
#define MAX_STR 80
#define TOLERANCE le-7
#define TRUE 1
#define FALSE
main ()
double cresult, {result, val;

char str [ MAX.STR]
printl ( "Value? (0 to stop) ")

gets ( str)
val = atof ( str)
while ( non_zero ( val))
cresult = ceil ( val)

fresult = floor ( val)
printf ( "Ceiling == '/.10.21f; floor ==
'/.lo 21f\n"
cresult. fresult)
printf ( "Value? (0 to stop) ")
gets ( str) ;
val = atof ( str)
i:t":n":z"ern '.izi
{
'' "
vîf"
'"^ "^° "^ "° " ^'^^^ ^ ^^^^^"-^ — */
^
r:tu;n° (° TRUE)° '"'''"'^ " "^^' " °°^ ' -TOLERANCE))
else
return ( FALSE)
The program produces the following session:
Value? (0 to stop) 3.50

Celling — 4.00; floor ~ 3 00
Value? (0 to stop) -3,50
Celling " -3.00; floor - -4,00
Value? fo to stop)
double cos (double angle)

double sin (double angle)
double tan (double angle) These functions return the sine, cosine,
and
angent respectively, of the specified
angle. The specified angle is in
radians If
the angle argument large, the returned value
is
may lose precision
;
/* Program to illustrate use of trigonometric functions */
#include <Btdio.h>
Vlnclude <math.h>
#deflne INCREMENT 0.1
main ()
<
double counter;
printl ( "Value\t\tCos ()\t\tBln ()\t\tTan ()\n");

lor ( counter - -1; counter <1; counter +- INCREMENT)
/* display acos. asin and atan for each value */

printf ( "i'.5.31f\t\t'/.B.311\t\ty.B.311\t\ty.5.31f\n"
counter, cos ( counter), sin ( counter),
tan ( counter))
Value
556 Using QuickC
librarydocumentation on your own, however. You could

save yourself a lot of
work if you find a function that does what you
want to do in your program.
Summary
This chapter has provided a brief discussion
of some of the header files that
come with your QuickC package, and of some of the functions, data types and
constants declared in these files. With this
information, you're all set to explore
C more thoroughly on your own. Happy programming!
I
ASCII CODES
Table A-1 lists the ASCII codes for characters.
Table A- 1. ASCII Character Codes
DEC
558 Using QuickC
Table A-1. ASC II Character Codes (continued)
DEC OCTAL HEX ASCII DEC OCTAL

36 044 24
37 045 25
38 046 26
39 047 27
40 050 28
41 051 29
42 052 2A
43 053 2B
44 054 2C
45 055 2D
46 056 2E
47 057 2F
48 060 30
49 061 31
50 062 32
51 063 33
52 064 34
53 065 35
54 066 36
55 067 37
56 070 38
57 071 39
58 072 3A
59 073 3B
60 074 3C
61 075 3D
62 076 3E
63 077 3F
64 100 40 @
65 101 41 A
66 102 42 B
67 103 43 C
68 104 44 D
69 105 45 E
70 106 46 F
71 107 47 G
72 110 48 H
73 111 49 I
74 112 4A J
75 113 4B K
76 114 4C L
77 115 4D M
78 116 4E N
79 117 4F
80 120 50 P
81 121 51
•Reprinted from rhe C Uhrarv

B
Building
Libraries in
QuiclcC
One of C's most important features is the ease with which it allows you to build
and use function libraries, precompiled collections of functions that you can
use in you programs. The advantage of using such libraries, as opposed to
having the source code for the Ubrary functions in your program, is in the time
saved because the compiler doesn't have to compile the functions every time
you make changes to your program.
QuickC is particularly flexible in the way it you work with
lets libraries.
You can build two types of Ubraries in QuickC. The first type. Quick
libraries.
are built for use when you want to run your program inside the QuickC
environment, as opposed to building an executable version of your program.
559
560 Using QuickC
That IS, Quick used when you want to compile your program
libraries are
to
memory while inside QuickC, and then run the program.
Quick libraries have
the extension .qlb. You don't need to use a Quick library if you plan to compile
the function to executable code each time - that is, if you're going to create an
•exe file whenever you compile. Quick can only be used with QuickC.
libraries
The second type of library is a stand-alone library, which contains
precompiled functions that can be linked into your
program when you're
building an executable version. Such libraries
generally have the extension
.lib. Stand-alone libraries
have the same format as the libraries included with
QuickC or Microsoft C 5.0.
In this appendix, you'll learn how to
build both types of libraries. You'll
build a Quick library containing Run-Time
library functions that are used in
our example programs, but that are not built
into QuickC. Chapter 6 of the
QuickC Programmer's Guide contains a table of the
functions built into
QuickC. As you'll notice, several of the functions
randO, pow(), and fgetc()-are not built imo QuickC.
we've used including —
In the next section
you'll see how Quick library file, qcstuff.qlb, that contains these
to build a
functions. (This library has been mentioned in
earlier chapters.) You must
build the qcstuff.qlb library yourself; it is not
part of QuickC.
You'll also learn how to build a stand-alone library, and how to link this
library into your programs. We'll only
be looking at a small number of the
possibilities here; read the discussion in
your QuickC Programmer's Guide for
details.
Building Quick Libraries
We'll look at the steps involved in building

aQuick library by developing one
that includes the functions used in the
example programs for this book.
To create a Quick library for a program or programs,
you need to do three
things:
1. Create a source file that includes calls to the

functions you want to
include in the Quick library.
2. Compile and link this source file to create a compiled version of the file
with the extension .qlb.
3. Load the Quick library when you want to run your program within
QuickC.
;
Building Libraries in QuickC 561
Creating the Source File

calls to
The source file you create just needs a main( ) function that contains
the source file
each of the functions you want. The following listing represents
in Chapters
used to build a file, qcstuff.qlb, usable for compiling the programs
1 through 16 within the QuickC environment.
/* Source file containing calls to the functions

needed for
example program in Chapter 1 -- 16.
qcstuff.qlb.
File is eventually compiled and linked to create
*/
#include <math.h>
#include <stdio.h>
main ()
{
char ch;
double dbll. dbl2;
randO ;
Brand ;
IgetcharO ;
IputcharC ch)
_ftol();
pow ( dbll, dbl2);
sqrt ( dbll);
>
As you can see, the format for this file is simple. The entire "program" consists
The program does nothing with the results of
of calls to the desired functions.
these function calls.
The basic strategy QuickC to link the desired functions into a file
is to get
file is then trans-
that really does nothing with them. The resulting object
formed into a .qlb file having the format required for QuickC to be able to
use
these functions when you compile and run your program within QuickC.
Compiling and Linking

to a .qlb File
Once you've created your source file, you need to create a Quick library from it.
The following line contains a batch file you can use to build the file qcstuff.qlb.
qcl /AM \qc\lib\quicklib y.l.c /Fe7.1.qlb /link /Q

562 Using QuickC
Let s look at the elements in

this rather long command line.
The first "word"
on the hne, qcl, lets you compile and
link files outside of the QuickC
environ-
ment The qcl program, which is included
with QuickC, compiles and (if you
wish) hnks the specified files
without bringing you into the QuickC
window
environment.
The /AM medium memory model is to be used This
specifies that a
memory model necessary for a Quick Hbrary. Compiler
.s
and linker options
are case-sensitive m
QuickC and in Microsoft C 5.0, partly because
of the large
number of options available.
^REMEMBER Quick libraries must use a medium memory model.
° ^ W«^\inc\quickHb is to the qcl

program where the
tell
•
qmckhb ''u^Tr'
m-k' obj file is to be found.
The quicklib.obj file is needed for building
Quick ibranes. If you set up your QuickC
files using the default
directories
you only need to specify quicklib here-that
is, you don't need to
specify an
entire path. ^ ^
The next word (%l.c) specifies the file

to be compiled. The %1 is a
placeholder in this batch file, just as it
would be in a printf( ) string argument
When you call this batch file, you need to
specify qcstuff as a command line
argument. You could just as well write
qcstuff instead of %1 in this file, thereby
making the batch file capable of
building just the one Quick library
qcstuff qlbjhe .c extension is
necessary when specifying a file name
here
he /Fe%l.qlb specifies that the
1
"run" file is to have the same name as
your source file (the name substituted
for %1 ), and the extension .qlb
Ordinar-
ily, when you compile
a file to become a stand-alone
program, the resulting file
will have the extension .exe,
since this is the extension DOS
expects However
in this case, you don't want
DOS
to deal with the file; you want
QuickC to run
It. QuickC expects
the .qlb extension.
The /link command invokes the linker, and
the /Q option tells it to create
a Quick hbrary out of the compiled
file. This Quick library
have the file will
lormat appropriate for use by QuickC.
You can accomplish the same thing with a
two-step process. The following
listing shows the two command
lines needed:
qcl /c /AM qcstuff.c

link \qc\lib\quicklib.obj + qcstuff.
obj. qcstuf.qlb. . /Q;
The first invokes the qcl program as in the earlier example. The /c option
line
specifies that you just want to compile, not to Hnk.

The /AM option again
qcstuff.c tells qcl what file you
specifies the medium memory model, and the
want to compile.
The second command line invokes the linker. The lengthy expression,
\qc Mibquicklib.obj + qcstuff.obj, tells the linker what compiled files to link
Such files will generally have the extension .obj, but they may also
be
together.
stand-alone libraries — that is, .lib files.
The qcstuff.qlb argument specifies the "run" file you want the linker to
one-Hne version. Notice that linker parameters, or fields,
create, just as in the
type of information,
are separated by commas. This tells the linker where one
or set of parameters (object files, for example) stops
and the next type (run
files, for example) starts.
Two commas with nothing between them indicate that the linker can use
its default values for that field. In this
case, the space between qcstuff.qlb, and
the next comma indicates that the linker can use its default
names for a file
know as the file, which the linker can create.
map (Such a file contains
information about where in the module the segments of a
program are to be
default, in this case, the
found. For most purposes, you won't need this file.) By
linker would write this information to qcstuff.map.
search for
also specify additional libraries for the linker to
You could
routines needed in other modules. In our case, there were
no other libraries
that needed to be searched. Ordinarily, the linker would

prompt for additional
libraries if none were The semicolon suppresses this prompt.
specified.
library. Linker
Finally, the /Q option tells the linker to create a Quick
options can be included just about anywhere on the command
line.
produce three files in addition to

The commands in the previous listing
the qcstuff.c file that started it all: qcstuff.obj (created by the compiler),
following pair of
qcstuff.map, and qcstuff.qlb (created by the linker). The
command lines would have accomplished the same thing, except that no .map
file would be built.
qcl /c /AM qcstuff.c

link /Q \qc\lib\quicklib.obj + qcstuff.obj, qcstuf.qlb;
Notice that the /Q option has been moved to an earlier part of the line. This
makes no difference, but the semicolon immediately after the name of the run
564 Using QuickC
e .s :mportant. This the linker not to worry about

tells
the remaining two
fields, map f.le and addit.onal
libraries. The result is that
no .map file is
created and the hnker doesn't ask about
whether to search additional library
Loading the Quick Library

Once you've created your Quick library,
you're ready to use it in any programs
that rdy on more than the
functions built into QuickC. To
start QuickC with
"'''^'- "" f«"«-^ ^y ^he name ofle
oZ.V:
Quick library n'as
file,
^'^
in the following
/' ° P^'° "-
command line. This Hne will let you
compile the to memory, once you're in
file srcfile
program uses more than the built-in

QuickC, even though iZ
QuickC functions.
qc /Iqcstuff srclile
Building Stand-alone Libraries
You can use the Microsoft Library

Manager, lib, to build stand-alone libraries
Such libraries consist of compiled
routines that can be added to any
you
program
re building and can be used in the program. Once
they are in compiled
form, the compiler need not
process these routines each time
you compile
v-umpue a
program that uses them.
For example, the following listing collects some of the
more generally
applicable functions we've defined in
this book. We'll build a library
contain-
ing these functions; you can link
this library when you build any
program that
^* "ntaining commonly used functions.

li^l is used to
File illustrate how to build a stand-alone
^^ library.
*include <stdlo.h>
#include <dos.h>
#deline NULL. CHAR -Xo'

#define FALSE
#define TRUE i
#deline TOLERANCE le-12
•define INVALID.VAL -99999 999
; ; ; ; ; ;
'* since midnight.

R^^^s^^hi^nS^ber ol seconds elapsed on system clock
NOTE : Assumes <dos.li> (Microsoft) or equivalent.
USAGE : time.elapsed - get.tlme ;
double get_time ()
double hrs, mins, sees, hundredths;

union REGS inregs, outregs;
/* Request DOS service 0x2c */

inregs. h. ah = 0x2 c
0x2c •/
/* call interrupt 0x21 with DOS service request #
intdos ( tinregs. toutregs)
hrs - (double) outregs. h.ch; /* hrs elapsed returned in CH */

Bins - (double) outregs. h.cl; /* mins elapsed "turned in CL ./
sees - (double) outregs h dh . . ; /* sees elapsed returned in DH »/
hundredths - (double) outregs. h.dl; /* l/lOO's sees returned in DL */
"
/* Total elapsed time (in seconds)
3600 (sees / hr) * hrs +
60 ( sees / min) * mins +
1 ( sees / see) * sees + , , ^^^
.01 ( sees per 1/lOOth see) * hundredths.
hrs * 3600.0 + mins • 60.0 + sees + hundredths / 100.0);

return (
/* double how long ( double start, double finish)

start.
Returns the time elapsed between finish and .. ^ ,.^
before and finished
Routine compensates for tasks that started
after midnight. ^ ..j v^.
time.required - how.long ( start, finish;,
.,
USAGE :
double how.long ( double start, double finish)
define FULL.DAY 86400.0 /• seconds in a 24 hr day •/
/* start " first elapsed time measurement;

finish " second elapsed time measurement.
^^„.„vf
midnight
must have passed
If start > finish then the time
between start and finish of process.
is necessary.
In that ease, a formula adjustment
*/
if ( start > finish)
return ( FULL.DAY - start + finish)
else .
return ( finish - start;
/* void make.str.lower ( ehar *str)

Convert a string to lowercase characters
USAGE :
make.str.lower ( my.str)
void make str_lower ( ehar *str)

{
int index;
index-*)
for ( index - 0; str [ index] !- NULL CHAR;
str [ index] - tolower ( str [ index] )
/* void make_str.upper ( ehar *str)

; ; ; ;
566 Using QuickC
*° -uppercase characters
USAGf" ^make.str.upper
USAGE ^J'''"*
( my.str)
:
^^
void make.str.upper
( char *8tr)
int index:
for index = 0; atr t index] !-

(
str [ index] - tcupp^r
nmr CH4R- < ^
J (
^'['^^^^^Jf^'^**^
/* int non.zero ( double
,/
"SAGE
val)
Return true If val (iiff=-_
test.relSJt'^.^^LTzerTc-^LtTt":^:)^"' ' ^"'^«^^-<*
:
int non.zero ( double

val)
*
—
'' ' " »t'u;n° (° kÊr"""'" " "-1 - ° 0) < -TOLERANCE))
else
return ( FALSE)
J
Return quotle'nt or a '%'"" -^"^"^ "•

def"ult^
OSAGE quotient - sale.di vision u^Tl^^^n'Îfr ° " "'""i° " "y zero.
( nr^êl^f"-^
:
^^
double safe.divlsion
( double nu«er.
double deno»)
int non.zero { double)
if non.zero ( denom))
(
'"^*"" ( n'»er / denom)
else ;
return ( INVALID. VAL)

J
'*
^c^^-rt-h^viiuêrs^^^ff !^4-"« ^---''^
USAGE swap.dbl '"' *"""'^-
^^
:
( fir^t! second J"*
void swap.dbl double *first. double
(
.second)
double temp-
P. /* <-„ .^
/* to store one of the values during
swap ./
temp - *first;
*first • .second;
.second - temp;
void swap.int ( int .first, int

.second)
mt temp;
/. to store one of the values
during swap ./
temp - .first;
.first - .second:
.second - tempj
; ; ;
/* double zero_one_rand
Retoms a pseudorandom value between and 1, inclusive.
USAGE : pseudo zero_one rand ()
•/
{
define MAX.VAL 32767.0 /* NOTE: defined as floating point type */
int rand ( void) ; /* returns a pseudorandom integer */
int rand.result
rand.result - rand /* get a pseudorandom integer */

;
return ( rand.result / MAX.VAL)
To build a stand-alone library, you need to do two things:
1. Compile the source file(s) to an .obj file.
2. Build a .lib library file from this object file, using the library manager
program, lib.
A batch file containing the following two command lines will let you build
a stand-alone library file from a source file. In the discussion, assume the file
containing the preceding listings is named utils.c.
qc 1 /c '/.I . c
lib Xl.lib +'/.i.obJ;
The first line invokes the qcl program to compile the source file specified in the
command line argument when starting the batch file. In our case, this argu-
ment would be utils, without an extension (since the extension is added in the
batch file). You would include this argument on your command line when you
invoked the batch file.
The output from the named utils.obj. The second

first line would be a file
line in the batch file builds the stand-alone library. The first field specifies the
name of a library file to be modified. If no file with this name exists, the library
manager will create a new one, which is what we want in this case. The second
field specifies that the hbrary manager should add (+) the contents of the
object file specified (in this case, utils) to the .lib file. The semicolon again
indicates that the program should not look for additional fields or options.
(See Chapter 10 of the QuickC Programmer's Guide for details on these
additional fields.) The outcome from executing this command line is that a file
named utils.lib is created.
568 Using QuickC
Using a Stand-alone Library
the following program, which

uses several of the functions
in ulJls.lib:
#include <stdio.h>
#define MAX.TRIALS 20
main ()
""""• "'--""° °°^

doSSl: îl?t'; Vi'.l'^t-
""-""^-â""! void) get.time
( void)
doI^M* how.long ( double,
•
(
double
,
double)-
double safe.dlvislon ( double,
mt double)-
''
Index;
start - get.time ();

first - zero.one rand ()
for ( index - 1; index <:
MAX.TRIALS; index++)
second zero.one rand ()-
^'n^/c-lJjto^^lJîrUJ-.-cond);
if ( ratio > max.ratio)
printf "old max -- y.l0.41f;

(
max.ratio, ratio)-
new max " Xio 41f\n"
/.iu'Jiixn
max.ratio • ratio;
if ( ratio > max.ratio)
printf "old max -. Xl0.41f

( ; new max == y.lo
'.iuiiivn
41f\n"
max.ratio, ratio)-
max.ratio - ratio;
first • second;
finish - get.time ()-

printf ( "Xl0.21f secondsXn".
how.long ( start, finish));
The following command line would let you compile this program which
we 1, call rat.os.c, linking
,n the uti.s.lib hbrary while'creatmg'the
ex";:table
qcl ratios. /Feratiosl exe- /link utils.lib;

c .
rat.os.exe. The hnking mstrucfons specify that

the library file, utils.lib is to be
or in the standard
searched for any functions not found in tiie ratios.obj file
libraries.
The resulting ratios.exe file behaves just the same as if the program had
included in both
been built out of a large source file containing the functions
ratios.c and in utils.c, or out of two source files compiled separately or

of
compiled together by including an instruction to read the contents
utils.c
while compiling ratios.c The difference is in the compilation time required. In
this case, compiling just ratios.c, then linking in utils.Iib, is almost 20% faster
than working with the source files alone.
on your
You can explore additional options and ways of using the linker
own. One thing to notice is we didn't include the /AM option. By default,
that
QuickC compiles with a small memory mode. The resuUing files are different
than they would be if they had been compiled with a medium memory model.
make sure the libraries and the source files are
When you link in libraries,
compiled under the same memory models.
Summary
In this appendix, we've looked at two ways to use precompiled files to make
libraries let you
program development quicker and more convenient. Quick
the advantages of
compile and run your programs within QuickC, which has
compile, and revise
speed and ease of modification. This means you can create,
without ever leaving QuickC —
one of the nicest features of the software.
to, you can
Once you've got the program working the way you want it
you'll often want to save
compile it to an executable file. During this process
tested, and can now be
time by linking in precompiled libraries that have been
the compilation process
used in any of your programs. This approach makes
gives you flexibility for building modular
programs. By collect-
faster, and also
ing related functions in libraries and then linking these libraries into the
smaller (since only the
programs you're building, you can make your programs
functions will be linked in) and also make your
program-
librafies for needed
ming tools more widely usable.
QuickC Commani
Summary
This appendix summarizes the commands and options available in QuickC. In
the commands, special notation is used in a few places.
The vertical bar, |, means "or," so that | 1means "0 or 1," as in the
command to set warning levels for qci.exe, for which any of the following
would be valid:
qcl first /WO
qcl first /Wl
qcl first /W2
qcl first /W3
Material between curly braces, i(, is optional, as in the command

add to
watch variables. This material may be repeated more than once. Both of
571
572 Using QuickC
the following would be valid watch

variable selections:
val
val ; even
Angle brackets, < and >. around

material mean that you are to provide
information of the sort specified between
these brackets. Do not include
the brackets m
your text. For example, the first of the
following calls to
QuickC IS valid, but the second call is not
valid:
/* the following call Is valid •/

qc /Iqc stuff
/* the following call is NOT valid */

qc /l<qcstuff>
Commands for Calling QuickC

Start the QuickC program q,.
You can use the following commands

as command-line arguments when
you invoke QuickC -that is, when
you use the qc command.
Start QuickC in black-and-white mode /b

qc /b
Start QuickC when using a color graphics adapter

/g
qc /g
Use as many
screen lines as possible, given the
display adapter being used
/|,
qc /h
Load a Quick library for use when compiling to

^ /\<library name>
qc /Iqcstuff
Start QuickC with a source as the working

file file <file name>
qc first
QuickC Command Summary 573
Useful Commands in the QuickC

Environment
situa-
The following predefined keys are very convenient, especially in dire
listing of the QuickC com-
tions. The on-line help feature provides a brief
mands. The exit command can get you out of many tough situations.
On-line help P'
On-line help about a C keyword or Run-

Time library function (assumes cursor is
on keyword or function name) SHIFT-Fl
Exit from QuickC ALT-F X
Editing Commands
The following commands are available while editing a file. Many of these
commands accomplish the same thing as QuickC menu options, eliminating
the need to call up a menu.
Movement Commands
Move up one line UP ARROW
or
CTRL-E
Move down one line DOWN ARROW
or
CTRL-X
Move right one character RIGHT ARROW
or
CTRL-D
Move left one character LEFT ARROW
or
CTRL-S
574 Using QuickC
Move right one word

CTRL-RIGHT ARROW
CTRL-F
Move left one word
CTRL-LEFT ARROW
CTRL-A
Move to top of screen
CTRL-Q E
Move to bottom of screen
CTRL-Q X
Move to beginning of line
HOME
CTRL-Q S
Move to end of line
END
or
Move to beginning of
CTRL-Q D
file
CTRL-HOME
or
CTRL-Q R
Move to end of file
CTRL-END
or
CTRL-Q C
Move to next error
SHIFT-F3
Move to previous error
SHIFT-F4
Scroll up one line
CTRL-W
Scroll down one line
CTRL-Z
Scroll up one screen, or window PGUP
or
CTRL-R
Scroll down one screen, or window PGDN
or
CTRL-C
Scroll left one window
CTRL-PGUP
Scroll right one window CTRL-PGDN
Find text to be specified
CTRL-Q F
Find next occurrence of text just
found F3
Find selected text
CTRL-\
Find and change text to be
specified CTRL-Q A
The following command is available after CTRL-Q A has been specified:
Switch to Change To text box ALT-T
Selection Commands
Select preceding character SHIFT- LEFT ARROW
Select current character SHIFT- RIGHT ARROW
Select preceding "word" SHIFT- CTRL-LEFT ARROW
Select current "word" SHIFT- CTRL-RIGHT ARROW
Select preceding line SHIFT UP ARROW
Select current line SHIFT DOWN ARROW
Select to beginning of file SHIFT CTRL-PGUP
Select to end of file SHIFT -CTRL-PGDN
Insertion Commands
Insert text from Clipboard SHlFT-lNS
Insert line below current line CTRL-B

Insert line above current line CTRL-N
Insert line deleted using CTRL-Y SHIFT-INS
Insert tab at current cursor position TAB

or
CTRL-1
Copy selected text to Clipboard CTRL-INS
Deletion Commands
Delete character at current cursor position DEL
or
CTRL-G
Delete preceding character BACKSPACE
or
CTRL-H
Delete to end of current word CTRL-T
Delete current Hne CTRL-Y
Delete to end of current line CTRL-Q Y
576 Using QuickC
Delete selected text without

saving in Clipboard del
™
Delete selected text, saving in
Clipboard shift dpi
Delete control character
.^ ^
CTKL-P<character>
Miscellaneous Commands
Toggle between overtype and
insert modes
INS
or
CTRL-V
Mark section of text
CTRL-K
Jump to marked section of text
I
1
CTRL-Q 1
Find matching left brace
I I
CTRL-1
Find matching left bracket
CTRL-[
Find matching left angle bracket
Find matching
CTRL<
left parenthesis
CTRL-(
Find matching right brace
CTRL-1
Find matching right bracket
CTRL-]
Find matching right angle
bracket CTRL->
Find matching right parenthesis
CTRL-)
Move to next tabstop
TAB
Move to previous tabstop
SHIFT-TAB
Menu Commands
StkCmls'rr""
v<!uickC
^^^^° — -d «P^-ns '^^ available through
menus. These commands are
grouped by menu.
Files Menu (alt-f)

The File menu
serves to create, open, and
save files of various sorts It
includes m,scellaneous options also
for gettmg access to DOS
and" nmlng 1 file
File Manipulation Commands

Create new file ALT-F N
Open existing file ALT-F O
Open file edited before current file F2
or
ALT-F F
Merge specified file into work file at current
cursor location ALT-F M
Save current file ALT-F S
Save current file under a new name, leaving
original file intact ALT-F A
Program List Commands The following commands let you create, mod-
ify,and delete program list files, which contain the names of all the source files
that make up a large program.
Create a program list for current file ALT-F L

Edit program list for current file ALT-F E
The following options and commands are available when either of
the preceding options has been set. That is, the following assume either
ALT-F L or ALT-F E.
File name for program list (.mak) file <file name>
Once QuickC has created or opened the specified program list file,
the following commands can be used:
File name to be added to program list <file name>

Add file name to list, if not present, or
remove name from list, if present RETURN
Select Add/ Remove option, if not currently
selected ALT-A
Clear program list ALT-C
Save program list ALT-S
Clear, or delete, program list for current file ALT-F C
578 Using QuickC
Miscellaneous File Commands

Print current file
„ A.-rt.D
ALT-F P
Suspend QuicicC, exit temporarily to DOS shell alt-F D
Edit Menu (alt-e)
This menu makes h possible to modify the contents of the

working file and
possibly of other files as well.
Clear, or delete, text; do not copy to DEL

Clipboard
or
ALT-E E
Cut, or delete, text; copy text to
Clipboard SHIFT-DEL
or
ALT-E T
Copy text to Clipboard; do not delete from file CTRL-INS
ALT-E C
Paste text from Clipboard to
Target (requires SHIFT-INS
text in Clipboard)
or
ALT-E P
Make working file read only
ALT-E R
Undo last action on current line
ALT-BACKSPACE
or
ALT-E U
View Menu (Ait-v)
This menu lets you see various files associated

with your current program file
It also lets you change the way QuickC appears
on your screen.
View program source

a file (that is, a file on the
program list)
ALT-V S
View an include file for the current program
ALT-V I
View display format options
ALT-V O
View output screen F4

or
ALT-v T
Open/ Close Error window ALT-v E
Search Menu (alt-s)

This menu letsyou find and modify specified text, find the definition of a
function in the source file, and so on.
Find specified text ALT-S F

Find and change specified text ALT-S C
The following all work with the preceding options. Each of the
following options toggles:
Require self-standing word alt-w
Require uppercase or lowercase matching ALT-M
Regular Expression ALT-R
The following commands assume the ALT-S C option has been

specified:
Switch to Change To text box ALT-T

Change all occurrences of specified text, with-
out verifying ALT-C
Set default action to skip current occurrence
of text S
Set default action to change current occur-
rence of text C
The following special characters are allowed in regular expressions,
and assume that alt-R has been specified:
Match any single character appearing in

specified position
Match one or more occurrences of the char-
acter preceding * <character>*
Treat the next character literally \
Match if specified phrase appears at end of

line <text>%
Match if specified phrase appears at
beginning of line ^<texl>
580 Using QuickC
Match occurrence of any one of the

characters
between the brackets
[<iext>]
The following are special characters that
can be used within me
wuuiu the
square brackets:
To search any ASCII values between those

for
of the starting and ending
characters, use "-" [<char>.<char>]
To match any characters except those listed
between the brackets, use "^'
in regular
expressions
[^<rm>]
Repeat search for last text found F3
or
Find marked, or selected, text

ALT-S R
CTRL - \
or
ALT-S S
Find function definition
Find next error
ALT-S U
SH1FT-F3
or
Find previous error

ALT-S N
SHIFT-F4
or
ALT-S P
Run menu (alt-r)

This
""''" "' "" ^° "^ P^"^^^'"- '' -"»-- --ing^ your
program It tXri
am if
"mTf It has been stonneH ^
it
stopped c^r^.^ ,^„„„_
fnr some
for reason.
Start compilation and execution

SHIFT-F5
or
ALT-R S
Continue interrupted program
execution F5
or
ALT-R N
Restart interrupted program execution at next
statement ALT-R R
Set compile-time options ALT-R C
Compile-time options include the following. All these options
assume ALT-R C has been selected.
Warning Levels (0 through 3) UP ARROW

or
DOWN ARROW
The following five commands toggle:
Compile for subsequent debugging D

Compile with pointer checks P
Compile with stack checks S
Allow Microsoft language extensions L
Optimize for speed Z
The following four options for specifying output from compilation

process are mutually exclusive:
Compile to object file O

Compile to memory M
Compile to executable file X
Syntax check only Y
In the Compiler option dialog box, the following additional
com-
mands are allowed:
Search in additional paths for include I
or
ALT-I
Specify definitions for current compilation D

or
ALT-D
In the Compiler option dialog box, the following commands, in
addition to Cancel, are valid:
Build program ^
or
RETURN
582 Using QuickC
Compile file
^
Rebuild all „
Set run-time options
^
The following options all assume alt-r O has been selected:
Specify information to be
passed
to program on command line
for use in programs
just being
compiled memory
in
<command line information>
Specify memory to allocate for
global and static program
data
{near data)
c .. ALT-N
specify amount of memory
to
allocate for local variables
(stack) ^LT-S
Debug menu (alt-d)

This menu lets you set up your program to watch
changes in the variables of
?efo7""'^°
The following^-^^'^'^^^^^
options both toggle:
Turn program tracing on/ off

Turn screen swapping on/ off
^^t-d T
^^t-j) S
^"'7'"^ "''''° "' '" '''""^^ '^' P^S^^"^ has been

Deh,I''
Debug compiled with the
compiler option turned on:
Add one or more watch variables

^LT-D A
The following assumes alt-d A has been selected:
Specify the watch variable(s)
to be added
<name>{-Kname>;}
'"" '^'° '^^ '^' ° "'P"' ^"™"' ^he watch variables, using
Jr '"f These
the ffollowing specifiers.
specifiers
f"--
are included after the watch

variable name, and are separated by a comma from this name.
Signed decimal integer d

or
Unsigned decimal integer u

Unsigned octal integer o
Hexadecimal integer x
Real number in floating point format f
Real number in scientific notation format e
Real number in either floating point or
scientific notation format, whichever is
more compact 8
Single character ^
String (characters up to first null character) s
Delete the last watch variable set SHIFT-F2

or
ALT-D E
Clear all watch variables currently set ALT-D L
Toggle breakpoint on/ off F9
or
ALT-D B
Clear all breakpoints currently set ALT-D C
The following keyboard commands will let you step through the program
in the debugger:
Execute the next program statement, tracing

execution through the function F8
Execute the next program statement, tracing

execution around the function FlO
Execute the program until it reaches the current

^'^
cursor position
Execute program to next breakpoint F5
Display the current output screen F4

584 Using QuickC
Compiling and Linlcing Outside

of QuicltC
Get help about qcl commands

/help
Set warning level (/Wl)
Compile only to object
/W0| 1|2|3
file; no linking (off) /c
Debug mode (off)
Pointer checks on (off)
/Zq and Zi and Zd
/Zr
Stack checks off (on)
Syntax check only (off)
/Gs
/Zs
Language extensions off (on)
/Za
Optimize for speed /time (off)
/Ot
Optimize loops (off)
/Ol
Optimize for everything (off)
Specify directories to search
/Ox
for include files
/ Kpath name>
Do not search usual places for
include files (off) /X
Specify definitions for
current program/ run
(none)
Set stack size (0x400) / D<definitions>
I F <hexadecimal
value>
Specify name of executable file to be
created (same
name as main source file, .exe
extension) I Fe<file name>
Specify name of map file
to be created (none)
I Fm<file name>
Specify name of object file
to be created (same
name as main source file, .obj
extension)
5>pecify language underlying
I Fo<fi/e name>
function-calling and
naming conventions used by
program (for
mixed-language programming)
I Gc fortran |
pascal
I
cdecl
\
Memory Models
The following commands let you specify the memory models and library iles
Use small memory model —

one 64K data segment,
one 64K code segment (default for qcl) / AS
Use medium memory model —
one 64K data seg-
ment, multiple 64K code segments (default
forqc) /AM
Use compact memory model — multiple 64K data
segments, one 64K code segment /AC
Use large memory model — multiple 64K data seg-
ments, multiple 64K code segments / AL
Specify size threshold for including data structure
in a new data segment / Gi{<number>}
Emulate 8087 or 80287 for floating point math
(default) / FPi
Generate code for an 8087 or 80287 for floating
point math / FPi87
Use instruction set for 8086 (default) / GO
Use instruction set for 80286 /G2
Pack structure members /Zp
Do not use the default library or libraries /Zl
Controlling the Preprocessor
The following commands let you use the preprocessor and also save files after
the preprocessor has finished with them.
Preserve comments in source files (observe case of
command) /C
586 Using QuickC
Write preprocessed output to a disk file

/P
Write preprocessed output to stdout
/E
Write preprocessed output to disk file
and stdout /EP
Undefine the specified predefined name
/ U <name>
Undefine all predefined names /u
Controlling the Linker
The following commands are available when

linking files to build a program or
library. Note that linker options are not case-sensitive.
For the following
commands, you don't necessarily have to write out the
entire command The
capitalized characters are necessary; the
lowercase characters can be omitted
when referring to the option.
Get help about linker options

/HEIp
Pause for disk swap before writing .exe
/ PAUse
file
Display information during linking
/ Information
Don't prompt if linker can't find a file
/ Batch
Do not search in default libraries
/NODefaultlibrary-
search
Create a map file
/Map
Include line numbers in output file
/LInenumbers
Prepare executable file for use with Codeview
/COdeview
Do not ignore case
/ NOIgnorecase
Create a Quick hbrary
/Quickhb
Make executable file as small and accessible as
possible
/Exepack
Optimize use of far calls to functions /Farcalltranslation
Do not optimize use of far calls to functions
/NOFarcall-
translation
Pack contiguous program segments
/ PACkcode
Do not pack contiguous program segments
/ NOPackcode
Order program segments using Microsoft high-
level language defaults
/ DOsseg
The following linker options let you control various values relating to the
program being compiled.
Maximum number of program segments

(default == 128) / SEgments: <number>
Maximum amount of space needed by
program in memory / <number>
CParmaxalloc;
Maximum stack size (in bytes) / STack^numbery
Features of QuickC
and Microsoft C 5.0
In this appendix we'll briefly mention some of the differences between the
QuickC programming environment and the Microsoft C 5.0 compiler and

auxiliary programs. Each compiler has strengths suited to particular parts of a
software development project. Together, they offer a more powerful develop-
ment tool than either provides alone.
Environment and Performance
In a certain sense, QuickC and the Microsoft C 5.0 compiler represent two
different philosophies of programming environments. The QuickC environ-
ment makes the programming task easy, by collecting the most useful devel-
opment tools in one program, and by providing fast and convenient compila-
tion. The C 5.0 compiler makes the programming product (the resulting
589
590 Using QuickC
program) as fast and efficient as possible. That is, the emphasis in the C 5
compiler is on the program being
built, rather than on the process of building
QuickC an imegrated environment that includes

is
an editor, a compiler
and a debugger, all of which can
communicate with each other This means
that the compiler can tell the
editor the location of compilation
errors in your
program. Because you can switch
among these three programs so easily
QuickC s environment is ideal for the initial
writing and compilation of your
program. If you wish, you can also use
the QuickC compiler independently of
the rest of the environment.
The QuickC compiler is fast, and can build
a list of errors encountered
during compilation. Because the
compiler and editor can communicate
the
compiler ,s an important tool for
correcting errors during the earliest
program
^
development phases.
The C 5.0 compiler,
on the other hand, is a stand-alone
program and
cannot communicate with the editor
The compiler does provide error mes-
sages, including information
about the file location at which the
error was
encountered. The C 5.0 compiler's major
strength is its ability to generate
code
optimized for performance. Whereas
the QuickC compiler, itself
quickly, the C 5.0 compiler can
works
do more to m^k, your program run
quickly
Memory Models and Libraries

Very generally, the features and
capabilities of the Microsoft C 5.0
compiler
form a superset of QuickC's features
with respect to the memory models
that
are supported and the initial
configuration of the Run-Time library
Memory Models
The C 5.0 compiler supports Small, Compact, Medium, Large, and Huge
memory models; QuickC supports all but the
Huge model. While both com-
pilers support mixed memory
models, the C 5.0 compiler also lets you
specify a
customized memory model, as described
in the User S Guide for the
compiler
QuickC defaults to a Medium memory
model; C 5.0 defaults to a Small
Features of QuickC and Microsoft C 5.0 591
memory model. However, both compilers make it easy to specify a different
model when compiling.

The C 5.0 compiler gives you somewhat greater flexibility for naming and
controlling the use of your program modules or segments, another helpful
feature when you are fine-tuning your program's execution.
Libraries
Both compilers include run-time libraries containing the same functions, and
both include a library of graphics functions (graphics.lib). In addition, each
compiler includes a library unique to that compiler. QuickC comes with a
graphics Quick library file (graphics.qlb), which you can tell QuickC to use
if
you want to compile programs that use graphics to memory. The C 5.0
compiler includes an alternate floating point library.
To handle floating point operations in QuickC, you would use a floating
point library (such as mlibfp.lib) and either of two other libraries. One of
these
(87.1ib) requires a math coprocessor, such as the 8087 or 80287;

the other
(em.lib) essentially emulates such a coprocessor to carry out floating

point
operations.
In C 5.0, you can use an alternate math library (such as mlibfa.lib) instead
of the mlibfp.lib and em.lib combination. The alternate math library is much
faster, but accurate, than the emulator library. Using the alternate library
is less
lets you build smaller and faster programs. To go along

with the alternate
library, the C 5.0 compiler also gives you more options for specifying
how
floating point operations are to be handled in the program being created.
QuickC you compile a program to
lets memory and then run the pro-
gram. This compilation process does not include a link phase, so the compiler
does not automatically get access to QuickC's Run-Time library. This means
that only functions buiU into QuickC and those defined in your
program can
be used when compiling to memory.
Ifyou need to use Run-Time library functions but would still like to
compile to memory, you can build a Quick library as we did in Appendix B.
Such a library consists of the Run-Time library functions needed by your
program. A compiler switch lets you tell QuickC to make use of this hbrary
when compiling to memory. Because of their special purpose and format,

QuickC hbraries can be used only with QuickC. You don't need the Quick
library if you compile and link outside the QuickC environment.
'
592 Using QuickC
Debugging
As mentioned
Cod"ev'''?-J
" " '"'""
S?cic7eb:;r'"^^^^^^
the QuickC development
'''' '^^^"^^^ ^"'^ —
tools represent a subset of
-'^^ available
their C5
wh the
The CodeView debugger can
evaluate expressions written
in anv of
several languages,
mcluding C, BASIC, FORTRAN,
and Pascal CodeView
can^ven work w.th Hles that
contain both C and as.mblyTouL
code ^
In addition, the expressions
CodeView can handle are more
han h,,e possible extensive
m the Qu.ckC debugger. For example, Co
handle expressions mvolving evlw can
arithmetic and logical operato
s as welUs the
^^ ''- ^"'?" ^^^"^^-- -'-^^^ -'"^^ the iL-
ZToi\::tf:: e^t
respectively), the array

subscript operator and parentheses([]),
even ook
evenfoôk at thVcT^^":'
the ""'t registers,
contents of machine
"
'^'^"^^ ^"^"^^ "^^"^"^^ '"-»--' and
as the program executes
You
vL Th::r rt''"^' '^^^ ° ^ ^^^^^ ^^^^^ ^^ specific'locat.on:tcode-
rnfTc^Co^vrTr'^''^^"'^'^'^
in fact, CodeView lets
you compare two areas of
memory with a single
"" "'"'''P'^ ^'"'^"^^ ^^^' ^^^mple, source code,

redst'^rs'fnH
registers, 'V^. when
and variables) T'' compiling, and lets break^you set conditional
points, or n.<chpo,n>s.
Watchpoints are breakpoints that
a particu ar expression
become active when
becomes true. Thus, the program
will skip the witch
pointasifnobreakpointhadbeensetthereuntilth'eexVessioleo:^^^^
at which point the
breakpoint becomes active, stopping
execution reaches the watchpoim
the program when
statement. Codevfew also lets you
memory ^ search
''
for specific values.
In short CodeView lets you watch either variables,
memory locations. In some cases, expressions or
you can even change values
memory to try things during the tempoadl'y in
set of commands for
debugging session. Code View
making such changes while debugging
a ri^^^^ Z'S
debugger,
Th QuickC
on the other hand, lets you see fewer things, and only
le s you se^
regular breakpoints. QuickC does let you set watch vaiables, however
Features of QuickC and Microsoft C 5.0 593
CodeView provides support for expanded memory, which enables you to

also lets you
debug programs that were once too large to debug. CodeView
debug library modules.
Finally, CodeView you redirect a debugging session to a file. This can
lets
used to get to a
provide you with a record of the steps and responses you
certain state in the program, such as a bug. After
making the appropriate
session with the
modifications in the program, you can replicate your original
new version of the program to determine whether you've fixed the bug.
While the QuickC debugger is useful for most ordinary purposes
involv-
considerably greater
ing moderately sized programs, CodeView provides
you may
power and flexibility. As your C programs become more complex,
find Code View's additional capabilities useful.
Miscellaneous
QuickC
You can use QuickC's program list facility to provide the information
files save time by
needs to produce a .mak file automatically. Such "make"
recompiled.
making it possible to compile only those files that need to be
The format of the .mak file produced by QuickC is the same
as that
required for the C 5.0 compiler to use the same information

when compiling.
the C 5.0 compiler
This is useful when you want to move large programs up to
for optimization.
is much
QuickC's on-line help facility, accessible with the Fl function key,
in the C
more extensive than the help available when using the /HELP switch
for each of the QuickC
5.0 compiler. QuickC provides command summaries
components, as well as information about each of the Run-Time
library
contrast, the C 5.0 help facility provides information

about the
functions. In
available compiler switches.
Similarities
While there are a number of differences between QuickC and C 5.0, the two
compilers also have many similarities.

594 Using QuickC
QuickC source and object files are completely compatible with the C 5.0
compiler. That means you won't have to change programs developed with
QuickC, if you decide to optimize or recompile them under C 5.0.
If you tell the QuickC compiler to compile your program for use with a
debugger, the compiler produces a file that is compatible with CodeView. This
means you can debug your QuickC programs with CodeView, if you wish.
All of QuickC's compiler and linker switches are identical to the same
options for the C 5.0 compiler.
Finally, both compilers use the same language definition, as you might
expect, since they use the same Language Reference manual. Both compilers
support most features of the Draft Proposed ANSI Standard language defini-
tion, and both include various language extensions. You can tell either com-
piler not to accept code using language extensions if you need to ensure
portability of your program to non-Microsoft environments.

Trademarks
dBASE® Ashton-Tate
dBASE III® Ashton-Tate
DOS™ International Business Machines Corporation
Microsoft® Microsoft Corporation
QuickC® Microsoft Corporation
UNIX® AT&T
WordStar® MicroPro International Corporation
I
)
Index
Sdefine, 119, 124

#else, 132 abs(), 136,516,552
#endif, 133 Absolute value. See abs(

#error, 134 access( ), 548
#nag, 157 acos(), 552
#if, 133 Actual parameters, 127, 2\l-224
#ifdef, 132 Add Watch option, 67
#include, 123 Address, (Zero), 285
#0, 157 Address operator, 158-165

# pragma, 134 Address units, 281
# symbol, 121 Addresses

#undef, 132 allocating, 264
#X, 157 pointers and, 273-274
%E, 154 structures and, 465
%f, 154 Aliases, pointer, 286
%g or %G, 154 And operator (&&), 170
%hd, 153 annuity( ), 353
%hu, 153 annuity deposit( ), 353
%i, 153 ANSI Standard, 7
%ld, 153 Arguments

%lf, 154 command line, 369-390
%lx, 153 passing bad, 227
%u, 153 passing to main( ), 376-382
597
598 Using QuickC
Arithmetic, pointer, 280-284

Breaking out of programs, 342-343
Arithmetic operators, 107-113
Breakpoints, setting, 30
Array subscript operator, 323
Buffered input, 149
Array subscripts, returning, 346
Bugs. See Debugging
Arrays. 290-303
Build Program option, 65
multidimensional, 315-322
C
passing as parameters, 298-303
Call by reference. See Pass by
pointer, 322-326 reference
Call by value. See Pass by value
pointers and, 293-298
Calling QuickC, commands for, 572-573
string, 324-326
callocO, 414, 516
structure, 473
case. 179
ASCII table, 558
Case sensitivity, 83
ASCIIZ strings, 304
Cast operator. 404-407
asinO, 552
ceilO, 553
Assignment operators, 140
Changing text, 60
compound, 182-184
char type, 89
including, 127
Character
Assignment statements, 86
atan( constants, 104
), 552
routines. 537-541
atofO. 411,516
strings. 303-315
atoiO, 315, 411,516
Auto storage Characters
class, 255
blank, tab, and newline, 161
Automatic storage duration, 249
reading, 146-152
B
special search, 59
Binary
whitespace, 161
logical operators, 170-171
char_pos( ), 346
operators, 108
chmod( ), 549
representations, 422
clean__of_char( ), 346
Bit patterns, 422
clearerr( ), 509
Bit-fields, 492-496
Clipboard, copying text to the, 46-50
Bitwise AND operator, 426-430
CodeView, 592-593
Bitwise complement operator, 424-426 Comma operator, 200
Bitwise operators, 421-450
Command line arguments, 369-390
Bitwise OR operator, 431-434
Command line text box, 66
Bitwise XOR, 435-438
Command summary, 571-587
Blank lines, removing, 399
Commands
Blanks, 161
cursor movement, 573-575
Blocks. See Compound statements deletion, 575
Braces, finding matching, 54
editing, 573
Break and continue, 201-204
entering QuickC, 15
Break statement, 201-204
executing DOS, 70
i
Index 599
Commands, continued Date and time, 544

insertion, 575 dbl_mean( ), 345
menu, 576-583 Debug Menu, 66-67
QuickC, 38-72 commands, 582-583
selection, 575 Debug options, 63
Comments, program, 75 table of, 68
Compile errors, 19 Debugger, using the QuickC, 247-249

Compile option, 65 Debugging. 28-38
Compiler instructions, table of, 65 features in QuickC, 592
Compiling, 9-11, 61-66 Decimal numbers, 103
outside QuickC, 584 Declaration and definition, differences
Compound assignment operators, between, 258

182-184 Decrement operator ( ), 184-186
Compound statements, 81, 168, 208 Default keywords and labels, 179-180
defining variables within, 245-247 Defining

compound _interest(), 352 simple data types, 95
Conditional actions, 167 variables, 84-88
Conditional operators, 451-455 delete( ), 345

Constants, 101-106 Delete All Watch option, 67
manifest, 120, 124-127 Deleting text, 49-51
Continuation condition, 187 Deletion commands, 575

Continue option, 61 dir command, 373-376
Continue statement, 201-204 Direct reference, 269
Control constructs, 167-204 Disk space, determining available, 543

Controlling C, 167-204 div(), 517
Conversion routines, 537-541 Do-while loop, 191-192

Copying text, 23 DOS, going temporarily to, 70
commands for, 50 DOS Shell option, 70
cos( ), 554 dos.h, 541-548
Creating files, 39-60 Double constants, 106

Creating programs in QuickC, 14-17 Double precision, 92-95
ctype.h, 536-537 double type, 92-95, 158

Cursor movement Dynamic memory allocation, 403-420
commands, 573-575 E
keystrokes, 41-45 echo command, 372
Cut and paste, 46-50 Edit Menu commands, 576
D Editing
Data types. See also Types commands, summary of 573-576

operations on mixed, 110-113 files, 39-60
simple, 88-98 modes, 39

summary of, 10! Else, missing, 176
600 Using QuickC
End of line, 164 Files, continued

Enumeration types, 500-502 source, 8
Equality operators, 137, 168-169 using dir command with, 374
Error handling, 338-344 working with in QuickC, 14-27

Errors Find options, 56-59
compile, 19 Flags, printf( ), 156
moving the cursor to, 45 Float constants, 106

Escape codes, 79 float type, 90-92
Exe Output option, 37 Floating point

Executable files, 10 numbers, 90-95
exitO, 342-343, 516 type operators, 107
Extern storage class, 257-258 types, 154
floorO, 553
F fopen( ), 392, 507
fabsO, 136 For loop, 193-200

fcloseC ), 393, 507 omitting expressions from, 197
fcloseallO, 510 Formal parameters, 127, 217-224

Features fprintf( ), 157, 507
C programming language, 2-3 fputcO, 150-152,508
Microsoft C 5.0, 589-594 fputcharO, 150-152,508
QuickC, 589-594 fputs( ), 508
feof( ), 399, 507 freeO, 416-417, 516
ferror( ), 399, 507 freopenO, 510
fgetcO, 149-150,507 fscanf( ), 413, 508
fgetcharO, 148-149,507 Function

fgets( ), 398, 507 body, 208
Fibonacci numbers, 365 call operator, 331
Field width, 154-156 calls, 210
File manipulation commands, 577 declaration, 137
File menu, 53-54, 577 declarator, 208
Files, 392-403 heading, 208
creating and editing, 39-60 libraries, building, 559-569

executable, 10 option, 67-68
header, 8, 118, 143-144 Function parameters

include, 143-144 pointers as, 274-280
library, 10 using structures as, 467

manipulating, 53-54 Function prototypes, 227-238
moving around in, 40-45 Function returns, 213-217
moving text between, 45 Functions
object, 10 creating. 205-225
overwriting, 54 defined in this book, 344-358
reading and writing, 145-166 finance oriented, 352-359

Index 601
Functions, continued int type, 89

1/0,506-511 using in a program, 135
library, 135-140 intdos( ), 543
QuickC library, 505-556 Integer constants, 102-104
returning pointers with. 330-338 Integer type operators, 107
returning structures, 469 Integers, 89
string, 309-315, 345-352 Integral types, 153
G Interrupts. DOS, 542, 547
int mean( ), 345

getcO, 149-150,508
io.h, 548-551
getch( ), 137, 146. 152
isalnum( ), 537
getcharO, 148-149
isalpha( ), 537
getcheO, 137, 152
getenv(
isascii( ), 537
), 517
iscntrl( ), 537
gets( ), 306, 310, 398. 508
isdigit( ), 537
H isgraph( ), 537
Header files, 8. 118, 143-144
islower( ), 537
Help, on-line, 39. 573
isprint( ), 537
Hexadecimal numbers, 102-104, 153
ispunct{ ), 537
High-level language, 5
isspace( ), 537
I isupper( ), 537
1/0, 145-166 isxdigit( ), 537
functions, 506-511 Iteration, 167
Identifiers, 81-84 itoaO, 315, 518-519

naming, 82
using to refer to memory locations, K
239 Keystrokes for cursor movement, 41-45
If statements, 172-178 Keywords, 84
dangling, 178 list of, 85
watching, 340
If-else construct, 172-178
Include files, 143-144 labsO, 136,519,552
Increment operator (-H-f-), 184-186 Languages, properties of high- and low-
Indexing in multidimensional arrays, 319 level, 6
Indirect reference, 269 IdivO, 519
Indirection operator, 269 Left shift operator, 439
Initialization during variable definition, Lexicographic ordering. 310

87 Libraries.
Initializing arrays, 292 building stand-alone, 564

Input/ output, 145-166 Microsoft C 5.0, 591
Insert mode. 39 Quick, 559-569

Insertion commands, 575 Library files, 10
602 Using QuickC
Library functions, 135-140 memchrO, 526

creating. 205-225 memcmp( ), 527
QuickC, 505-556 memcpy( ). 527
string, 309-315 memmove( ). 527
Lifetime, storage, 249-251 Memory allocation, 403-420
Linked lists, 479-492 function declaration and, 137
Linker, controlling the, 585 Memory models. 585
Linking, 9-11 Microsoft C 5.0. 590
outside QuickC, 584 memset( ), 528
Lists, linked, 479-492 Menu commands, 576-583
Logical negation operator, 171 Merge option, 49
Logical operators, 170-172 Microsoft C 5.0, similarities to QuickC,
Logical shift, 443 593
long (integer), 99 Mixed types, operations on, 110-113
long int, 153 Modifying programs in QuickC, 18-21
using in a program, 135 Modularity, 3
Loops. 186-204 Modulus operator, 108
Low-level language, 5 monthly _mortgage( ), 353
Lvalues, 264-267 Movement commands, cursor, 573-575
Moving blocks of text, 23, 45-52
M Multidimensional arrays, 315-322
Macro body, 120
Macros, 120
N
parameters with, 127-132
Name length, maximum, 83
Naming rules in C, 82
predefined, 141-142
Negation operator, 171
Main program, 4
Negative numbers, 89
main( ), 4, 75-76
Nested structures. 464
passing parameters to, 376-382
Newline characters, 161
using as program and as function.
non zero( ), 344
370
malloc( 408-414, 516
NULL, 285
),
Manifest constants, 120, 124-127

NULL character, 307
Numbers, octal and hexadecimal,
Mantissa, 91
102-104
Marking text, 45-52
Masks, bit. 427 O
Matching braces, finding, 54 Object files, 10
math.h, 551-555 Objects, 264-267
Matrices, 319 Octal numbers, 102-104
Member lists, 464 On-line help, 39, 573
Members, structure, 458 One's complement, 424
Index 603
Open Last File option. 53 Pointer arrays, 322-326

Open option, 53 Pointer Check option, 63
Operator precedence, 109-110 Pointers, 263-288
Operators arrays and, 293-298

address, 158-165 misguided, 287
arithmetic. 107-113 multidimensional arrays and, 319
bitwise, 421-450 returning with functions, 330-338
compound assignment, 182-184 structures and, 471
conditional, 451-455 Portability, 3
equality. 137, 169-170 Postfix test, 185
evaluating, 273 pow( ). 552

increment and decrement, 184-186 Powers of two. shift operators and, 447
logical, 170-172 Precedence, operator. 109-110. 173
precedence of. 173 Precision, specifying, 154-156
relational. 168-169 Prefix test. 185
shift, 439-450 Preprocessor, C, 119-135
unary. 160 controlling the. 585
Or operator (II). 170 Print option. 70
Overflow conditions, 91 printf( ). 76-79. 153-157, 508
Overtype mode, 39 placeholder types for. 113-114
Program
P character routine, 538-541
Parameters example of structure and features,
actual. 217-224 116-117
array, 298-303 file reader, 396
formal, 217-224 finance function. 353-358

function prototype. 233 I/O function, 511-515
macros with. 127-132 io.h, 550
passing by reference, 278 linked list. 479-492
passing by value, 219 math.h, 555
passing structures as. 467 notepad. 395
passing to main( ). 376-382 replacing tabs and spaces, 401
scope and. 243-245 right shift operator. 444
using pointers as function. 274-280 stand-alone library. 564
Pass by value, 219,244,471 stdlib.h. 521-525
Pass by reference, 278 string function, 348-352
perror( ). 510 string.h, 530-536

Placeholder types. printf( ), 113 structure pointer array, 476
Pointer aliases. 286 using command line arguments,
Pointer arithmetic, 280-284 382-390
!
604 Using QuickC
Program, continued Return (end of input line), 164
using predefined macros, 141-142 Return statement (function), 213-217

Program execution Returned pointers, 330-338
resuming, 61 reverse str( ), 346
tracking, 28 rewind( ), 511
Program list commands, 577 Right shift operator, 443

Program lists, 69-70 Run Menu, 61-66
Program structure, C, 74-79, 115-119 commands, 580-582

Programming, example of C, 3-5 Run-time option, 35-36, 66
Programs
compiling, 61
creating in QuickC, 14-17 safe division( ), 344
debugging, 28-38 scanf( ), 160-164, 413, 509
exiting, 342-343 Scope, 239-248

modifying in QuickC, 18-21 Screen, initial Quick C, 16
steps in creating C, II Screen, scrolling the, 44-45
Prototypes, function, 227-238 Scrolling commands, 44-45

putcO, 150-152,509 Search Menu, 54-56
putch( ), 152 commands, 579
putcharO, 150-152,509 Searching for functions, 67-68
putsO, 310, 509 Seed values, 31
Selection commands, 575

Q
Selection construct, 167
qcstuff qlb, 560
Self-referential structures, 478-492
Quick Libraries, 559-569
Shift operators, 439-450
R short (integer), 99
randO, 137,214-215,517 short int, 153
Reading and writing in C, 145-166 short unsigned int, 153
Real numbers, 90-95 signed char, 99

reallocO, 414-416, 517 signed int, 99
Recursion, 359-368 Simple data types, 88-98
Redirection operators, DOS, 338 summary of, 101
References, direct and indirect, 269 variants on, 99-101

Register storage class, 255-257 Simple statements, 80
Registers, Intel processor, 541 sin( ), 554
Relational operators, 168-169 Source file, 8
remove( ), 511 Spaces, replacing, 401

remove wd( ), 346 Special characters, using in search
rename( ), 549 expressions, 59
Replace text, 56-59 sqrt( ), 552
Reserved words, 2 Stack Check option, 64
Index 605
Standards, C, 7 strrchrO, 529

Start option, 61 strrev( ), 346, 529
Statements, 80-81. See also Compound strset( ), 529
assignment, 86 strstr( ), 529
Static storage, 403 Structure arrays, 473
class, 251-255 Structure member operator, 461
stderr, 338-344 Structure pointer arrays, 473
stdin, 148 Structures, 458-492
stdio.h, 148, 506-509 self-referential, 478-492
stdlib.h, 515-525 strupr( ), 529
stdout, 151 Suppressing values, 164
using in error handling, 338 swap dbl( ), 344
Storage class specifiers, 251-260 swap int( ), 344
Storage classes Switch construct, 178-182
array, 292 Switches, compiler, 65
default, 259 Syntax Check option, 63
Storage, determining available. 417 Syntax, non-prototype, 237
Storage duration, 249-251 systemO, 519
default, 259
strcatO, 312-315, 525

strchr( ), 528 Tab characters, 161
strcmp( ), 310-312, 525 Tabs

strcopyO, 314, 526 inserting, 52
strdup( ), 528 replacing, 401
String Tag name, structure, 458, 463-464
arguments, comparing, 310 tan( ), 554

arrays, 324-326 Text
constants, 105 changing, 60
library functions, 309-315 copying, 23
string.h, 525-536 copying to the Clipboard, 46-50
Strings, 303-315 deleting, 49-51
problems with defining and finding and replacing. 56-59

manipulating, 333-338 marking, 23
using dynamic memory allocation marking and moving, 45-52
with, 419 Text marking commands, 48
strlen( ), 305, 526 Type specifiers. 381
strlwr( ), 528 Typedef storage class. 260

strncatO, 312-315,525 Types
strncmp( ), 310-312, 525 enumeration. 500-502
strncopy{ ), 314, 526 floating point. 153
strpbrk( ), 528 integral. 153

606 Using QuickC
Types, continued
Variables
operations on mixed, 10-113
1
array, 290-303
simple data, 88-98
checking values of, 30
variable, 84
declarations and definitions of. 258
defining, 84-88
defining within compound

U
statements, 245-247
Unary negation operator, 171
duration of, 249-251
Unary operators, 108, 160
global and local, 119, 250
evaluating, 273
initializing during definition, 87
Undo commands. 51
local, 242
ungetcO. 149-150
looping, 189
ungetch( ), 146
passing, 158-165
Unions, 497-500
pointer, 267-274
Unions of structures, 499
returning pointers to local, 338
unsigned char, 99
watching values of, 67
unsigned int, 99
View Menu commands. 576
using to display address values, 272
Visibility, 239-248
void, 238, 409
W
Values, 264-267 Warning Levels. 62
checking intermediate, 359 While loop, 186-191
returned function, 213-217 components of, 188
suppressing, 164 Whitespace, 161
variable, 158-165
Z
Variable types, 84
zero__one_rand( ), 345
OsborRe/McGraw-Hill's
Indispensable
Cemplele Reference Series
1-2 3'; The Complete DOS: The Compleie

Relerence
by Mary Campbell Ok Kris Jamsa
Every Lotus* 1-2-3* com- Has all the answers to all
mand, function, and proce- your questions on DOS

dure IS thoroughly explained through version 3.x. This
and demonstrated In "real- essential resource Is for
world " business applications- everyPC-DOS and MS-
Includes money-saving cou- DOS" user 1045 pages.
pons for add-on products.
S24.95, A Quality Paperback,
892 pages ISBN 07.SBI25S-3
SZ2.95, A Quality Paperback,

ISBN007-a8W0S-l
HBASE III PLUS": The C: The Complete

Compleie Relerence
by Joseph-David Canabis t>v Herbert Schildt
Conveniently organized so For all C programmers,

you can quickly pinpoint all beginners and seasoned
dBASE III* and dBASE III pros, here's an encyclope-
PLUS'" commands, dia of C terms, functions,
functions, and features, codes, and applications.
768 pages. Covers C + -t- and the
proposed ANSI standard.
$22.05, A Quality Paperback,
ISSN a-07-88WI2-4 740 pages
824.85, A Quality Paperback.

isanooj-sanes-i
AVAILABLE NOW ORDER TOLL-FREE

Dealers & Wholesalers 1-800-772-4726
Colleges & College Bookstores 1-800-338-3987
Availatjie in Canada through McGraw-Hill Ryerson Ltd Phone 416-293-1911
« J
^yv; Osborne ^^Gla wHill
m^muL 2600 Tenth Street
nil Berkeley. California 94710
Tradeniar1(s Lotus and 1 -2-3 are registered trademarks of Lotus Development Corp dBASE is a registered trademarlr and
dBASE III PLUS IS a trademartt of Ashton-Tate MS-DOS is a registered trademark of Microsotl Corp
iyi^\^^l X increases your
DOS addressable conventional
memory beyond 640K for
only $195.
Add up to 256K Top off a 512 IBM Add up to 96K above

above 640K for pro- AT's memory to 640K 640K to all programs,
grams like FOXBASE- and add another including PARADOX
and PC/FOCUS. 128K beyond that. and 1-2-3.
Short card works in Run resident Compatible with

the IBM PC, XT, AT, programs like EGA, Network, and
and compatibles. Sidekick above 640K. other memory cards.
Break through the 640 barrier. Installation is a snap.

MAXIT increases your PC's available The MAXIT 256K memory card and
memory by making use of the vacant software works automatically. You
unused address space between 640K don't have to learn a single new com-
and 1 megabyte. (See illustrations) mand.
If you have questions, our customer
Big gain no pain. — support people will answer them, fast.
Extend the productive life of your, IBM MAXIT is backed by a one-year war-
PC, XT, AT or compatible. Build more ranty and a 30-day money-back
complex spreadsheets and databases guarantee.
without upgrading your present soft-
ware. ,,
Order toll free 1-800-227-0900. MAXIT is just $195 plus $4 shipping, and applicable state sales
tax. Buy MAXIT today and solve your PC's memory crisis. Call Toll free 1-800-227-0900 (In Cali-
fornia 800-772-2531). Outside the U.S.A. call 1-415-548-2805. We accept VISA, MC.
MAXIT IS a trademark of Osborne McGraw-Hill IBM is a registered trademark of International Business Machines Corporation, 1-2-3 and
Symphony are registered trademarks of Lotus Development Corporation, Sidekick is a registered trademark of Borland International. Inc;
PARADOX IS a trademark of ANSA Software, FOXBASE+ is a trademark of Fox Software, Hercules is a trademark of Hercules Computer
Technology, XT and AT are registered trademarks
Inc, of International Business Machines Corporation; Compaq is a registered trademark of
Compaq Computer Corporation
iLl;5
o S J=
be _r ^
c C - D X
•
"^
^ U at
S c
>- Q. _ 8 i
2 E
cr5 c: £
(SJ O
«j a CO6 n D n D
c« o
D a
<U O
X =-1; -^
H
IX 6
3 > 3
2 5 .c
e =
" " r •£
c
o
U 3;
c
2 £
3 'C
a ill
3
HJ
=
T3
i
O ">-
:=
aJCQ Qi
lU
X C & ^ S: X 5 D D
'
QA 76. 73 .015 F45 lititi ^-
Feibel, Werner.
Using Qu.ickC
PICATINNY ARSENAL. STINFO DIVISION

Learn QuickC^ prograi in one. Microsoft's speedy new
Quicl<C compiler is fully compatible with version 5.0, so Feibel teaches
you how to program in both environments;
If you're a beginner, you'll find clear instructions that from fundamentals to
intermediate techniques. If you're an experienced progi 11 find out how to
use QuickC's unique features
Using QuickC* thoroughly covers the standard topics of th?C^

Syntax and data types
,, Operators
*: Expressions
^ Functions
Arrays and pointers
:ik^
The preprocessor
Structures, unions, and liles
Numerous examples are used throughout tiP5ook so that you gain a better
understanding of the concepts^^|y
All in all, you'll easily maste^^ôft's impressive compiler with the expert
techniques foun^^WMipMIc^.
Werner Feibel i^^^P^nt and an instructor at Boston University.
Microsoft and^kH^Bngistered trademarks ot Microsoft Corp
ISBN D-D7-afll5T5-S $n.TS

Using QuickC PDF

Uploaded by

Copyright:

Available Formats

Using QuickC PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Using QuickC PDF

Uploaded by

Copyright:

Available Formats

#

may be reproduced or distributed in any form or by any means, or stored in a database or

1234567890 DODO 8987

A Quick Lool( at Quicl( C 13

Simple Types and Operators 73

Preprocessors and Programs 115

Preprocessor Commands 122

5 Reading and Writing in C 145

8 Function Prototypes 227

9 Scope, Lifetime, and Storage Class 239

I 11 Arrays and Strings 289

12 l\/lore on Functions and IVIore Functions 329

13 Command Line Arguments 369

14 Fiies and l\/lemory 391

15 Bit and Other Operators 421

17 QuickC Library Functions 505

A ASCII Codes 557

B Building Libraries in Quicl(C 559

C QuickC Command Summary 571

D Features of QuickC and IVIicrosoft C 5.0 589

Welcome to C and QuickC environment! You can use this book to

language of choice for all sorts of software development Programs

necessary components to create, compile, test, and run C programs.

writing C programs and on how to avoid them.

Program Source Files

This book contains dozens of programs that illustrate C concepts. Many of

Number of copies: Amount enclosed:

Company (if applicable).

City State ZIP Code.

C is an elegantly simple language; it is also a challenge to programmers. At

There is much to like about C: it is small, powerful, and when used

them destroy your data if you are not careful.

On balance, you'll be able to do all sorts of things with C, without getting

Several features make C a very attractive programming language for projects

applications. Because individual modules are built and modified separately,

/• Progreun showing the use of an Include file containing program specific

#include "proginfo.h" /* a file containing various definitions. */

main C) /* the main C program */

The main program, the C function niain( ), simply writes something to

The escape code \n compact way of moving the cursor in a particular

The structure of function main( ) illustrates the format of functions in C.

apparently contradictory properties. C lets you create complex data struc-

Table 1-1. C Measured Against the Properties of High- and Low-level

High-level Languages C Low-level Languages

Structured yes yes Fast

programs on electronic bulletin boards, from user groups, or in

The committee's task is to resolve ambiguities and to make it easier to

The following listing is an example of a source file for a C program:

/* Sample C source file.

#include "proginlo.h" /* file containing program specific information */

main () /* main program function */

int result: /* definition of an integer variable, named result */

il = 7 + 9; /* add 7+9. assign sum to result */

The output from this program is

Finally, the statement,

Compiling and Linking

/• Partial contents of file, proginfo.h. */

#define PROG.NAME "QuickC version 1.0" /* C version name */

meaningful and easy-to-remember names. The compiler substitutes actual

void str_info ( char message. FILE fptr)