C语言编程基础教程

需积分: 10 26 浏览量更新于2024-07-22 收藏 1.17MB PDF 举报

"C程序设计语言" 是一本关于学习C语言的经典教材，由Brian W. Kernighan和Dennis M. Ritchie合著。书中详细介绍了C语言的基础概念和编程技术。在第一章“教程介绍”中，作者从入门开始，引导读者逐步熟悉C语言。这一章涵盖了以下几个关键知识点： 1. 开始编程：讲解如何启动C语言编程环境，包括编译器的基本用法。 2. 变量与算术表达式：介绍变量的概念，以及如何进行基本的数学运算，如加减乘除、取余等。 3. for语句：解释了for循环的工作原理，以及如何使用它来重复执行一段代码。 4. 符号常量：介绍了#define宏定义常量的方法，以及它们在程序中的作用。 5. 字符输入与输出：讲解了标准输入输出函数，如printf和scanf，以及如何处理字符数据。 - 文件复制：展示了如何编写一个简单的程序来复制一个文件的内容。 - 字符计数：演示了计算输入文件中字符数量的程序。 - 行计数：讲解了如何统计文件中的行数。 - 单词计数：介绍了一个计数文件中单词数量的示例。 6. 数组：深入讨论了数组的概念，包括一维和多维数组，以及如何使用数组存储和操作数据。 7. 函数：讲述了函数的定义、调用以及参数传递，强调了函数的模块化编程思想。 8. 参数传递：特别提到了C语言中参数传递的方式——值传递，以及其工作原理。 9. 字符数组：讨论了字符数组（字符串）的处理，包括字符串常量和动态字符串。 10. 外部变量与作用域：介绍了全局变量和局部变量的区别，以及作用域规则。第二章“类型、运算符和表达式”进一步深入C语言的核心元素： 1. 变量名：规定了变量命名的规则和约定。 2. 数据类型：详细描述了C语言中的基本数据类型，如int、char、float和double等，以及它们的大小。 3. 常量：涵盖了各种类型的常量，包括数值、字符和字符串常量。 4. 声明：解释了声明变量的语法，以及如何声明数组和函数。 5. 算术运算符：涵盖了加、减、乘、除等基本运算符，以及自增自减运算符。 6. 关系和逻辑运算符：讨论了比较和逻辑运算，如==、!=、&&、||等。 7. 类型转换：讲述了不同数据类型之间的自动和强制转换。 8. 位运算符：介绍了按位与、或、非、异或以及左移和右移运算符。 9. 赋值运算符和表达式：讨论了各种赋值运算符，如+=、-=等，以及表达式的值和副作用。 10. 条件表达式：讲解了三目运算符，用于根据条件选择返回不同的值。 11. 运算符优先级和结合性：详细阐述了运算符的执行顺序和优先级规则。第三章“控制流程”主要涉及程序流程的控制结构： 1. 语句与块：介绍了基本语句和使用花括号{}组织的代码块。 2. if-else：讲解了条件判断语句if和其配对的else语句。 3. else-if：介绍了多条件判断的else-if结构。 4. switch：探讨了switch-case语句，用于多分支选择。 5. 循环：涵盖了while、for和do-while循环，以及它们在迭代中的应用。 6. break和continue：讨论了如何跳出循环或跳过循环内部的部分代码。 7. goto和标签：虽然不推荐使用，但还是介绍了goto语句及其在程序中的用法。这些章节的内容构成了C语言的基础，对于初学者来说是学习C语言的宝贵资源。通过这本书，读者将能够理解C语言的基本概念，并具备编写简单到复杂程序的能力。

/* 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 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()

剩余216页未读，继续阅读

码道

粉丝: 1
资源: 1

C语言编程基础教程

C 语言 API文档 C语言是一门面向过程的、抽象化的通用程序设计语言

C语言程序设计：第1章 C语言程序设计概述

C语言程序设计，可以让很多不懂C语言的人很容易上手。

C程序设计语言PDF 清晰原版

C程序设计语言 第2版 新版

程序设计语言 实践之路 第3版

C++程序设计语言（第四版 英文版）

C程序设计语言(第2版·新版).pdf

程序设计语言编译原理课后习题答案(陈火旺 第三版)

C程序设计语言(第2版·新版)习题解答.pdf

最新资源

C程序设计语言第2版新版

程序设计语言实践之路第3版

C++程序设计语言（第四版英文版）

程序设计语言编译原理课后习题答案(陈火旺第三版)