G
`
`
`
`LANGUAGE
`
`Google Exhibit 1056
`Google v. Parus
`IPR2020-00846
`
`

`

`THE
`
`C
`
`PROGRAMMING
`
`LANGUAGE
`
`Second Edition
`
`

`

`THE
`
`C
`
`PROGRAMMING
`
`LANGUAGE
`
`Second Edition
`
`Brian W. Kemighan 0 Dennis M. Ritchie
`
`AT&T Bell Laboratoriw
`
`Murray Hill, New Jersey
`
`

`

`--__ ..-°-.—.-, .. c-uae u o
`
`The C programing language.
`Includes index.
`1. C (Computer program language)
`Dennis M.
`II. 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. No part of this publication may be reproduwd. 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.
`
`UNIX is a registered trademark of AT&T.
`
`This book was typeset (piclthlieqnltroff -lll8) in Times Roman and Courier by
`the authors. using an Autologic APS-S phototypesetter and a DEC VAX 8550 running
`the 9th Edition of the UNIX' operating system.
`
`Prentice Hall Software Series
`
`Brian Kemighan, Advisor
`
`Printed in the United States of America
`
`1098
`
`ISBN D-lB-llDBEE-B {PBK}
`ISBN D-lB-llDB'NJ-‘l
`
`Prentice-Hall International (UK) Limited, London
`Prentice-Hall of Australia Pty. Limited, Sydney
`Prentice-Hall Canada Inc., Toronto
`Prentice-Hall Hispanoamericana. S.A.. Mexico
`Prentice-Hall of India Private Limited, New Delhi
`
`Preface
`
`Preface to the First Edition
`
`Introduction
`
`Chapter 1. A Tutorial Introduction
`1.1
`Getting Started
`1.2
`Variables and Arithmetic Expressions
`1.3
`The For Statement
`1.4
`1.5
`1.6
`1.7
`1.8
`1.9
`1.10
`
`Symbolic Constants
`Character Input and Output
`Arrays
`Functions
`
`Arguments—Call by Value
`Character Arrays
`External Variables and Scope
`
`Data Types and Sizes
`Constants
`Declarations
`
`Chapter 2. Types, Operators, and Expressions
`2.1
`Variable Names
`2.2
`2.3
`2.4
`2.5
`2.6
`2.7
`2.8
`2.9
`2.10
`2.1 l
`2.12
`
`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
`
`Chapter 3.
`3.1
`
`Control Flow
`Statements and Blocks
`
`

`

`pinyin-Publication om
`
`rograrn language)
`
`I. Ritchie,
`
`88-5934
`
`:11 Telephone Laboratories. Incorporated.
`
`of this publication may be reproduced. stored in a retrieval
`I 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
`
`ix
`
`Itblieqnlttoff -ms) in Times Roman and Courier by
`gic APS-S phototypesetter and a DEC VAX 8550 running
`
`Chapter I. A Tutorial Introduction
`1.1
`Getting Started
`1.2
`Variables and Arithmetic Expressions
`L3
`The For Statement
`1.4
`1.5
`L6
`1.7
`1.8
`1.9
`1.10
`
`Symbolic Constants
`Character Input and Output
`Arrays
`Functions
`
`Arguments—Call by Value
`Character Arrays
`External Variables and Scope
`
`Data Types and Sizes
`Constants
`Declarations
`
`Chapter 2. Types, Operators, and Expressions
`2.1
`Variable Names
`2.2
`2.3
`2.4
`2.5
`2.6
`2.7
`2.8
`2.9
`2.10
`
`Arithmetic Operators
`Relational and Logical Operators
`Type Conversions
`Increment and Decrement Operators
`Bitvvise Operators
`Assignment Operators and Expressions
`
`

`

`liscuss 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
`its 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 common interface
`This library is defined by the ANSI standard and is
`all machines that support C, so programs that use it
`:r operating system access can be moved from one sys-
`
`l 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-
`
`1 language reference manual. The official statement of
`s of C is the ANSI standard itself. That document,
`
`most for compiler writers. The reference manual here
`‘ the language more concisely and without the same
`t B is a summary of the standard library, again for
`renters. 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 language in 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 standard library.
`This approach has its drawbacks. Most notable is 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 drawback is 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
`Chapter 2.
`
`1 . 1 Getting Started
`
`

`

`A TUTORIAL INTRODUCTION
`
`CHAPTER I
`
`SECTION 1.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 . 1»
`
`main”
`{
`
`printfl "hello, wor1d\n") ;
`
`l
`
`Just how to run this program depends on the system you are using. As a
`specific example, on the UNIX operating system you must create 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
`
`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 you are at 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.
`main will usually call other functions to help perform its job, some that you
`wrote, and others from libraries that are provided for you. The first line of the
`program,
`#include <stdio . h>
`
`the standard input/output
`to include information about
`tells the compiler
`library; this line appears at the beginning of many C source files. The standard
`
`
`
`#include <stdio.h>
`
`include informatic
`
`main( )
`
`{
`
`}
`
`defim
`that rec
`
`statements of ma:
`
`printfl "hello, wor1d\n");
`
`main calls
`to print thl
`\n represe
`
`The first C program.
`
`
`example, main is defined to be a function that expect:
`indicated by the empty list
`( ).
`The statements of a function are enclosed in braces
`contains only one statement,
`
`printfl "hello, wor1d\n" ) ;
`
`A function is called by naming it, followed by a parent]
`so this calls the function printf with the argumen
`printf is 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 the string is C notation for the i
`when printed advances the output to the left margin I
`leave out the \n (a worthwhile experiment), you will I
`advance after the output is printed. You must use ‘
`character in the printf argument; if you try somethini
`
`printfl "hello, world
`I);
`
`

`

`CHAPTER I
`
`SECTION 1.:
`
`GETTING STARTED
`
`7
`
`it successfully, load it, run it, and find out where your
`2 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, wor1d\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. Asia
`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 as .out by typing the command
`
`lee will be different; check with a local expert.
`rations about the program itself. A C program, what-
`f functions and variables. A function contains state-
`computing operations to be done, and variables store
`computation. C functions are like the subroutines and
`the procedures and functions of Pascal. Our example [8
`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 empty list
`( ).
`The statements of a function are enclosed in braces U. The function main
`contains only one statement,
`
`printfl "hello , wor1d\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, wor1d\n".
`printf is a library function that prints output, in this case the string of char-
`acters between the quotes.
`is
`like "hello, wor1d\n",
`A sequence of characters in double quotes.
`called a character string or string constant. For the moment our only use of
`character strings will be as arguments for printf and other functions.
`The sequence \n in 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 something like
`
`printfl "hello, world
`
`

`

`8
`
`A TUTORIAL INTRODUCTION
`
`CHAPTER I
`
`SECTION 1.2
`
`VARIABLES AND I
`
`#include <stdio.h>
`
`min”
`I
`
`printf("hello, ")3
`print£('world");
`print£(“\n"):
`
`l
`
`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 backslash itself. There
`is a complete list in Section 2.3.
`
`Exercise l-l. Run the “hello, world” program on your system. Experiment
`with leaving out parts of the program, to see what error messages you get. D
`
`Exercise 1-2. Experiment to find out what happens when printf‘s argument
`string contains \c, where c is some character not listed above. U
`
`1.2 Variables and Arlthmetlc 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
`40
`4
`60
`15
`80
`26
`100 37
`120 48
`140 60
`160 71
`180 82
`200 93
`220 104
`240 115
`260 126
`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
`II upper limit s/
`/§ step size s/
`
`fahr = lower;
`{
`while (fahr <= upper)
`celsius = 5 » (fahr~32) / 9;
`printf("%d\t%d\n", fahr, eels
`fahr : fahr + step;
`
`}
`
`The two lines
`
`/e print Fahrenheit—Celsius table
`for fahr = O, 20, ..., 300 s/
`
`are a comment, which in this case explains briefly w
`characters between /* and s/ are ignored by the <
`freely to make a program easier to understand. C
`where a blank or tab or newline can.
`
`In C, all variables must he 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 -l
`32-bit ints. A float number is typically a 32-bi‘
`significant digits and magnitude generally between a‘
`C provides several other basic data types besides
`
`

`

`CHAPTER I
`
`SECTION [.2
`
`VARIABLES AND ARITHMETIC EXPRESSIONS
`
`9
`
`risents only a single character. An escape sequence like
`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 backslash itself. There
`
`“hello, world” program on your system. Experiment
`)f the program, to see what error messages you get. El
`
`ent to find out what happens when printf's argument
`:re c is some character not listed above. El
`
`Arithmetic Expresslons
`
`uses the formula 'C - (5/9)(‘F-32) to print the follow-
`L temperatures and their centigrade or Celsius equivalents:
`
`#include <stdio.h>
`
`/s print Fahrenheit-Celsius table
`for fahr = 0, 20,
`..., 300 s/
`mainl)
`{
`
`int fahr. celsius;
`int lower, upper, step;
`
`lower = 0,
`upper = 300;
`step = 20;
`
`/! lower limit of temperature table s/
`/s upper limit 9/
`I» step size s/
`
`fahr = lower;
`{
`while (fahr <= upper)
`celsius = 5 s (tent-32) / 9;
`printf("%d\t%d\n", fahr, celsius);
`fab: = fahr + step;
`
`}
`
`The two lines
`
`/s print Fahrenheit-Celsius table
`for fahr = O, 20, ..., 300 s/
`
`are a comment, which in this case explains briefly what the program does. Any
`characters between /s and s/ 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 and a list 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 means floating 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 number is typically a 32-bit quantity, with at least six
`
`

`

`
`
`
`retmthemanofwhichwewillmeetiuduecourse.
`Computation in the temperature conversion program begins with the assign.
`men: statements
`loose: I 0;
`upper I 300:
`step I 20;
`lab: I lover:
`
`
`
`
`
`
`
`
`
`
`
`
`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 output line: this is the purpose of the while loop
`while (Ian: <I 11990!)
`{
`
`individual statements are ter-
`
`)
`if
`The while loop operates as follows: The condition in parentheses is tested.
`it is true (tabs: is lea 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 (tahr exceeds
`upper) the loop ends. and execution continues at the statement that 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
`m1.‘1<j)
`1.291;
`
`put unli
`
`tion 7.4
`output.
`The:
`The sin
`right-ju
`ment w
`For ins1
`
`toprinl
`inafie
`
`the Cl
`about
`floatin
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`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 makins Wins 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 eelaius by the statement
`
`
`celeiua I 5 s (false-32) I 9:
`
`The reason for multiplying by S and then dividing by 9 instead of just multiply-
`ing by 5/9 is that in C. as in many other languages. integer division inmates:
`
`any fractional part is discarded. Since 5 and 9 are integers. 5/9 would be
`
`truncatedtomosndaoalltheCelsiustemperatureswouldbereportedsszero.
`
`
`
`
`

`

`
`
`also arrays.
`auctions that
`
`l the assign-
`
`=nts are ter-
`
`a loop that
`
`If
`is tested.
`)p (the three
`e-tested. and
`ah: exceeds
`t follows the
`tee.
`in braces. as
`a in
`
`to while by
`: at a glance
`s the logical
`1 how a pro-
`ograms easy
`her line. and
`meets is less
`.osen one of
`,ently.
`ius tempera-
`ment
`
`SECTION I2
`
`VARIABLE AND ARITHMETIC WIONS II
`
`This example also shows a bit more of how print: 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
`as indicating where one of the other (second. third. ...) arguments is to be substi-
`tuted..and in what form it is to be printed. For instance. 36d specifies an integer
`argument. so the statement
`print“ 'l‘d\th\n' . tahr. celeiue) ;
`
`causes the values of the two integers fahr and celeiue to be printed. with a
`tab (\t) between them.
`Each as construction in the first argument of print: 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. printf is not part of the C language; there is no input or 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 print: is defined in the ANSI standard. however. so its properties should be
`the same with any compiler and library that conforms to the standard.
`In order to concentrate on C itself. we won‘t tall: much about input and out-
`put until Chapter 7.
`ln particular. we will defer formatted input until then.
`If
`you have to input numbers. read the discussion of the function ecanf in Sec-
`tion 7.4. scent is like printe. 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 output isn't very pretty because the numbers are not
`right-justified. That‘s easy to fix; if we augment each Xd in the print-1 state-
`ment with a width. the numbers printed will be right-justified in their fields.
`For instance. we might say
`printfl'de mm'. tabs. celaiua);
`
`to print the first number of each line 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.
`
`

`

`sacrum
`
`Width
`numhe
`the den
`the nu]
`
`Amom
`chars:
`
`table.
`
`1.3
`
`Let‘s
`
`n A ruroaw. INTRODUCTION
`
`manual
`
`Include «use.»
`lo print emanate-custa- table
`for (ah: I 0. 20.
`.. .. 300; floating-point version 0/
`natal)
`i
`
`float tahr. celaiua;
`int: lever, upper. step:
`
`l
`
`l
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`and the test
`
`
`
`while (Ian: «I am!)
`
`
`also work in the natural way—the int: is converted to float: before the opera-
`
`
`tion is done.
`The print: conversion specification $3.0! says that a floating-point
`
`
`number (here take) is to be printed at least three characters wide. with no
`
`
`decimal point and no fraction digits. $6. 1: describes another number
`
`
`(calaiue) that is to be printed at least six characters wide. with 1 digit after
`
`
`the decimal point. The output looks like this:
`
`Is lover 11-1: of taupetatute table a]
`In upper 11.1: s/
`la step size a/
`
`lover.- I 0;
`upper I 300:
`step I 20;
`lab: - lower:
`while (tan: 0 upper) (
`eel-toe I (5.0/9.0) I (fans-32.0):
`printfl'fl.“ $6.1£\n'. tahr, celeiua);
`tahr I (an: 0 step;
`
`that {am- and calaiua 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 truheate it to zero. A decimal point in a constant indi-
`cates that it 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 tam-32. the 32 would he automati-
`cally convened to floating point. Nevertheless. writing floating-point constants
`with explicit decimal points even when they have integml 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
`to!!! - lover:
`
`
`
`

`

`
`
`CHAPTER!
`
`version a/
`
`re table a/
`
`celaiua are
`Len in a more
`:rsion because
`constant indi-
`tted because it
`
`eration is per-
`rand and one
`g point before
`I be automati-
`noint constants
`es emphasizes
`
`3 point are in
`
`'ore the opera-
`
`floating-point
`wide. with no
`
`sscnou 1.:
`
`THE ma STATEMENT
`
`I:
`
`o
`20
`so
`
`-17.8
`-6.7
`4.4
`
`Width and precision may be omitted from a specification: X6£ says that the
`number is to be at least six characters wide; X. 2: specifies two characters after
`the decimal point, but the width is not constrained: and Kt merely says to print
`the number as floating point.
`as
`print as decimal integer
`it“
`print as decimal integer. at least 6 characters wide
`It
`print as floating point
`are:
`print as floating point. at least 6 characters wide
`x. 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
`Among others. prints also recognizes tie for octal, Xx for hexadecimal. “c for
`character. its for character string. and ’0‘ for is itself.
`
`Exercise l-3. Modify the temperature conversion program to print a heading
`above the table. U
`
`Exercise 1-4. Write a program to print the corresponding Celsius to Fahrenheit
`table. El
`
`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 «£610.!»
`
`/. print: Fahrenheit-Celsius table a!
`saint)
`'
`(
`
`int tent;
`
`talu- - tab: + 20)
`for (fab: - 0: fish: <- 300;
`printfl'x3d X6.1£\rt". Eahr. (5.0/9.0)oifahx-32i);
`
`i
`
`This produces the same answers. but it certainly looks different. One major
`change is the elimination of most of the variables; only £ahr remains. and we
`have made it an int. The lower and upper limits and the step size appear only
`
`

`

`The C Programming Language
`Second Edition
`
`Brian W. Kernighan/Dennis M. Ritchie
`
`From the Preface
`
`We have tried to retain the brevity of the first edition. C is not a big language, and it
`is not well sewed by a big book. We have improved the exposition of critical
`features, such as pointers. that are central to C programming. We have refined 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.
`
`As we said in the preface to the first edition. C “wears well as one‘s experience with
`it grows.“ With a decade more experience. we still feel that way. We hope that this
`book will help you to learn C and use it well.
`
`3‘.
`
`Also available from Prentice Hall:
`SECOND EDITION
`
`THE C ANSWER BOOK
`Solutions to the Exercises in
`
`The C Programming Language. second edition
`by. Brian W. Kcrnighan 8: Dennis M. Ritchie
`
`CLOVIS L. To'NDO
`
`SCOTT E GIMPEL
`
`PTR Prentice Hall, Englewood Cliffs, New Jersey 00632
`
`