C语言编程基础与Unix知识探索

需积分: 3 75 浏览量更新于2024-07-24 收藏 2.77MB PDF 举报

“这是一本关于C语言编程的经典英文教材，涵盖了C语言的基础和高级特性，同时结合Unix系统知识进行讲解，适合希望通过阅读英文书籍来学习和提升C语言技能的读者。” 该书首先从基础入门，逐步引导读者了解C语言的核心概念。在第一章“教程介绍”中，作者详细阐述了以下几个知识点： 1. 开始编程：如何启动C语言编程之旅，包括设置环境和编写第一个简单的程序。 2. 变量与算术表达式：讲解了变量的基本用法和不同类型的算术运算，如加减乘除、取余和自增自减等。 3. for循环：介绍了C语言中的for循环结构，以及如何在循环中控制条件和迭代。 4. 符号常量：如何定义和使用符号常量（#define）替代可变值，提高代码可读性和安全性。 5. 字符输入与输出：讲解了标准输入输出函数，如printf和scanf，以及如何处理字符数据。 - 文件复制：通过示例展示了如何读取一个文件并将其内容写入另一个文件。 - 字符计数：计算输入中的字符数量。 - 行计数：统计文本文件中的行数。 - 单词计数：实现一个简单的单词计数程序。 6. 数组：解释了数组的概念，如何声明和使用一维和多维数组。 7. 函数：介绍了函数的定义、调用和作用，以及函数作为代码复用的基本单元。 8. 参数传递：讨论了C语言中的值传递机制，即函数调用时参数的传递方式。 9. 字符数组：特别提到了字符串在C语言中的表示和处理。 10. 外部变量与作用域：解释了变量的生命周期和可见范围，包括局部变量、全局变量和外部变量。第二章“类型、运算符与表达式”深入探讨了： 1. 变量命名规则：讲解了如何遵循命名规范来创建有意义的变量名。 2. 数据类型及其大小：介绍了C语言中的基本数据类型（如int、char、float等）以及它们的内存占用。 3. 常量：包括数值常量、字符串常量和字符常量的定义与使用。 4. 声明：阐述了变量声明的语法和用途，以及如何声明数组和指针。 5. 阐述了各种算术运算符，如加、减、乘、除、取模等。 6. 关系与逻辑运算符：用于比较和组合条件，如==、!=、<、>、&&、||等。 7. 类型转换：讨论了隐式和显式类型转换的规则。 8. 自增与自减运算符：++和--的前缀和后缀形式及其对变量值的影响。 9. 位运算符：介绍位操作，如按位与、或、非、异或和位移。 10. 赋值运算符：包括简单的赋值和复合赋值运算符，如=、+=、-=等。 11. 条件表达式：提供了在表达式中根据条件选择值的能力。 12. 运算符优先级和结合性：讲解了运算符执行顺序的规则。第三章“控制流”涉及控制程序流程的各种结构： 1. 语句和块：介绍了语句的基本概念，以及用花括号{}定义代码块的作用。 2. if-else结构：展示了如何根据条件执行不同的代码路径。 3. else-if结构：在多个条件中选择满足的一个分支执行。 4. switch语句：提供了多分支选择，常用于基于不同情况执行不同代码块。 5. while和for循环：两种常见的循环结构，用于重复执行一段代码直到满足特定条件。 6. do-while循环：先执行后判断的循环结构，确保至少执行一次循环体。 7. break和continue：控制循环流程，break用于跳出循环，continue用于跳过当前迭代剩余部分。 8. goto和标签：尽管不推荐使用，但仍然介绍了goto语句和标签的用法。第四章“函数和程序结构”可能进一步涵盖： 1. 函数的高级特性，如递归、函数指针等。 2. 结构化编程原则，包括模块化和函数的组织。 3. 分析和设计程序结构，以提高代码可读性和可维护性。 4. 头文件和包含，以及函数原型声明。 5. 链接和库，如何使用和创建外部库。这本书全面覆盖了C语言的基础知识，从基本语法到更复杂的控制结构和函数应用，是学习C语言的宝贵资源，尤其对想要结合Unix环境进行学习的读者来说更具价值。通过阅读和实践书中的例子，读者可以逐步掌握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

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

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

王瑞祥

粉丝: 5
资源: 19

C语言编程基础与Unix知识探索

C语言程序设计基础教程

"C语言程序设计初步与基本知识要点

C语言程序设计历年真题及答案

C语言程序设计C语言程序设计

C语言程序设计习题习题程序C语言程序设计c语言程序设计c语言习题PDF

C语言程序设计习题习题程序C语言程序设计c语言程序设计c语言习题pdf

C语言程序设计 C语言程序设计

"C语言程序设计教程804页.ppt：基础知识及程序设计概念

C语言程序设计基础知识概述

036GraphTheory(图论) matlab代码.rar

最新资源