C编程语言精华解读

需积分: 0 127 浏览量更新于2024-07-26 收藏 578KB PDF 举报

"C Programming Language英文版入门教程" 《C Programming Language》是由Brian W. Kernighan和Dennis M. Ritchie合著的经典书籍，于1988年由Prentice-Hall出版，书中的内容是关于C语言的基础知识，非常适合初学者。这本书的中文名通常称为《C程序设计语言》，在编程界有着广泛的影响力。本书分为多个章节，逐步介绍了C语言的核心概念和技术： 1. 第一章：教程介绍这部分主要帮助读者快速上手C语言，包括： - 如何开始编写程序 - 变量与算术表达式 - for循环的使用 - 符号常量 - 字符输入与输出 - 并通过几个实际的示例程序（如文件复制、字符计数、行计数和单词计数）加深理解 2. 第二章：类型、运算符和表达式在这一章，作者深入讨论了： - 变量命名规则 - 数据类型及其大小 - 常量 - 声明 - 算术运算符 - 关系和逻辑运算符 - 类型转换 - 自增自减运算符 - 位运算符 - 赋值运算符和表达式 - 条件表达式 - 运算符的优先级和求值顺序 3. 第三章：控制流控制流程是编程中不可或缺的部分，本章涵盖了： - 语句和代码块 - if-else结构 - else-if结构 - switch语句 - while和for循环 - do-while循环 - break和continue语句 - goto语句和标签 4. 第四章：函数和程序结构函数是C语言中模块化程序设计的关键，这一章涉及： - 函数的定义和使用 - 参数传递（按值调用） - 字符数组 - 外部变量和作用域这本书不仅涵盖了C语言的基本语法，还强调了良好的编程实践和清晰的代码结构。对于想要学习或巩固C语言基础的读者来说，这是一本不可多得的教材。通过阅读并实践书中的例子，读者可以逐步掌握C语言的精髓，并为更高级的系统编程打下坚实基础。

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)

This has the undesired effect of setting c 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 nc. 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 %f 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 or 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

The next program counts input lines. As we mentioned above, the standard library ensures that an input text stream appears

as a sequence of lines, each terminated by a newline. Hence, counting lines is just counting newlines:

#include <stdio.h>

/* count lines in input */

main()

{

int c, nl;

nl = 0;

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

if (c == ’\n’)

++nl;

printf("%d\n", nl);

}

The body of the while now consists of an if, which in turn controls the increment ++nl. The if statement tests the

parenthesized condition, and if the condition is true, executes the statement (or group of statements in braces) that follows.

We have again indented to show what is controlled by what.

The double equals sign == is the C notation for ‘‘is equal to’’ (like Pascal’s single = or Fortran’s .EQ.). This symbol is used to

distinguish the equality test from the single = that C uses for assignment. A word of caution: newcomers to C occasionally

write = when they mean ==. As we will see in Chapter 2, the result is usually a legal expression, so you will get no warning.

A character written between single quotes represents an integer value equal to the numerical value of the character in the

machine’s character set. This is called a character constant, although it is just another way to write a small integer. So, for

example, ’A’ is a character constant; in the ASCII character set its value is 65, the internal representation of the character A.

Of course, ’A’ is to be preferred over 65: its meaning is obvious, and it is independent of a particular character set.

The escape sequences used in string constants are also legal in character constants, so ’\n’ stands for the value of the newline

character, which is 10 in ASCII. You should note carefully that ’\n’ is a single character, and in expressions is just an

integer; on the other hand, ’\n’ is a string constant that happens to contain only one character. The topic of strings versus

characters is discussed further in Chapter 2.

Exercise 1-8. Write a program to count blanks, tabs, and newlines.

Exercise 1-9. Write a program to copy its input to its output, replacing each string of one or more blanks by a single blank.

Exercise 1-10. Write a program to copy its input to its output, replacing each tab by \t, each backspace by \b, and each

backslash by \\. This makes tabs and backspaces visible in an unambiguous way.

1.5.4 Word Counting

The fourth in our series of useful programs counts lines, words, and characters, with the loose definition that a word is any

sequence of characters that does not contain a blank, tab or newline. This is a bare-bones version of the UNIX program wc.

#include <stdio.h>

#define IN 1 /* inside a word */

#define OUT 0 /* outside a word */

/* count lines, words, and characters in input */

main()

{

int c, nl, nw, nc, state;

state = OUT;

nl = nw = nc = 0;

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

++nc;

if (c == ’\n’)

++nl;

if (c == ’ ’ || c == ’\n’ || c = ’\t’)

state = OUT;

else if (state == OUT) {

state = IN;

++nw;

}

printf("%d %d %d\n", nl, nw, nc);

}

Every time the program encounters the first character of a word, it counts one more word. The variable state records

whether the program is currently in a word or not; initially it is ‘‘not in a word’’, which is assigned the value OUT. We prefer

the symbolic constants IN and OUT to the literal values 1 and 0 because they make the program more readable. In a program as

tiny as this, it makes little difference, but in larger programs, the increase in clarity is well worth the modest extra effort to

write it this way from the beginning. You’ll also find that it’s easier to make extensive changes in programs where magic

numbers appear only as symbolic constants.

The line

nl = nw = nc = 0;

sets all three variables to zero. This is not a special case, but a consequence of the fact that an assignment is an expression

with the value and assignments associated from right to left. It’s as if we had written

nl = (nw = (nc = 0));

The operator || means OR, so the line

if (c == ’ ’ || c == ’\n’ || c = ’\t’)

says ‘‘if c is a blank or c is a newline or c is a tab’’. (Recall that the escape sequence \t is a visible representation of the tab

character.) There is a corresponding operator && for AND; its precedence is just higher than ||. Expressions connected by &&

or || are evaluated left to right, and it is guaranteed that evaluation will stop as soon as the truth or falsehood is known. If c is

a blank, there is no need to test whether it is a newline or tab, so these tests are not made. This isn’t particularly important

here, but is significant in more complicated situations, as we will soon see.

The example also shows an else, which specifies an alternative action if the condition part of an if statement is false. The

general form is

if (expression)

statement

else

statement

One and only one of the two statements associated with an if-else is performed. If the expression is true, statement

executed; if not, statement

is executed. Each statement can be a single statement or several in braces. In the word count

program, the one after the else is an if that controls two statements in braces.

Exercise 1-11. How would you test the word count program? What kinds of input are most likely to uncover bugs if there are

any?

Exercise 1-12. Write a program that prints its input one word per line.

1.6 Arrays

Let is write a program to count the number of occurrences of each digit, of white space characters (blank, tab, newline), and

of all other characters. This is artificial, but it permits us to illustrate several aspects of C in one program.

There are twelve categories of input, so it is convenient to use an array to hold the number of occurrences of each digit, rather

than ten individual variables. Here is one version of the program:

#include <stdio.h>

/* count digits, white space, others */

main()

{

int c, i, nwhite, nother;

int ndigit[10];

nwhite = nother = 0;

for (i = 0; i < 10; ++i)

ndigit[i] = 0;

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

if (c >= ’0’ && c <= ’9’)

++ndigit[c-’0’];

else if (c == ’ ’ || c == ’\n’ || c == ’\t’)

++nwhite;

else

++nother;

printf("digits =");

for (i = 0; i < 10; ++i)

printf(" %d", ndigit[i]);

printf(", white space = %d, other = %d\n",

nwhite, nother);

}

The output of this program on itself is

digits = 9 3 0 0 0 0 0 0 0 1, white space = 123, other = 345

剩余204页未读，继续阅读

tygfyxgs

粉丝: 0
资源: 1

C编程语言精华解读

The Rust Programming Language.pdf

THE C PROGRAMMING LANGUAGE，2nd（ENGLISH TEXT VERSION）

The C++ Programming Language, 4th Edition part1

The C++ Programming Language, 4th Edition part3

The C++ Programming Language, 4th Edition part2

The_C_plus_plus_programming_language_english_versi_VC书籍_C++_

The Swift Programming Language (Swift 5.0)包括pdf和epub版本

The.Go.Programming.Language.2015.11(English)

Learn C++ Programming Language C++11 书签修正版pdf

Programming.in.the.Large.with.Design.Patterns

最新资源