C语言程序设计——经典教程

4星 · 超过85%的资源需积分: 10 153 浏览量更新于2024-07-28 收藏 548KB PDF 举报

"《C语言程序设计》：Dennis M. Retchie的经典之作，深入讲解C语言编程" 《C语言程序设计》是Dennis M. Ritchie与Brian W. Kernighan合著的一本经典书籍，首次出版于1988年，由Prentice-Hall出版社发行，书号分别为0−13−110362−8（平装版）和0−13−110370−9。这本书是学习C语言的权威指南，被广泛称为“K&R”（Kernighan & Ritchie）一书，对全球程序员产生了深远影响。本书内容丰富，涵盖了C语言的基础和高级概念，旨在帮助读者理解和掌握这门强大的编程语言。全书分为多个章节，每个章节都深入浅出地讲解了一个特定的主题。第1章“教程式介绍”作为入门章节，引导读者逐步进入C语言的世界。这一章包括： 1. 开始编程，介绍如何启动和编写简单的程序。 2. 变量和算术表达式，讲解变量的声明和基本的数学运算。 3. for循环，解释如何使用for语句进行迭代操作。 4. 符号常量，介绍如何定义常量并避免硬编码。 5. 字符输入和输出，教授如何读取和打印字符。 6. 文件复制，通过实际例子展示文件处理的基本步骤，如字符计数、行计数和词计数等。第2章“类型、运算符和表达式”深入讨论了C语言的核心元素： 1. 变量名的规则，如何为变量选择合适的名称。 2. 数据类型及其大小，讲解整型、浮点型、字符型等不同类型的表示。 3. 常量的定义，包括数值常量、字符串常量等。 4. 声明语法，如何声明变量和数组。 5. 各种算术运算符，如加减乘除、取余等。 6. 关系和逻辑运算符，用于比较和逻辑判断。 7. 类型转换，如何在不同数据类型之间转换。 8. 自增和自减运算符，用于快速增加或减少变量值。 9. 位运算符，处理二进制位的逻辑操作。 10. 赋值运算符和表达式，说明如何使用赋值操作和复合赋值操作。 11. 条件表达式，用于根据条件选择不同的表达式结果。 12. 运算符优先级和求值顺序，确保正确理解表达式的计算过程。第3章“控制流”探讨了程序执行的流程控制： 1. if-else语句，用于基于条件执行不同的代码块。 2. else-if结构，允许扩展多条件的逻辑判断。 3. switch语句，提供了更灵活的选择结构。 4. while循环，当条件满足时反复执行一段代码。 5. do-while循环，至少执行一次循环体，然后检查条件。这些章节不仅包含详细的理论解释，还提供了丰富的示例代码，帮助读者通过实践来巩固所学知识。通过阅读《C语言程序设计》，读者将能够熟练掌握C语言的基础知识，为后续的软件开发和系统编程打下坚实的基础。

form it is to be printed. For instance, %d specifies an integer argument, so the statement

printf("%d\t%d\n", fahr, celsius);

causes the values of the two integers fahr and celsius to 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 properly by number and type, or you will get wrong answers.

By the way, printf is not part of the C language; there is no input or output defined in C itself. printf is

just a useful function from the standard library of functions that are normally accessible to C programs. The

behaviour of printf 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 don't talk much about input and output 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 Section 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 output

isn't very pretty because the numbers are not right−justified. That's easy to fix; if we augment each %d in the

printf statement 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 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, the Celsius temperatures are not

very accurate; for instance, 0

F is actually about −17.8

C, not −17. To get more accurate answers, we should

use floating−point arithmetic instead of integer. This requires some changes in the program. Here is the

second version:

#include <stdio.h>

/* print Fahrenheit−Celsius table

for fahr = 0, 20, ..., 300; floating−point version */

main()

{

float fahr, celsius;

float lower, upper, step;

lower = 0; /* lower limit of temperatuire scale */

upper = 300; /* upper limit */

step = 20; /* step size */

fahr = lower;

The C programming Language

1.2 Variables and Arithmetic Expressions 16

while (fahr <= upper) {

celsius = (5.0/9.0) * (fahr−32.0);

printf("%3.0f %6.1f\n", fahr, celsius);

fahr = fahr + step;

}

This is much the same as before, except that fahr and celsius are 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 indicates 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 performed. 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 automatically 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;

and the test

while (fahr <= upper)

also work in the natural way − the int is converted to float before the operation is done.

The printf conversion specification %3.0f 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.1f describes another number

(celsius) that is to be printed at least six characters wide, with 1 digit after the decimal point. The output

looks like this:

0 −17.8

20 −6.7

40 4.4

...

Width and precision may be omitted from a specification: %6f says that the number is to be at least six

characters wide; %.2f specifies two characters after the decimal point, but the width is not constrained; and

%f merely says to print the number as floating point.

%6d print as decimal integer, at least 6 characters wide

%f print as floating point

%6f print as floating point, at least 6 characters wide

%.2f print as floating point, 2 characters after decimal point

%6.2f print as floating point, at least 6 wide and 2 after decimal point

Among others, printf also recognizes %o for octal, %x for hexadecimal, %c for character, %s for character

string and %% for itself.

The C programming Language

1.2 Variables and Arithmetic Expressions 17

Exercise 1−3. Modify the temperature conversion program to print a heading above the table.

Exercise 1−4. Write a program to print the corresponding Celsius to Fahrenheit table.

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 Fahrenheit−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 upper limits and the step

size appear only as constants in the for statement, itself a new construction, and the expression that computes

the Celsius temperature now appears as the third argument of printf instead of a separate assignment

statement.

This last change is an instance of a general rule − in any context where it is permissible to use the value of

some type, you can use a more complicated expression of that type. Since the third argument of printf must

be a floating−point value to match the %6.1f, any floating−point expression can occur here.

The for statement is a loop, a generalization of the while. If you compare it to the earlier while, its

operation should be clear. Within the parentheses, there are three parts, separated by semicolons. The first

part, the initialization

fahr = 0

is done once, before the loop proper is entered. The second part is the test or condition that controls the loop:

fahr <= 300

This condition is evaluated; if it is true, the body of the loop (here a single ptintf) is executed. Then the

increment step

fahr = fahr + 20

is executed, and the condition re−evaluated. The loop terminates if the condition has become false. As with

the while, the body of the loop can be a single statement or a group of statements enclosed in braces. The

initialization, condition and increment can be any expressions.

The choice between while and for is arbitrary, based on which seems clearer. The for is usually

appropriate for loops in which the initialization and increment are single statements and logically related,

since it is more compact than while and it keeps the loop control statements together in one place.

The C programming Language

1.3 The for statement 18

Exercise 1−5. Modify the temperature conversion program to print the table in reverse order, that is, from 300

degrees to 0.

1.4 Symbolic Constants

A final observation before we leave temperature conversion forever. It's bad practice to bury ``magic

numbers'' like 300 and 20 in a program; they convey little information to someone who might have to read the

program later, and they are hard to change in a systematic way. One way to deal with magic numbers is to

give them meaningful names. A #define line defines a symbolic name or symbolic constant to be a

particular string of characters:

#define name replacement list

Thereafter, any occurrence of name (not in quotes and not part of another name) will be replaced by the

corresponding replacement text. The name has the same form as a variable name: a sequence of letters and

digits that begins with a letter. The replacement text can be any sequence of characters; it is not limited to

numbers.

#include <stdio.h>

#define LOWER 0 /* lower limit of table */

#define UPPER 300 /* upper limit */

#define STEP 20 /* step size */

/* print Fahrenheit−Celsius table */

main()

{

int fahr;

for (fahr = LOWER; fahr <= UPPER; fahr = fahr + STEP)

printf("%3d %6.1f\n", fahr, (5.0/9.0)*(fahr−32));

}

The quantities LOWER, UPPER and STEP are symbolic constants, not variables, so they do not appear in

declarations. Symbolic constant names are conventionally written in upper case so they can ber readily

distinguished from lower case variable names. Notice that there is no semicolon at the end of a #define

line.

1.5 Character Input and Output

We are going to consider a family of related programs for processing character data. You will find that many

programs are just expanded versions of the prototypes that we discuss here.

The model of input and output supported by the standard library is very simple. Text input or output,

regardless of where it originates or where it goes to, is dealt with as streams of characters. A text stream is a

sequence of characters divided into lines; each line consists of zero or more characters followed by a newline

character. It is the responsibility of the library to make each input or output stream confirm this model; the C

programmer using the library need not worry about how lines are represented outside the program.

The standard library provides several functions for reading or writing one character at a time, of which

getchar and putchar are the simplest. Each time it is called, getchar reads the next input character

from a text stream and returns that as its value. That is, after

The C programming Language

1.4 Symbolic Constants 19

c = getchar();

the variable c contains the next character of input. The characters normally come from the keyboard; input

from files is discussed in Chapter 7.

The function putchar prints a character each time it is called:

putchar(c);

prints the contents of the integer variable c as a character, usually on the screen. Calls to putchar and

printf may be interleaved; the output will appear in the order in which the calls are made.

1.5.1 File Copying

Given getchar and putchar, you can write a surprising amount of useful code without knowing anything

more about input and output. The simplest example is a program that copies its input to its output one

character at a time:

read a character

while (charater is not end−of−file indicator)

output the character just read

read a character

Converting this into C gives:

#include <stdio.h>

/* copy input to output; 1st version */

main()

{

int c;

c = getchar();

while (c != EOF) {

putchar(c);

c = getchar();

}

The relational operator != means ``not equal to''.

What appears to be a character on the keyboard or screen is of course, like everything else, stored internally

just as a bit pattern. The type char is specifically meant for storing such character data, but any integer type

can be used. We used int for a subtle but important reason.

The problem is distinguishing the end of input from valid data. The solution is that getchar returns a

distinctive value when there is no more input, a value that cannot be confused with any real character. This

value is called EOF, for ``end of file''. We must declare c to be a type big enough to hold any value that

getchar returns. We can't use char since c must be big enough to hold EOF in addition to any possible

char. Therefore we use int.

EOF is an integer defined in <stdio.h>, but the specific numeric value doesn't matter as long as it is not the

same as any char value. By using the symbolic constant, we are assured that nothing in the program depends

on the specific numeric value.

The C programming Language

1.5.1 File Copying 20

剩余238页未读，继续阅读

张鸣筝

粉丝: 0
资源: 37

C语言程序设计——经典教程

《the c programming language》(CLH)

The C Programming Language(2nd Edition) 中文完整版PDF

The C programming Language

The C Programming language

the C Programming language

The C programming language

springboot-个性化智能学习系统.zip

微信小程序源码铁路订票平台小程序pf-毕业设计.zip

129) Aardvark - BuddyPress、会员与社区主题 v4.54.zip

springboot-旅游攻略平台.zip

最新资源