C语言第二版：从入门到控制流程

需积分: 4 36 浏览量更新于2024-08-02 收藏 1.19MB PDF 举报

《C语言程序设计（第二版）》是一本深入浅出的C语言教程，该书详细介绍了C语言的基础知识和核心概念。以下是章节概览以及关键知识点： **第1章：C语言入门** - **1.1 Getting Started**: 开篇部分引导读者快速上手C语言，包括环境设置和基本语法。 - **1.2 Variables and Arithmetic Expressions**: 学习变量的声明和使用，以及算术表达式的操作，如整型、浮点型等。 - **1.3 The for statement**: 对循环结构的介绍，特别是for循环，它是控制程序流程的基本工具。 - **1.4 Symbolic Constants**: 讲解符号常量，用于表示固定值，提高代码可读性。 - **1.5 Character Input and Output**: 包括文件复制、字符计数、行计数和单词计数等输入输出操作，涉及文件I/O功能。 - **1.6 Arrays**: 介绍数组，作为数据存储和处理的重要方式，及其索引和操作。 - **1.7 Functions**: 引入函数的概念，是模块化编程的基础，以及参数传递方式（按值传递）。 - **1.8 Character Arrays**: 字符数组的使用，包括字符串处理。 - **1.9 External Variables and Scope**: 外部变量和作用域的规则，帮助理解程序中数据的存储和生命周期。 **第2章：类型、运算符与表达式** - **2.1 Variable Names**: 变量命名规则和命名实践。 - **2.2 Data Types and Sizes**: 数据类型的定义和不同数据类型在内存中的占用空间。 - **2.3 Constants**: 常量的使用，包括整型、浮点型、枚举等。 - **2.4 Declarations**: 变量声明的重要性，以及如何正确地声明不同类型的数据。 - **2.5 Arithmetic Operators**: 算术运算符的运用，如加减乘除、取余等。 - **2.6 Relational and Logical Operators**: 比较和逻辑运算符，用于条件判断和逻辑表达。 - **2.7 Type Conversions**: 类型转换，如何在不同数据类型之间转换。 - **2.8 Increment and Decrement Operators**: 自增和自减运算符，用于修改变量值。 - **2.9 Bitwise Operators**: 位操作符，针对二进制位进行操作。 - **2.10 Assignment Operators and Expressions**: 赋值运算符及其与表达式的结合。 **第3章：控制流** - **3.1 Statements and Blocks**: 语句和块的作用，控制程序的执行顺序。 - **3.2 If-Else**: 条件语句的使用，实现分支逻辑。 - **3.3 Else-If**: 多分支结构，多个条件的检查。 - **3.4 Switch**: switch-case语句，处理多个可能值的情况。 - **3.5 Loops - While and For**: 两种主要循环结构，用于重复执行代码块。 - **3.6 Loops - Do-While**: do-while循环的特点，先执行后判断。 - **3.7 Break and Continue**: 控制循环的退出和跳过当前迭代。 - **3.8 Goto and labels**: 跳转指令，虽然在现代C语言中较少使用，但在此介绍其原理。 **第4章：函数和程序结构** - **4.1 Functions**: 更深入地探讨函数的定义、调用和参数传递。 - **4.2 Program Structure**: 代码组织原则，如何构建模块化的程序结构。通过学习这些章节，读者将掌握C语言的核心要素，能够编写出功能丰富的程序，并为后续进阶学习打下坚实基础。这本书不仅适合初学者，也对有一定经验的程序员提供实用参考。

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

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

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

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

to be a type

big enough to hold any value that

getchar

returns. We can't use

char

since

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

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

, 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)

This has the undesired effect of setting

to 0 or 1, depending on whether or not the call of

getchar

returned end of file. (More on this in

Chapter 2.)

Exercsise 1-6.

Verify that the expression

getchar() != EOF

is 0 or 1.

Exercise 1-7.

Write a program to print the value of

EOF

1.5.2 Character Counting

The next program counts characters; it is similar to the copy program.

#include <stdio.h>

/* count characters in input; 1st version */

main()

{

long nc;

nc = 0;

while (getchar() != EOF)

++nc;

printf("%ld\n", nc);

}

The statement

++nc;

presents a new operator,

, which means increment by one. You could instead write

nc = nc

+ 1

but

++nc

is more concise and often more efficient. There is a corresponding operator

to decrement by 1. The operators

and

can be either prefix operators (

++nc

) or postfix

operators (

nc++

); these two forms have different values in expressions, as will be shown in

Chapter 2, but

++nc

and

nc++

both increment

. For the moment we will will stick to the

prefix form.

The character counting program accumulates its count in a

long

variable instead of an int.

long

integers are at least 32 bits. Although on some machines,

int

and

long

are the same

size, on others an

int

is 16 bits, with a maximum value of 32767, and it would take relatively

little input to overflow an

int

counter. The conversion specification

%ld

tells

printf

that the

corresponding argument is a

long

integer.

It may be possible to cope with even bigger numbers by using a

double

(double precision

float

). We will also use a

for

statement instead of a

while

, to illustrate another way to write

the loop.

#include <stdio.h>

/* count characters in input; 2nd version */

main()

{

double nc;

for (nc = 0; gechar() != EOF; ++nc)

;

printf("%.0f\n", nc);

}

printf

uses

for both

float

and

double

;

%.0f

suppresses the printing of the decimal point

and the fraction part, which is zero.

The body of this

for

loop is empty, because all the work is done in the test and increment

parts. But the grammatical rules of C require that a

for

statement have a body. The isolated

semicolon, called a null statement, is there to satisfy that requirement. We put it on a separate

line to make it visible.

Before we leave the character counting program, observe that if the input contains no

characters, the

while

for

test fails on the very first call to

getchar

, and the program

produces zero, the right answer. This is important. One of the nice things about

while

and

for

is that they test at the top of the loop, before proceeding with the body. If there is nothing

to do, nothing is done, even if that means never going through the loop body. Programs

should act intelligently when given zero-length input. The

while

and

for

statements help

ensure that programs do reasonable things with boundary conditions.

1.5.3 Line Counting

剩余220页未读，继续阅读

lixpeng_1986

粉丝: 0
资源: 3

C语言第二版：从入门到控制流程

The.C.Programming.Language.2Nd.Ed

The C Programming Language 2nd Ed

The C Programming Language 2nd Ed.rar

《C Programming Language》(2nd ed.) 解答集

Implementing.Domain.Specific.Languages.with.Xtext.and.Xtend.2nd.Ed

The c programming language.azw3

programming_principles_and_practice_using_cpp_2nd_ed.rar

Scientific.Computing.with.Python.3.2nd.Ed.epub

C++ 14 Quick Syntax Reference(2nd).pdf 2016第2版

Functional Programming pdf 2018

最新资源