C语言教程：从入门到精通

PDF文件

下载需积分: 7 | 1.21MB | 更新于2024-07-31 | 17 浏览量 | 举报收藏

立即下载

"C编程语言教程" C编程语言是一门基础且强大的编程语言，它以其高效、灵活性和对硬件的接近性而闻名。本教程旨在引导初学者逐步掌握C语言的核心概念和技术。以下是对各章节内容的详细说明：第一章 - 教程介绍这一章作为入门指引，首先介绍了如何开始C语言的学习。它涵盖了变量和算术表达式的基本概念，让学习者理解如何在C语言中存储数据和进行基本的数学运算。接着，讲解了for循环，这是C语言中最常用的循环结构之一，适用于重复执行代码块的情况。此外，还介绍了符号常量的概念，它们是不可变的标识符，用于替代硬编码的数值。本章进一步讨论了字符输入与输出，包括如何实现文件复制、字符计数、行计数和单词计数的示例。最后，介绍了数组，一种存储多个相同类型数据的集合，以及函数的使用。第二章 - 类型、运算符和表达式本章深入到变量命名规则、数据类型及其内存占用，以及常量的定义。声明是告诉编译器变量类型的重要步骤，本章详细解释了声明的语法。接着，探讨了各种算术运算符，如加减乘除，以及关系和逻辑运算符，这些是编写条件语句的基础。此外，讲解了类型转换，允许在不同数据类型之间转换。增量和减量运算符（++和--）以及位运算符也在此章中被涵盖，它们允许对单个二进制位进行操作。赋值运算符和表达式的处理，以及条件表达式的使用，使得程序能够根据特定条件执行不同的操作。最后，详细解析了运算符的优先级和求值顺序。第三章 - 控制流程此章关注程序的控制流程，即如何决定代码何时以及如何执行。讲解了if-else语句，用于根据条件执行不同的代码段，以及else-if的用法，用于多条件分支。switch语句提供了一种更简洁的方式来处理多个可能的条件。循环是控制流的关键部分，包括while和for循环，它们用于反复执行代码，直到满足特定条件。do-while循环是另一种形式，至少会执行一次循环体。break和continue语句分别用于跳出循环或跳过当前迭代。goto语句和标签允许非局部跳转，但其使用通常被视为不推荐的编程实践。第四章 - 函数和程序结构这一章聚焦于C语言中的函数，它是模块化和重用代码的关键。函数可以接受参数（按值传递），并返回结果。外部变量和作用域的概念也被介绍，这关乎变量在程序的不同部分可见和可访问的程度。通过合理组织函数和程序结构，可以提高代码的可读性和可维护性。这个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

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

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 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页未读，继续阅读

dingbo911

粉丝: 0

C语言教程：从入门到精通

《the c programming language》(CLH)

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

C语言C programming language

C Programming Language

C Programming language

c programming language

C programming language C语言圣经

C语言程序设计 The C programming language

c语言（C语言编程宝典、Expert C Programming、The C programming Language）

kr c c programming language

最新资源