`
`THE
`
`DENNIS M.RITCHIE—|;
`
`PROGRAMMING
`LANGUAGE
`
`
`
`Google Exhibit 1056
`Google v. Parus
`IPR2020-00846
`
`
`
`THE
`
`C
`
`PROGRAMMING
`
`LANGUAGE
`
`Second Edition
`
`
`
`THE
`
`C
`
`PROGRAMMING
`
`LANGUAGE
`
`Second Edition
`
`Brian W. Kernighan ¢ Dennis M.Ritchie
`
`AT&TBell Laboratories
`Murray Hill, New Jersey
`
`
`
`TTT ToT ee oe
`The C programming language.
`Includes index.
`1. C (Computer program language)
`Dennis M.
`it. Title.
`1988
`QA76.73.C15K47
`005.13'3
`ISBN 0-13-110370-9
`ISBN 0-13-110362-8 (pbk.)
`
`I. Ritchie,
`
`88-5934
`
`Copyright © 1988, 1978 by Bell Telephone Laboratories, Incorporated.
`All rights reserved. Nopart ofthis publication may be reproduced, stored in a retrieval
`system, or transmitted, in any form or by any means, electronic, mechanical, photocopy-
`ing,
`recording, or otherwise, without
`the prior written permission of the publisher.
`Printed in the United States of America. Published simultaneously in Canada.
`UNIXis a registered trademark of AT&T.
`
`This book was typeset (picitblieqn!trof£ -ms) in Times Roman and Courier by
`the authors, using an Autologic APS-5 phototypesetter and a DEC VAX 8550 running
`the 9th Edition of the UNIX® operating system.
`
`Prentice Hall Software Series
`Brian Kernighan, Advisor
`
`Printed in the United States of America
`
`10
`
`9
`
`8
`
`ISBN Q-13-1103b2-8
`ISBN O-13-110370-9
`
`{PBK}
`
`Prentice-Hall International (UK) Limited, London
`Prentice-Hall of Australia Pty. Limited, Sydney
`Prentice-Hall Canada Inc., Toronto
`Prentice-Hall Hispanoamericana, $.A., Mexico
`Prentice-Hall of India Private Limited, New Delhi
`
`Preface
`
`Preface to the First Edition
`
`Introduction
`
`. A Tutorial Introduction
`Getting Started
`Variables and Arithmetic Expressions
`The For Statement
`Symbolic Constants
`Character Input and Output
`Arrays
`Functions
`Arguments—Call by Value
`Character Arrays
`External Variables and Scope
`
`. Types, Operators, and Expressions
`Variable Names
`Data Types and Sizes
`Constants
`Declarations
`Arithmetic Operators
`Relational and Logical Operators
`Type Conversions
`Increment and Decrement Operators
`Bitwise Operators
`Assignment Operators and Expressions
`Conditional Expressions
`Precedence and Order of Evaluation
`
`2.12
`
`Chapter 3.
`3.1
`
`Control Flow
`Statements and Blocks
`
`
`
`ing-in-Publication Data
`
`rogram language)
`
`I. Ritchie,
`
`88-5934
`
`11 Telephone Laboratories, Incorporated.
`of this publication may be reproduced, stored in a retrieval
`; form or by any means, electronic, mechanical, photocopy-
`the prior written permission of the publisher.
`f America. Published simultaneously in Canada.
`
`Preface
`
`Preface to the First Edition
`
`Introduction
`
`Contents
`
`‘tblieqnitroff -ms) in Times Roman and Courier by
`pic APS-5 phototypesetter and a DEC VAX 8550 running
`
`1?
`
`. A Tutorial Introduction
`Getting Started
`Variables and Arithmetic Expressions
`The For Statement
`Symbolic Constants
`Character Input and Output
`Arrays
`Functions
`Arguments—Call by Value
`Character Arrays
`External Variables and Scope
`
`. Types, Operators, and Expressions
`Variable Names
`Data Types and Sizes
`Constants
`Declarations
`Arithmetic Operators
`Relational and Logical Operators
`Type Conversions
`Increment and Decrement Operators
`Bitwise Operators
`Assignment Operators and Expressions
`
`
`
`jiscuss various aspects of C in more detail, and rather
`Chapter 1, although the emphasis is still on examples
`her than isolated fragments. Chapter 2 deals with the
`rs and expressions. Chapter 3 treats control
`flow:
`e, for, etc. Chapter 4 covers functions and program
`les, scope rules, multiple source files, and so on—and
`rocessor. Chapter 5 discusses pointers and address
`ers structures and unions.
`e standard library, which provides a commoninterface
`This library is defined by the ANSI standard andis
`all machines that support C, so programs that use it
`“r Operating system access can be moved from onesys-
`
`| interface between C programs and the UNIX operat-
`on input/output, the file system, and storage alloca-
`his chapter is specific to UNIX systems, programmers
`find useful material here,
`including some
`on of the standard library is implemented, and sugges-
`
`. language reference manual. Theofficial statement of
`; of C is the ANSI standard itself. That document,
`nost for compiler writers. The reference manual here
`the language more concisely and without the same
`< B is a summary of the standard library, again for
`ienters. Appendix C is a short summary of changes
`In cases of doubt, however, the standard and one’s
`final authorities on the language.
`
`cHAPTER 1: A Tutorial Introduction
`
`Let us begin with a quick introduction to C. Our aim is to show the essen-
`tial elements of the languagein real programs, but without getting bogged down
`in details, rules, and exceptions. At this point, we are not trying to be complete
`or even precise (save that the examples are meant to be correct). We want to
`get you as quickly as possible to the point where you can write useful programs,
`and to do that we have to concentrate on the basics: variables and constants,
`arithmetic, control flow, functions, and the rudiments of input and output. We
`are intentionally leaving out of this chapter features of C that are important for
`writing bigger programs. These include pointers, structures, most of C’s rich set
`of operators, several control-flow statements, and the standardlibrary.
`This approach hasits drawbacks. Most notableis that the complete story on
`any particular language feature is not found here, and the tutorial, by being
`brief, may also be misleading. And because the examples do not use the full
`power of C, they are not as concise and elegant as they might be. We have
`tried to minimize these effects, but be warned. Another drawbackis that later
`chapters will necessarily repeat some of this chapter. We hope that the repeti-
`tion will help you more than it annoys.
`In any case, experienced programmers should be able to extrapolate from the
`material in this chapter to their own programming needs. Beginners should sup-
`plement it by writing small, similar programs of their own. Both groups can use
`it as a framework on which to hang the more detailed descriptions that begin in
`Chapter2.
`
`1.1 Getting Started
`
`
`
`A TUTORIAL INTRODUCTION
`
`CHAPTER1
`
`SECTION1.1
`
`text somewhere, compile it successfully, load it, run it, and find out where your
`output went. With these mechanical details mastered, everything else is com-
`paratively easy.
`In C, the program to print “hello, world”is
`#include <stdio.h>
`
`main( )
`{
`
`printf("hello, world\n");
`
`}
`Just how to run this program depends on the system you are using. As a
`specific example, on the UNIX operating system you mustcreate the program in
`a file whose name ends in “.c”, such as hello.c, then compile it with the
`command
`
`cc hello.c
`If you haven’t botched anything, such as omitting a character or misspelling
`something, the compilation will proceed silently, and make an executable file
`called a.out.
`If you run a.out by typing the command
`a.out
`
`it will print
`
`
`
`#include <stdio.h>
`
`include informatic
`
`main()
`
`{
`
`}
`
`define
`that rec
`statements of ma:
`printf("hello, world\n");
`main calls
`to print thi
`\n represe
`
`Thefirst C program.
`
`
`example, main is defined to be a function that expect:
`indicated by the emptylist ().
`The statements of a function are enclosed in braces
`contains only one statement,
`
`printf("hello, world\n");
`
`hello, world
`On other systems, the rules will be different; check with a local expert.
`Now for some explanations about the program itself. A C program, what-
`ever its size, consists of functions and variables. A function contains state-
`ments that specify the computing operations to be done, and variables store
`values used during the computation. C functions are like the subroutines and
`functions of Fortran or the procedures and functions of Pascal. Our example is
`a function named main. Normally youareat liberty to give functions whatever
`names you like, but “main” is special—your program begins executing at the
`beginning of main. This means that every program must have a main some-
`where.
`mainwill usually call other functions to help perform its job, some that you
`wrote, and others from libraries that are provided for you. Thefirst line of the
`program,
`#include <stdio.h>
`printf("hello, world
`the standard input/output
`tells the compiler
`to include information about
`#'}<
`library; this line appears at the beginning of manyCsource files. The standard
`
`A function is called by namingit, followed by a parent!
`so this calls the function printf with the argumen
`printfis a library function that prints output, in this
`acters between the quotes.
`like '
`A sequence of characters in double quotes,
`called a character string or string constant. For the
`character strings will be as arguments for printf and
`The sequence \n in thestring is C notation forthe:
`when printed advances the output to the left margin
`leave out the \n (a worthwhile experiment), you will|
`advance after the output is printed. You must use °
`character in the printf argument;if you try somethin;
`
`
`
`CHAPTER1
`
`SECTION 1.1
`
`GETTING STARTED
`
`7
`
`it successfully, load it, run it, and find out where your
`. mechanical details mastered, everything else is com-
`
`print “hello, world”is
`
`
`
`#include <stdio.h>
`
`include information about standard library
`
`main()
`
`{
`
`}
`
`define a function named main
`that receives no argument values
`Statements of main are enclosed in braces
`
`printf("hello, world\n");
`
`main calls library function printf
`to print this sequence of characters;
`\n represents the newline character
`
`program depends on the system you are using. As a
`UNIX operating system you must create the program in
`in “.c”, such as hello.c, then compile it with the
`
`anything, such as omitting a character or misspelling
`ion will proceed silently, and make an executable file
`n a.out by typing the command
`
`les will be different; check with a local expert.
`iations about the program itself. A C program, what-
`* functions and variables. A function contains state-
`computing operations to be done, and variables store
`computation. C functions are like the subroutines and
`he procedures and functions of Pascal. Our exampleis
`Normally you are at liberty to give functions whatever
`ain” is special—your program begins executing at the
`is means that every program must have a main some-
`
`ll other functions to help perform its job, some that you
`libraries that are provided for you. The first line of the
`
`The first C program.
`
`
`example, main is defined to be a function that expects no arguments, which is
`indicated by the emptylist ().
`The statements of a function are enclosed in braces {}. The function main
`contains only one statement,
`
`print£("hello, world\n");
`
`A function is called by naming it, followed by a parenthesized list of arguments,
`so this calls the function printf with the argument "hello, world\n".
`printfis a library function that prints output, in this case the string of char-
`acters between the quotes.
`like "hello, world\n", is
`A sequence of characters in double quotes,
`called a character string or string constant. For the moment our only use of
`characterstrings will be as arguments for printf and other functions.
`The sequence \nin the string is C notation for the newline character, which
`when printed advances the output to the left margin on the next line.
`If you
`leave out the \n (a worthwhile experiment), you will find that there is no line
`advance after the output
`is printed. You must use \n to include a newline
`character in the printf argument; if you try somethinglike
`
`printf("hello, world
`
`
`
`8
`
`A TUTORIAL INTRODUCTION
`
`CHAPTER 1
`
`SECTION 1.2
`
`VARIABLES AND/
`
`#include <stdio.h>
`
`main()
`{
`
`printf("hello, ");
`printf ("world") ;
`printf£("\n");
`
`}
`
`to produce identical output.
`Notice that \n represents only a single character. An escape sequence like
`\n provides a general and extensible mechanism for representing hard-to-type
`or invisible characters. Among the others that C provides are \t for tab, \b
`for backspace, \" for the double quote, and \\ for the backslashitself. There
`is a completelist in Section 2.3.
`
`Exercise 1-1. Run the “hello, world” program on your system. Experiment
`with leaving out parts of the program, to see what error messages you get. O
`
`Exercise 1-2. Experiment to find out what happens when printf’s argument
`string contains \c, where c is some character notlisted above. O
`
`1.2 Variables and Arithmetic Expressions
`The next program uses the formula °C = (5/9)(*F—32) to print the follow-
`ing table of Fahrenheit temperatures and their centigrade or Celsius equivalents:
`0
`-17
`20
`-6
`
`280 137
`300 148
`
`#include <stdio.h>
`
`/* print Fahrenheit-Celsius table
`for fahr = 0, 20,
`..., 300 */
`main()
`{
`
`int fahr, celsius;
`int lower, upper, step;
`
`lower = 0;
`upper = 300;
`step = 20;
`
`/* lower limit of
`/* upper limit */
`/* step size */
`
`fahr = lower;
`{
`while (fahr <= upper)
`celsius = 5 * (fahr-32) / 9;
`printf ("%d\t%d\n", fahr, cels
`fahr = fahr + step;
`
`}
`
`The two lines
`
`/* print Fahrenheit-Celsius table
`for fahr = 0, 20, ..., 300 «/
`
`are a comment, which in this case explains briefly w
`characters between /* and */ are ignored by the «
`freely to make a program easier to understand. C
`where a blankor tab or newline can.
`In C, all variables must be declared before the
`beginning of the function before any executable
`announces the properties of variables; it consists of
`variables, such as
`
`int fahr, celsius;
`int lower, upper, step;
`
`The type int means that the variables listed are
`float, which means floating point,
`i.e., numbers
`part. The range of both int and float depend
`using; 16-bit ints, which lie between —32768 and 4
`32-bit ints. A float numberis typically a 32-bi
`significant digits and magnitude generally between a
`C provides several other basic data types besides
`
`
`
`CHAPTER 1
`
`SECTION 1.2
`
`VARIABLES AND ARITHMETIC EXPRESSIONS
`
`9
`
`(put.naa only a single character. An escape sequencelike
`and extensible mechanism for representing hard-to-type
`Among the others that C provides are \t for tab, \b
`the double quote, and \\ for the backslashitself. There
`
`“hello, world” program on your system. Experiment
`of the program, to see what error messages you get. 0
`
`ent to find out what happens when printf’s argument
`re c is some characternotlisted above. 0
`
`#include <stdio.h>
`
`/* print Fahrenheit-Celsius table
`for fahr = 0, 20,
`..., 300 #/
`main()
`{
`
`int fahr, celsius;
`int lower, upper, step;
`
`lower = 0;
`upper = 300;
`step = 20;
`
`/* lower limit of temperature table +*/
`/* upper limit «/
`/* step size */
`
`fahr = lower;
`{
`while (fahr <= upper)
`celsius = 5 * (fahr-32) / 9;
`printf ("%d\t%d\n", fahr, celsius);
`fahr = fahr + step;
`
`}
`
`The twolines
`
`/* print Fahrenheit-Celsius table
`for fahr = 0, 20, ..., 300 «*/
`
`Arithmetic Expressions
`uses the formula °C = (5/9)(° F—32) to print the follow-
`: temperatures and their centigrade or Celsius equivalents:
`
`are a comment, which in this case explains briefly what the program does. Any
`characters between /* and */ are ignored by the compiler; they may be used
`freely to make a program easier to understand. Comments may appear any-
`where a blank or tab or newline can.
`In C, all variables must be declared before they are used, usually at the
`beginning of the function before any executable statements. A declaration
`announces the properties of variables; it consists of a type name andalist of
`variables, such as
`
`int fahr, celsius;
`int lower, upper, step;
`
`The type int means that the variables listed are integers, by contrast with
`float, which meansfloating point,
`i.e., numbers that may have a fractional
`part. The range of both int and float depends on the machine you are
`using; 16-bit ints, which lie between —32768 and +32767, are common,as are
`32-bit ints. A float numberis typically a 32-bit quantity, with at least six
`
`
`
`
`
`10
`ATUTORIAL INTRODUCTION
`CHAPTER |
`
`
`The sizes of these objects are also machine-dependent. There are also arrays,
`structures and unions of these basic types, pointers to them, and functions that
`return them, all of which we will meet in due course.
`Computation in the temperature conversion program begins with the assign-
`ment statements
`lower = 0;
`upper = 300;
`step = 20;
`fahr = lower;
`Individual statements are ter-
`which set the variables to their initial values.
`minated by semicolons.
`Each line of the table is computed the same way, So we use a loop that
`repeats once per outputline; this is the purpose of the while loop
`while (fahr <= upper) {
`
`}
`The while loop operates as follows: The condition in parentheses is tested. If
`it is true (fahr is less than or equal to upper), the body of the loop (the three
`statements enclosed in braces) is executed. Then the condition is re-tested, and
`if true, the body is executed again. When the test becomes false (fahr exceeds
`upper) the loop ends, and execution continues at the statementthat follows the
`loop. There are no further statements in this program, so it terminates.
`The body of a while can be one or more statements enclosed in braces, as
`in the temperature converter, or a single statement without braces, as in
`while (i < j)
`fe 2s iy
`In either case, we will always indent the statements controlled by the while by
`one tab stop (which we have shown as four spaces) so you can see at a glance
`which statements are inside the loop. The indentation emphasizes the logical
`structure of the program. Although C compilers do not care about how a pro-
`gram looks, proper indentation and spacing are critical in making programs easy
`for people to read. We recommend writing only one statement per line, and
`using blanks around operators to clarify grouping. The position of braces is less
`important, although people hold passionate beliefs. We have chosen one of
`several popular styles. Pick a style that suits you, then use it consistently.
`Most of the work gets done in the body of the loop. The Celsius tempera-
`ture is computed and assigned to the variable celsius by the statement
`celsius = 5 * (fahr-32) / 9;
`The reason for multiplying by 5 and then dividing by 9 instead of just multiply-
`ing by 5/9 is that in C, as in many other languages, integer division ¢runcates:
`any fractional part is discarded. Since 5 and 9 are integers, 5/9 would be
`
`the Ce
`about
`floatin
`
`truncated to zero and so all the Celsius temperatures would be reported as zero.
`
`
`
`
`
`also arrays,
`nctions that
`
`1 the assign-
`
`ents are ter-
`
`a loop that
`
`If
`is tested.
`op (the three
`e-tested, and
`ahr exceeds
`t follows the
`tes.
`in braces, as
`isin
`
`ie while by
`! ata glance
`5 the logical
`t how a pro-
`‘ograms easy
`ver line, and
`sraces is less
`osen one of
`ently.
`ius tempera-
`ment
`
`SECTION 1.2
`
`VARIABLES AND ARITHMETIC EXPRESSIONS
`
`I]
`
`This example also shows a bit more of how printf works. printf is a
`general-purpose output formatting function, which we will describe in detail in
`Chapter 7.
`Its first argument is a string of characters to be printed, with each
`% indicating where oneof the other (second,third, ...) arguments is to be substi-
`tuted,.and in what form it is to be printed. For instance, %d specifies an integer
`argument, so the statement
`printf("%d\tX%d\n", fahr, celsius);
`
`causes the values of the two integers fahr and celsiusto be printed, with a
`tab (\t) between them.
`Each % construction in the first argument of printf is paired with the
`corresponding second argument, third argument, etc.; they must match up prop-
`erly by number and type, or you'll get wrong answers.
`By the way, printfis not part of the C language; there is no inputor out-
`put defined in C itself. printf is just a useful function from the standard
`library of functions that are normally accessible to C programs. The behavior
`of printf is defined in the ANSI standard, however,so its properties should be
`the same with any compiler andlibrary that conforms to the standard.
`In order to concentrate on C itself, we won't talk much aboutinput and out-
`put until Chapter 7.
`In particular, we will defer formatted input until then.
`If
`you have to input numbers, read the discussion of the function scanf in Sec-
`tion 7.4. scanf is like printf, except that it reads input instead of writing
`output.
`
`There are a couple of problems with the temperature conversion program.
`The simpler one is that the outputisn’t very pretty because the numbers are not
`right-justified. That's easy to fix; if we augment each %d in the printéstate-
`ment with a width, the numbers printed will be right-justified in their fields.
`For instance, we might say
`printf£("%3d %6d\n", fahr, celsius);
`
`to print the first numberof eachline in a field three digits wide, and the second
`in a field six digits wide, like this:
`0
`-17
`20
`-6
`40
`4
`60
`15
`80
`26
`100
`37
`
`The more serious problem is that because we have used integer arithmetic,
`
`
`
`12.
`
`A TUTORIAL INTRODUCTION
`
`#include <stdio.h>
`
`/» print Fahrenheit-Celsius table
`for fahr = 0, 20, ..-, 300; floating-point version +/
`main()
`{
`
`float fahr, celsius;
`int lower, upper, step;
`lower = 0;
`/* lower limit of temperature table +*/
`upper = 300;
`/* upper limit +/
`step = 20;
`/* step size */
`fahr = lower;
`while (fahr <= upper) {
`celsius = (5.0/9.0) * (fahr-32.0);
`printf ("%3.0f %6.1£\n", fahr, celsius);
`fahr = fahr + step;
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`and thetest
`while (fahr <= upper)
`
`
`also work in the natural way—the intis converted to float before the opera-
`
`
`tion is done.
`
`
`The print£ conversion specification %3.0£ says that a floating-point
`
`
`number (here fahr) is to be printed at least three characters wide, with no
`
`
`decimal point and no fraction digits. %6.1£ describes another number
`(celsius) that is to be printed at least six characters wide, with 1 digit after
`
`the decimal point. The outputlooks like this:
`
`SECTION
`
`Width
`numbe
`the de
`the nu;
`
`Let’s
`
`This
`chan,
`have
`as co
`that
`pri:
`
`
`
`}
`
`}
`that fahr and celsius are
`This is much the same as before, except
`declared to be float, and the formula for conversion is written in a more
`natural way. We were unable to use 5/9 in the previous version because
`integer division would truncate it to zero. A decimal point in a constant indi-
`cates thatit is floating point, however, so 5.0/9.0 is not truncated because it
`is the ratio of two floating-point values.
`If an arithmetic operator has integer operands, an integer operation is per-
`formed.
`If an arithmetic operator has one floating-point operand and one
`integer operand, however, the integer will be converted to floating point before
`the operation is done.
`If we had written fahr-32, the 32 would be automati-
`cally converted to floating point. Nevertheless, writing floating-point constants
`with explicit decimal points even when they have integral values emphasizes
`their floating-point nature for human readers.
`The detailed rules for when integers are converted to floating point are in
`Chapter 2. For now, notice that the assignment
`fahr = lower;
`
`
`
`
`
`
`
`CHAPTER 1
`
`version #/
`
`SECTION 1.3
`
`0
`20
`40
`
`-17.8
`-6.7
`4.4
`
`THE FOR STATEMENT
`
`13
`
`cre table #/
`
`Width and precision may be omitted from a specification: %6£ says that the
`numberis to be at least six characters wide; %. 2£ specifies two characters after
`the decimal point, but the width is not constrained; and %£ merely says to print
`the numberas floating point.
`%a
`print as decimal integer
`x6da
`print as decimal integer, at least 6 characters wide
`KE
`print as floating point
`*6E
`print as floating point, at least 6 characters wide
`%.2£
`print as floating point, 2 characters after decimal point
`%6.2£
`print as floating point, at least 6 wide and 2 after decimal point
`Amongothers, printé£ also recognizes %o for octal, %x for hexadecimal, %c for
`character, %s for characterstring, and %% for%itself.
`Exercise 1-3. Modify the temperature conversion program to print a heading
`abovethe table. O
`
`celsius are
`‘en in a more
`trsion because
`constant indi-
`‘ted because it
`
`eration is per-
`rand and one
`g point before
`1 be automati-
`wint constants
`es emphasizes
`
`g point are in
`
`ore the opera-
`
`floating-point
`wide, with no
`
`Exercise 1-4. Write a program to print the corresponding Celsius to Fahrenheit
`table. 0
`
`1.3. The For Statement
`
`There are plenty of different ways to write a program for a particular task.
`Let’s try a variation on the temperature converter.
`#include <stdio.h>
`
`/* print Pahrenheit-Celsius table «/
`main()
`—
`
`int fahr;
`
`for (fahr = 0; fahr <= 300; fahr = fahr + 20)
`printf£("%3d %6.1f\n", fahr, (5.0/9.0) «#(fahr-32));
`
`}
`
`This produces the same answers, but it certainly looks different. One major
`change is the elimination of most of the variables; only fahr remains, and we
`have made it an int. The lower and upperlimits and the Step size appear only
`
`
`
`The C Programming Language
`Second Edition
`Brian W. Kernighan/Dennis M. Ritchie
`
`From the Preface
`
`Wehavetried to retain the brevity of thefirst edition. C is not a big language, andit
`is not well served by a big book. We have improved the exposition ofcritical
`features, such as pointers, that are central to C programming. We haverefined the
`original examples, and have added new examples in several chapters. For instance,
`the treatment of complicated declarations is augmented by programs that convert
`declarations into words and vice versa. As before, all examples have been tested
`directly from the text, which is in machine-readable form.
`
`Aswesaid in the preface to the first edition, C **wears well as one’s experience with
`it grows.’” With a decade more experience, westill feel that way. We hope thatthis
`book will help you to learn C and use it well.
`
`
`
`Also available from Prentice Hall:
`SECOND EDITION
`
`THE C ANSWER BOOK
`Solutions to the Exercises in
`The C Programming Language, secondedition
`byBrian W. Kernighan & Dennis M. Ritchie
`
`CLOVIS L. TONDO
`SCOTTE. GIMPEL
`
`PTR Prentice Hall, Englewood Cliffs, New Jersey 07632
`
`