C语言经典教程：基础到高级

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

《C程序设计语言》(The C Programming Language)，由 Brian W. Kernighan 和 Dennis M. Ritchie 联合撰写，于1988年由Prentice-Hall出版社出版。本书的两个版本分别为平装版(ISBN 0-13-110362-8)和硬皮版(ISBN 0-13-110370-9)，是C语言领域的经典教材，对于初学者和专业程序员都具有重要的参考价值。该书的内容涵盖了C语言的基础和核心概念，共分为四个章节，旨在帮助读者逐步掌握C语言的关键要素： 1. **入门教程**：第1章以实践为导向，引导读者快速上手。包括如何开始编写程序、变量和算术表达式、for循环的使用、符号常量、字符输入输出等。通过诸如文件复制、字符计数、行计数和单词计数等实例，让学习者理解C语言的基本操作。 2. **类型、运算符与表达式**：第2章深入探讨数据类型、变量命名规则、不同数据类型的大小，以及常量的使用。还讲解了声明、算术、关系和逻辑运算符、类型转换、自增自减运算符、位操作符等，为表达式的复杂性奠定基础。这部分内容对理解C语言的运算机制至关重要。 3. **控制流程**：第3章主要介绍程序的控制结构，如语句和代码块、if-else、嵌套if-else、switch语句、循环（while和for）、do-while循环、break和continue语句，以及goto和标签的用法。这些控制结构是构建复杂程序逻辑的基础。 4. **函数与程序设计**：第4章深入讨论函数的定义和调用，包括传值参数、字符数组、外部变量和作用域的概念。此外，还有对函数和程序组织结构的全面解析，帮助读者理解模块化编程的重要性。《The C Programming Language》是一本权威且实用的指南，不仅适合刚接触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页未读，继续阅读

ningboge

粉丝: 0
资源: 4

C语言经典教程：基础到高级

《the c programming language》(CLH)

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

The C Programming Language

the c programming language

The C programming Language

the C programming language

教师节主题班会.pptx

学生网络安全教育主题班会.pptx

世界环境日主题班会.pptx

GNSS 经纬度 所有国家的电子围栏

最新资源

GNSS 经纬度所有国家的电子围栏