C语言教程：入门与基础操作

需积分: 10 39 浏览量更新于2024-07-20 收藏 1.2MB PDF 举报

"C程序设计语言(英文版)"是一本深入讲解C语言编程基础的教程，由R&D团队编著。本书以实用和易懂的方式引导读者入门，涵盖了从基本概念到高级控制结构的全面内容。首先，章节1——"A Tutorial Introduction"，旨在帮助新手快速上手。这一章分为多个小节，如"Getting Started"介绍了安装和配置环境的过程，随后讲解了变量和算术表达式，这对于理解程序的基本运算至关重要。"The for statement"则详细解释了循环语句的使用，包括计数、复制文件、字符计数、行计数和单词计数等实际操作，通过实例演示让学习者掌握基本数据处理技巧。数组（Arrays）的介绍有助于理解内存管理和数据存储方式，而函数（Functions）的概念则为模块化编程打下基础。在第2章，"Types, Operators, and Expressions"，重点放在数据类型、运算符和表达式的语法上。变量名的选择规则、数据类型及其大小、常量的使用，以及声明语句都在这一章详细讨论。接下来的章节详细阐述了各种算术、关系和逻辑运算符，以及类型转换、自增/自减和位操作符。此外，还介绍了赋值运算符和条件表达式，以及运算符的优先级和执行顺序，确保读者能准确编写复杂的逻辑代码。第三部分，"Control Flow"，深入解析程序控制流程。章节3开始介绍基本的语句和块的结构，接着探讨了if-else和嵌套的else-if结构，以及switch语句的选择分支。循环结构如while和for的用法，以及do-while循环的特性和应用，都是控制流部分的核心内容，对于程序的逻辑流程设计至关重要。整体而言，这本书适合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 %f 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

www.linuxidc.com

Linux公社(LinuxIDC.com) 是包括Ubuntu,Fedora,SUSE技术，最新IT资讯等Linux专业类网站。

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.

www.linuxidc.com

Linux公社(LinuxIDC.com) 是包括Ubuntu,Fedora,SUSE技术，最新IT资讯等Linux专业类网站。

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''.

www.linuxidc.com

Linux公社(LinuxIDC.com) 是包括Ubuntu,Fedora,SUSE技术，最新IT资讯等Linux专业类网站。

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)

www.linuxidc.com

Linux公社(LinuxIDC.com) 是包括Ubuntu,Fedora,SUSE技术，最新IT资讯等Linux专业类网站。

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);

}

www.linuxidc.com

Linux公社(LinuxIDC.com) 是包括Ubuntu,Fedora,SUSE技术，最新IT资讯等Linux专业类网站。

剩余236页未读，继续阅读

DC_LW

粉丝: 0
资源: 9

C语言教程：入门与基础操作

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

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

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

Java语言程序设计（英文第十版）

C程序设计语言（第2版·新版）非扫描版&详细书签版.pdf

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

"Rust 程序设计语言简体中文版pdf和入门指南

上下文无关文法与程序设计语言

程序设计语言与编译：课后习题解析

"Rust程序设计语言官方文档 2023年更新 简体中文版

最新资源

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

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

"Rust程序设计语言官方文档 2023年更新简体中文版