C语言编程基础教程

需积分: 50 161 浏览量更新于2024-07-24 收藏 1.66MB PDF 举报

"这是一本关于C语言编程的初级入门教程，主要面向英语读者。书中由浅入深地介绍了C语言的基本概念和编程技巧，包括变量、表达式、控制流、函数等核心概念，适合初学者学习使用。" 在《C程序学习》这本书中，作者以易于理解的方式引导读者进入C语言的世界。首先，书中的“Preface”部分可能对作者的编写意图和书籍适用人群进行了简要介绍，为后续的学习奠定了基础。第一章“一个教程式的介绍”是入门阶段的关键，它涵盖了以下几个方面： 1.1 “Getting Started”引导读者如何开始编写C程序，包括环境设置和基本的编程流程。 1.2 阐述了“变量和算术表达式”，这是理解任何编程语言的基础，讲解了变量的声明、赋值以及基本的算术运算。 1.3 “The for statement”介绍了C语言中常用的循环结构for循环，它是程序控制流程中的重要工具。 1.4 “Symbolic Constants”解释了符号常量的使用，它们在程序中提供了一种定义不可变值的方式。 1.5 “Character Input and Output”这部分涉及字符输入和输出，包括简单的文件复制、字符计数、行计数和单词计数的示例，这些都是基本的I/O操作。 1.6 “Arrays”介绍了数组的概念，如何声明和操作数组。 1.7 “Functions”讲解了函数的定义和调用，以及函数在代码组织中的作用。 1.8 “Arguments - Call by Value”讨论了函数参数传递机制，即按值传递。 1.9 “Character Arrays”进一步深入到字符数组，也就是字符串的处理。 1.10 “External Variables and Scope”提到了外部变量和作用域的概念，这对于理解变量在程序中的可见性和生命周期至关重要。第二章“类型、运算符和表达式”深入到C语言的语法细节： 2.1 “Variable Names”讨论了变量命名规则和约定。 2.2 “Data Types and Sizes”介绍了C语言的数据类型及其存储大小。 2.3 “Constants”涵盖了常量的使用，包括整型、浮点型和字符型常量。 2.4 “Declarations”讲解了变量和数据类型的声明。 2.5 “Arithmetic Operators”列出了算术运算符，如加减乘除和取模。 2.6 “Relational and Logical Operators”介绍了关系和逻辑运算符，用于比较和逻辑判断。 2.7 “Type Conversions”讨论了类型转换，当不同数据类型之间进行运算时会发生的情况。 2.8 “Increment and Decrement Operators”解释了自增和自减运算符的用法。 2.9 “Bitwise Operators”涵盖了位操作符，适用于底层的位级操作。 2.10 “Assignment Operators and Expressions”讨论了赋值运算符及其在表达式中的应用。 2.11 “Conditional Expressions”介绍了条件表达式，如三元运算符。 2.12 “Precedence and Order of Evaluation”讲解了运算符的优先级和求值顺序，这对于正确理解表达式至关重要。第三章“控制流”关注程序的执行路径： 3.1 “Statements and Blocks”解释了语句和代码块的概念，如何组织代码。 3.2 “If-Else”介绍了条件语句if和else，用于执行基于条件的代码分支。 3.3 “Else-If”讲述了else-if的使用，增加了条件判断的灵活性。 3.4 “Switch”讲解了switch语句，提供了多分支选择的另一种方式。 3.5 “Loops - While and For”介绍了while和for循环，用于重复执行某段代码。 3.6 “Loops - Do-While”提到了do-while循环，其特点是先执行后判断。 3.7 “Break and Continue”讨论了在循环中跳出和跳过当前迭代的语句。 3.8 “Goto and labels”虽然在结构化编程中不推荐，但仍然介绍了goto语句及其在跳转控制中的使用。第四章“Functions”和后续章节可能会继续深入探讨更高级的主题，如指针、内存管理、结构体、文件操作等，这些是C语言的重要组成部分，也是进阶学习的关键。《C程序学习》是一本全面覆盖C语言基础知识的教材，通过实例和清晰的解释，帮助初学者逐步掌握编程技能。

}

The two lines

/* print Fahrenheit-Celsius table

for fahr = 0, 20, ..., 300 */

are a comment, which in this case explains briefly what the program does. Any characters between /* and */

are ignored by the compiler; they may be used freely to make a program easier to understand. Comments may

appear anywhere where a blank, tab or newline can.

In C, all variables must be declared before they are used, usually at the beginning of the function before any

executable statements. A declaration announces the properties of variables; it consists of a name and a list of

variables, such as

int fahr, celsius;

int lower, upper, step;

The type int means that the variables listed are integers; by contrast with float, which means floating

point, i.e., numbers that may have a fractional part. The range of both int and float depends on the

machine you are using; 16-bits ints, which lie between -32768 and +32767, are common, as are 32-bit ints.

A float number is typically a 32-bit quantity, with at least six significant digits and magnitude generally

between about 10

-38

and 10

C provides several other data types besides int and float, including:

char character - a single byte

short short integer

long long integer

double double-precision floating point

The size of these objects is also machine-dependent. There are also arrays, structures and unions of these

basic types, pointers to them, and functions that return them, all of which we will meet in due course.

Computation in the temperature conversion program begins with the assignment statements

lower = 0;

upper = 300;

step = 20;

which set the variables to their initial values. Individual statements are terminated by semicolons.

Each line of the table is computed the same way, so we use a loop that repeats once per output line; this is the

purpose of the while loop

while (fahr <= upper) {

...

}

The while loop operates as follows: The condition in parentheses is tested. If it is true (fahr is less than or

equal to upper), the body of the loop (the three statements enclosed in braces) is executed. Then the

condition is re-tested, and if true, the body is executed again. When the test becomes false (fahr exceeds

upper) the loop ends, and execution continues at the statement that follows the loop. There are no further

statements in this program, so it terminates.

4 Chapter 1 - A Tutorial Introduction

The body of a while can be one or more statements enclosed in braces, as in the temperature converter, or a

single statement without braces, as in

while (i < j)

i = 2 * i;

In either case, we will always indent the statements controlled by the while by one tab stop (which we have

shown as four spaces) so you can see at a glance which statements are inside the loop. The indentation

emphasizes the logical structure of the program. Although C compilers do not care about how a program

looks, proper indentation and spacing are critical in making programs easy for people to read. We recommend

writing only one statement per line, and using blanks around operators to clarify grouping. The position of

braces is less important, although people hold passionate beliefs. We have chosen one of several popular

styles. Pick a style that suits you, then use it consistently.

Most of the work gets done in the body of the loop. The Celsius temperature is computed and assigned to the

variable celsius by the statement

celsius = 5 * (fahr-32) / 9;

The reason for multiplying by 5 and dividing by 9 instead of just multiplying by 5/9 is that in C, as in many

other languages, integer division truncates: any fractional part is discarded. Since 5 and 9 are integers. 5/9

would be truncated to zero and so all the Celsius temperatures would be reported as zero.

This example also shows a bit more of how printf works. printf is a general-purpose output formatting

function, which we will describe in detail in Chapter 7. Its first argument is a string of characters to be printed,

with each % indicating where one of the other (second, third, ...) arguments is to be substituted, and in what

form it is to be printed. For instance, %d specifies an integer argument, so the statement

printf("%d\t%d\n", fahr, celsius);

causes the values of the two integers fahr and celsius to be printed, with a tab (\t) between them.

Each % construction in the first argument of printf is paired with the corresponding second argument, third

argument, etc.; they must match up properly by number and type, or you will get wrong answers.

By the way, printf is not part of the C language; there is no input or output defined in C itself. printf is

just a useful function from the standard library of functions that are normally accessible to C programs. The

behaviour of printf is defined in the ANSI standard, however, so its properties should be the same with any

compiler and library that conforms to the standard.

In order to concentrate on C itself, we don't talk much about input and output until chapter 7. In particular, we

will defer formatted input until then. If you have to input numbers, read the discussion of the function scanf

in Section 7.4. scanf is like printf, except that it reads input instead of writing output.

There are a couple of problems with the temperature conversion program. The simpler one is that the output

isn't very pretty because the numbers are not right-justified. That's easy to fix; if we augment each %d in the

printf statement with a width, the numbers printed will be right-justified in their fields. For instance, we

might say

printf("%3d %6d\n", fahr, celsius);

to print the first number of each line in a field three digits wide, and the second in a field six digits wide, like

this:

0 -17

20 -6

Chapter 1 - A Tutorial Introduction 5

40 4

60 15

80 26

100 37

...

The more serious problem is that because we have used integer arithmetic, the Celsius temperatures are not

very accurate; for instance, 0

F is actually about -17.8

C, not -17. To get more accurate answers, we should

use floating-point arithmetic instead of integer. This requires some changes in the program. Here is the second

version:

#include <stdio.h>

/* print Fahrenheit-Celsius table

for fahr = 0, 20, ..., 300; floating-point version */

main()

{

float fahr, celsius;

float lower, upper, step;

lower = 0; /* lower limit of temperatuire scale */

upper = 300; /* upper limit */

step = 20; /* step size */

fahr = lower;

while (fahr <= upper) {

celsius = (5.0/9.0) * (fahr-32.0);

printf("%3.0f %6.1f\n", fahr, celsius);

fahr = fahr + step;

}

This is much the same as before, except that fahr and celsius are declared to be float and the formula

for conversion is written in a more natural way. We were unable to use 5/9 in the previous version because

integer division would truncate it to zero. A decimal point in a constant indicates that it is floating point,

however, so 5.0/9.0 is not truncated because it is the ratio of two floating-point values.

If an arithmetic operator has integer operands, an integer operation is performed. If an arithmetic operator has

one floating-point operand and one integer operand, however, the integer will be converted to floating point

before the operation is done. If we had written (fahr-32), the 32 would be automatically converted to

floating point. Nevertheless, writing floating-point constants with explicit decimal points even when they have

integral values emphasizes their floating-point nature for human readers.

The detailed rules for when integers are converted to floating point are in Chapter 2. For now, notice that the

assignment

fahr = lower;

and the test

while (fahr <= upper)

also work in the natural way - the int is converted to float before the operation is done.

The printf conversion specification %3.0f says that a floating-point number (here fahr) is to be printed

at least three characters wide, with no decimal point and no fraction digits. %6.1f describes another number

(celsius) that is to be printed at least six characters wide, with 1 digit after the decimal point. The output

looks like this:

6 Chapter 1 - A Tutorial Introduction

0 -17.8

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

"%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

Chapter 1 - A Tutorial Introduction 7

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.

8 Chapter 1 - A Tutorial Introduction

剩余216页未读，继续阅读

CherishDevil

粉丝: 0
资源: 1

C语言编程基础教程

The C programme language.chm

The C Program Language 第二版 双语 高清

circle of a c programme

用英文给Programme Manager of the Winton Programme写一封信，表示想要申请Winton Programme，但是错过了申请意向提交的时间，希望可以得到考虑。

给Programme Manager of the Winton Programme写一封信，表示想要申请Winton Programme，但是错过了申请意向提交的时间，希望可以得到考虑。

最新资源

The C Program Language 第二版双语高清