C语言经典教程：英文第二版详解

需积分: 13 132 浏览量更新于2024-07-17 收藏 1.31MB PDF 举报

《C Programming Language》英文第二版是一本经典的入门教材，专为学习C语言的学生和开发者设计。尽管是英文版本，但对于有一定英语基础的学习者来说，书中大部分词汇并不构成阅读障碍。该书从基础知识入手，通过逐步深入的方式引导读者掌握C语言的关键概念。 **章节一：教程介绍（A Tutorial Introduction）** 1.1 **入门指南** 开篇部分引导学生如何开始学习，包括如何设置环境、编写和运行简单的程序，让初学者快速上手。 1.2 **变量和算术表达式** 介绍了变量的概念以及如何使用基本的数学运算符进行计算。 1.3 **for循环** 学习控制结构的基础，通过for循环示例演示了重复执行代码块的能力。 1.4 **符号常量** 讲解如何定义和使用预定义的值，如π或e等。 1.5 **字符输入和输出** 包括文件复制、字符计数、行计数和单词计数的实践操作，强化对文件I/O的理解。 1.6 **数组** 介绍数组作为数据结构的基础，演示如何存储和操作多个值。 1.7 **函数** 阐述函数的定义、调用和参数传递方式，以及call-by-value策略。 1.8 **字符数组** 探索字符数组的使用，扩展字符串处理能力。 1.9 **外部变量和作用域** 讨论变量的作用域规则，理解何时何地可以访问特定变量。 **章节二：类型、运算符和表达式** 2.1 **变量命名** 规定有效的标识符命名规则。 2.2 **数据类型和大小** 学习不同数据类型的特性及其在内存中的存储。 2.3 **常量** 阐明如何声明和使用恒定不变的数值。 2.4 **声明** 介绍变量声明的重要性，以及不同数据类型的声明方式。 2.5 **算术运算符** 和其对应的运算行为。 2.6 **关系和逻辑运算符** 用于比较和条件判断。 2.7 **类型转换** 学习如何在不同类型之间进行数据转换。 2.8 **自增和自减运算符** 调整变量值的方法。 2.9 **位操作符** 对二进制位进行处理的工具。 2.10 **赋值运算符和表达式** 讲解常见的赋值操作以及如何创建复杂的表达式。 2.11 **条件表达式** 逻辑运算的结果决定程序流程。 2.12 **优先级和求值顺序** 学习运算符的优先级和如何正确解析表达式。 **章节三：控制流** 3.1 **语句和块** 介绍代码的基本组成单元及其作用范围。 3.2 **if-else** 基本条件分支结构。 3.3 **else-if** 多条件分支处理。 3.4 **switch** 用于根据表达式的值选择不同的代码路径。 3.5 **循环** 包括while和for循环，强调它们的结构和用法。 3.6 **do-while** 循环结构，先执行一次再检查条件。 3.7 **break和continue** 控制循环流程，提前退出或跳过剩余代码。 3.8 **goto和标签** 提供更精细的控制，但通常被认为不推荐在现代C编程中使用。 **章节四：函数和程序结构** 4.1 **函数的定义和调用** 详细解释如何封装功能和复用代码。 4.2 **程序组织** 如何将函数组合成模块化的程序结构。 4.3 **参数传递** 深入理解如何传递和管理函数内的局部变量。 4.4 **指针** C语言中的核心概念，理解如何间接访问和操作内存地址。《C Programming Language》第二版提供了一个系统的学习路径，从基础语法到高级控制结构，帮助读者逐步建立起扎实的C语言编程技能。通过实际操作和理论结合，学习者能够熟练掌握这门语言，并为进一步的软件开发打下坚实基础。

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.

print as decimal integer

%6d

print as decimal integer, at least 6 characters wide

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.

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.

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 tim

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

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 program for copying would be written more concisely by experienced C programmers. In

C, any assignment, such as

c = getchar();

is an expression and has a value, which is the value of the left hand side after the assignment.

This means that a assignment can appear as part of a larger expression. If the assignment of a

character to c is put inside the test part of a while loop, the copy program can be written this

way:

#include <stdio.h>

/* copy input to output; 2nd version */

main()

{

int c;

while ((c = getchar()) != EOF)

putchar(c);

}

The while gets a character, assigns it to c, and then tests whether the character was the end-

of-file signal. If it was not, the body of the

while is executed, printing the character. The

while then repeats. When the end of the input is finally reached, the while terminates and so

does

main.

This version centralizes the input - there is now only one reference to getchar - and shrinks

the program. The resulting program is more compact, and, once the idiom is mastered, easier

to read. You'll see this style often. (It's possible to get carried away and create impenetrable

code, however, a tendency that we will try to curb.)

The parentheses around the assignment, within the condition are necessary. The precedence

!= is higher than that of =, which means that in the absence of parentheses the relational

test != would be done before the assignment =. So the statement

c = getchar() != EOF

is equivalent to

c = (getchar() != EOF)

剩余237页未读，继续阅读

万哥一游

粉丝: 0
资源: 1

C语言经典教程：英文第二版详解

The c programing language

The C++ Programing Language中文特别版

The C Programming Language 第二版 英文版

the c programing language

设字符集为26个英文字母，其出现频度如附件中的频度表所示。编写c语言程序，先构建对应的哈夫曼树，再利用此树对报文 \"the java programing language is my favorit

write a C programing to modify program to ignore any comments that begin with //

对字符串"I like java programing"取字符串"java programing"、"java"及"programing"。用StringTokenizer类实现

use python to programing a garbage classification program

Programing Flow with PEC

windows shell programing pdf

最新资源

The C Programming Language 第二版英文版