C编程语言英文版教程

需积分: 33 176 浏览量更新于2024-07-17 3 收藏 1.53MB PDF 举报

"The C Programming Language - 英文版，这是一本高清PDF版本的书籍，非扫描制作，质量上乘，无页眉页脚、无水印、无阅读痕迹，适合学习C语言的读者使用。" 《The C Programming Language》是由Brian W. Kernighan 和 Dennis M. Ritchie合著的经典之作，通常被编程者简称为K&R。这本书详细介绍了C语言的基础和核心概念，是学习C语言的必备参考书。在本书的第一章"ATutorialIntroduction"中，作者以简单易懂的方式引导读者入门C语言。章节涵盖了以下几个主要知识点： 1. **GettingStarted**：介绍了如何设置编程环境，以及如何编写和运行简单的C程序。 2. **VariablesandArithmeticExpressions**：讲解了变量的声明与使用，以及基本的算术运算符，如加减乘除和取余。 3. **Theforstatement**：阐述了for循环的结构和用法，这是C语言中常用的循环控制结构。 4. **SymbolicConstants**：提到了符号常量（宏定义）的概念，用于替代硬编码的数值，提高代码的可读性。 5. **CharacterInputandOutput**：讲解了字符输入输出，包括标准输入输出函数`getchar()`和`putchar()`。 6. **FileCopying, CharacterCounting, LineCounting, WordCounting**：通过几个简单的实例，展示了如何实现文件复制、字符计数、行计数和单词计数，这些都是基本的文本处理任务。 7. **Arrays**：介绍了数组的概念，包括一维数组和多维数组的声明和操作。 8. **Functions**：讲述了函数的定义、调用和参数传递，强调了按值传递（Call by Value）的机制。 9. **Arguments-CallbyValue**：详细解释了参数传递的过程，说明了局部变量和全局变量的区别。 10. **CharacterArrays**：特别讨论了字符数组，即字符串的处理，包括字符串常量和字符串拷贝。 11. **ExternalVariablesandScope**：介绍了外部变量（全局变量）的使用和作用域规则。第二章"Types,OperatorsandExpressions"深入讨论了C语言的数据类型、运算符和表达式： 1. **VariableNames**：讨论了变量命名的规则和约定。 2. **DataTypesandSizes**：介绍了基本数据类型（如int、char、float、double等）的大小和表示范围。 3. **Constants**：涵盖了整型、浮点型、字符型等不同类型的常量。 4. **Declarations**：讲解了变量声明的语法，包括类型修饰符和数组声明。 5. **ArithmeticOperators**：列出了所有的算术运算符，包括加、减、乘、除、取余等。 6. **RelationalandLogicalOperators**：涵盖了关系运算符（如==, !=, <, >, <=, >=）和逻辑运算符（如&&, ||, !）。 7. **TypeConversions**：解释了自动类型转换和强制类型转换。 8. **IncrementandDecrementOperators**：讨论了递增和递减运算符（++和--）的用法和特点。 9. **BitwiseOperators**：介绍了位运算符，如按位与、或、异或和位移。 10. **AssignmentOperatorsandExpressions**：涵盖了赋值运算符，以及复合赋值运算符。 11. **ConditionalExpressions**：讲解了三目运算符（条件表达式）的使用。 12. **PrecedenceandOrderofEvaluation**：阐述了运算符的优先级和结合性，以及表达式的求值顺序。第三章"ControlFlow"则涵盖了程序流程控制的相关知识： 1. **StatementsandBlocks**：介绍了语句和代码块的概念，以及如何组织代码结构。 2. **If-Else**：讲解了if和else语句，用于条件判断。 3. **Else-If**：引入了else-if结构，用于处理多个条件分支。 4. **Switch**：详细说明了switch语句，用于多分支选择。 5. **Loops-WhileandFor**：探讨了while和for循环，以及它们在重复执行代码块时的应用。 6. **Loops-Do-While**：介绍了do-while循环，其特点是先执行后判断。 7. **BreakandContinue**：解释了break和continue语句，用于控制循环的跳出和跳过当前迭代。 8. **Gotoandlabels**：虽然不推荐，但书中还是提到了goto语句及其与标签的配合使用。第四章"Functions"继续深入函数的高级话题，包括函数指针、递归、以及更复杂的函数应用。这些章节共同构成了对C语言基础的全面介绍，对于任何希望掌握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 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

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

of != 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)

剩余236页未读，继续阅读

CDqusi

粉丝: 4
资源: 8

C编程语言英文版教程

The C Programming Language第二版中文版.pdf

The C programming Language.pdf

The.C.Programming.Language(C程序设计语言-第2版·新版）中文版和英文版，非扫描清晰文字版，带官方题解

github c语言学习

the c++ programming language 中文版

the c programming language中文版

the c programming language pdf

the c programming language 2nd中文版

kernighan 和 ritchie 在《the c programming language》书里写下的第一个程

the c programming language

最新资源