C编程语言教程：第1-3章概要

需积分: 3 62 浏览量更新于2024-07-27 1 收藏 2.77MB PDF 举报

"The C Programming Language, 2nd edition, 是一本经典的C语言学习书籍，适合初学者入门。" 本文将详细解析《C Programming Language》的第二版中的关键知识点，涵盖预览、章节概要以及一些核心概念。首先，本书的前言介绍了作者对C语言的理解及其在编程教育中的地位。第一版前言则可能阐述了当时编写这本书的背景和目的，对于理解C语言的历史和发展有一定帮助。接着，第一章“ATutorialIntroduction”（教程介绍）是学习C语言的基础。它从以下几个方面展开： 1.1 Getting Started：这部分引导读者了解如何设置环境并开始编写C程序。 1.2 Variables and Arithmetic Expressions：讲解了变量的定义与基本算术运算表达式。 1.3 The for statement：深入讲解循环控制结构之一的for循环。 1.4 Symbolic Constants：介绍了常量的使用，如#define宏定义。 1.5 Character Input and Output：涵盖了字符输入输出的基本操作，如标准输入输出函数。 1.5.1 File Copying：展示了读写文件的基本操作，如文件复制。 1.5.2 Character Counting：如何统计文件中的字符数量。 1.5.3 Line Counting：计算文件中的行数。 1.5.4 Word Counting：实现单词计数功能，这是许多编程课程的经典练习。 1.6 Arrays：介绍数组的概念，包括一维和多维数组。 1.7 Functions：讲解函数的定义、调用以及参数传递。 1.8 Arguments - Call by Value：说明函数参数传递时的值传递机制。 1.9 Character Arrays：讨论字符数组，特别是字符串的处理。 1.10 External Variables and Scope：外部变量的作用域和生命周期。第二章“Types, Operators and Expressions”关注数据类型、运算符和表达式： 2.1 Variable Names：定义变量命名的规则和约定。 2.2 Data Types and Sizes：介绍C语言中的各种数据类型及其占用内存的大小。 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：赋值运算符及其在表达式中的应用。 2.11 Conditional Expressions：三元条件运算符的使用。 2.12 Precedence and Order of Evaluation：运算符优先级和求值顺序，决定表达式的计算方式。第三章“Control Flow”主要探讨程序流程控制： 3.1 Statements and Blocks：语句和代码块的概念，以及它们在程序中的组织方式。 3.2 If-Else：讲解if条件语句及其与else的结合使用。 3.3 Else-If：介绍else-if结构，用于处理多个条件分支。 3.4 Switch：switch语句，用于基于不同条件执行不同代码块。 3.5 Loops - While and For：讲解while和for循环，循环控制的重要工具。 3.6 Loops - Do-While：do-while循环，保证至少执行一次循环体。 3.7 Break and Continue：break和continue语句，用于提前退出循环或跳过当前循环迭代。 3.8 Goto and labels：goto语句和标签，尽管不常用，但了解其工作原理是必要的。第四章“Functions and Program Structure”可能继续深入探讨函数的高级特性和程序结构，包括函数的递归调用、作用域规则、头文件的使用、程序模块化等。《The C Programming Language》是一本全面介绍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页未读，继续阅读

sophate

粉丝: 0
资源: 2

C编程语言教程：第1-3章概要

《the c programming language》(CLH)

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

the c programming language

The C programming Language

the C programming language

一个C-S模版，该模版由三部分的程序组成

Android -「安卓端」 广告配音工具用于语音合成助手/自媒体配音/广告配音/文本朗读

基于java的网络教学平台设计与实现.docx

Go 语言开发的web系统脚手架, 前后端分离, 仅包含项目开发的必需部分, 基于角色的访问控制(RBAC), 分包合理, 精简易于扩展 后端Go包含了gin、 gorm、 jwt和casb.zip

IBM发布2024年AI实际应用报告: 探讨AI引领者成功之道

最新资源

Android -「安卓端」广告配音工具用于语音合成助手/自媒体配音/广告配音/文本朗读

Go 语言开发的web系统脚手架, 前后端分离, 仅包含项目开发的必需部分, 基于角色的访问控制(RBAC), 分包合理, 精简易于扩展后端Go包含了gin、 gorm、 jwt和casb.zip