C语言英文版教程：从基础到控制流

Programming

Language2

3星 · 超过75%的资源需积分: 16 200 浏览量更新于2024-07-20 收藏 2.92MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

本资源是一份英文版的C语言教程，第二版，旨在为初学者提供系统的学习路径。从第一章开始，作者引导读者逐步掌握C语言的基础知识。在第一章"ATutorial Introduction"中，作者首先介绍了如何入门，包括设置开发环境、理解变量和算术表达式。章节详细讲解了如何使用`for`循环进行迭代操作，以及如何定义和使用符号常量。接下来的部分涵盖了字符输入和输出，涉及文件复制、字符计数、行计数和单词计数等实用技巧，这些都是C程序中处理用户交互的基本技能。数组这一核心概念在第1.6节被深入剖析，帮助读者理解数据结构的组织方式。紧接着，函数是程序设计的关键，1.7节讲解了函数的定义和调用，特别是通过值传递的方式。字符数组和外部变量的作用域也在这一章中得到解释，这对于编写模块化的代码至关重要。第二章深入到C语言的数据类型、运算符和表达式的细节。变量名的命名规则、各种数据类型及其大小、常量的使用、声明语句的规则逐一介绍。随后，从基本的算术运算到比较和逻辑运算，再到类型转换、自增自减和位操作，都是构建高效代码的基础。此外，条件表达式和运算符优先级的了解同样不可或缺。第三章探讨控制流，包括基本的语句和块结构，`if-else`和`else-if`的选择结构，以及`switch`语句的使用。接着是循环结构，包括`while`、`for`和`do-while`的运用，以及如何通过`break`和`continue`来控制循环流程。最后，`goto`语句和标签的使用尽管不常用，但在某些特定场景下仍有所应用。第四章聚焦于函数和程序结构，讲解如何组织代码以实现模块化，并详细阐述函数的参数传递，以及如何设计和调用具有不同功能的函数。这部分内容对于理解和编写大型项目中的复杂程序至关重要。这份英文版C语言教程不仅涵盖了基础语法，还提供了丰富的实践示例和技巧，对学习者而言，无论是初次接触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

!= 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页未读，继续阅读

Singularity_L

粉丝: 0
资源: 2

C语言英文版教程：从基础到控制流

21天学会C语言 英文版 .chm

C语言编程快速入门教程（英文原版）

算法c语言实现（英文版）part1-4

现代编译原理c语言描述 英文版

现代编译原理:c语言描述(英文版)

《数据结构与算法分析c语言描述第二版》答案_英文版

c++ 标准库 第二版英文版

c++ how to program 10th 英文版

浙大版《c语言程序设计实验与习题指导（第3版）》题目集

俄罗斯方块c语言参考文献

c++程序设计语言 英文版 pdf

c语言指针该如何学习

C语言相关的中文参考文献

effective c++ 英文版

c++primer第五版英文版

c语言常见算法在哪看

c++程序设计语言英文版pdf

c++primer英文版

华为c语言编程规范v5.1

安富莱c语言编码规范 pdf

最新资源

21天学会C语言英文版 .chm

现代编译原理c语言描述英文版

c++ 标准库第二版英文版

c++程序设计语言英文版 pdf