C语言编程基础(ANSI C)教程

5星 · 超过95%的资源需积分: 9 146 浏览量更新于2024-07-24 收藏 2.26MB PDF 举报

"《C Programming Language (ANSI C)》是经典的C语言教程，适合用作常备参考书籍。本书涵盖了C语言的基础概念和核心特性，包括变量、运算符、表达式、控制流程、函数以及程序结构等重要内容，旨在引导初学者逐步掌握C语言编程技能。" 在本教程中，作者首先介绍了C语言的基本入门知识，如第1章的"ATutorialIntroduction"部分，从"GettingStarted"开始，讲解了如何启动编程环境，以及如何定义和使用变量（VariablesandArithmeticExpressions）。接着，教程深入到循环控制语句"Theforstatement"，使读者了解如何实现重复执行的逻辑。"SymbolicConstants"则介绍了常量的使用，增强了代码的可读性。此外，"CharacterInputandOutput"部分涵盖了基本的输入输出操作，包括文件复制、字符计数、行计数和单词计数等实用示例。第1章还讨论了数组(Arrays)、函数(Functions)以及参数传递(Arguments-CallbyValue)，强调了值传递的概念。接着是字符数组(CharacterArrays)、外部变量(ExternalVariablesandScope)的使用，这些都是C语言中重要且常见的数据结构。第2章"Types,OperatorsandExpressions"详细阐述了变量命名、数据类型及其大小、常量、声明、算术运算符、关系和逻辑运算符、类型转换、自增自减运算符、位运算符以及赋值运算符和条件表达式，这些都是编写C程序时不可或缺的元素。此外，还讨论了运算符的优先级和求值顺序，这对于理解和编写复杂的表达式至关重要。第3章"ControlFlow"主要讲解了程序控制结构，包括语句和块(StatementsandBlocks)、if-else语句、else-if结构、switch语句、while和for循环、do-while循环，以及break和continue语句。这些控制流工具使程序员能够根据条件执行不同路径的代码，实现更复杂的逻辑控制。最后，介绍了goto语句和标签，尽管它们在某些情况下不推荐使用，但了解其工作原理仍然有益。第4章"FunctionsandProgramStructure"将探讨函数的更深层次使用，以及如何组织和构建C程序的结构。这部分内容对于理解如何设计模块化的、可维护的代码至关重要，也是C语言学习者必须掌握的关键章节。《C Programming Language (ANSI C)》是一本全面介绍C语言的教程，通过详细的解释和实例，帮助读者逐步掌握编程基础，从而能够独立编写和理解C语言程序。无论你是初学者还是有经验的程序员，这本书都能提供宝贵的指导。

20 -6.7

40 4.4

...

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.

%d print as decimal integer

%6d print as decimal integer, at least 6 characters wide

%f 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 1Exercise 1--3.3. Modify the temperature conversion program to print a heading above the

table.

Exercise 1Exercise 1--4.4. Write a program to print the corresponding Celsius to Fahrenheit table.

1.3 The for statement1.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

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 1Exercise 1--5.5. Modify the temperature conversion program to print the table in reverse

order, that is, from 300 degrees to 0.

1.4 Symbolic Constants1.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 Output1.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 Copying1.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.)

剩余246页未读，继续阅读

tdyy

粉丝: 0

C语言编程基础(ANSI C)教程

The ANSI C Programming Language (Kernighan & Ritchie)

标准C语言编程(The ANSI C Programming Language)

The ANSI C Programming Language (2nd Edition)

The C Programming Language

the C programming language

The c programming language

C语言 英文第二版( The C Programming Language Second Version)

The C Programming Language第二版

The C Programming Language習題解答

The C Programming Language(C程序设计语言).pdf

最新资源

C语言英文第二版( The C Programming Language Second Version)