C语言入门教程：从基础到实践

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

"这是一本关于C语言开发的教程，适合初学者和有一定基础的开发者。本书内容详尽，经典实用，英文版提供了全面的C语言学习指导。" 在C语言开发教程中，作者首先从基础入手，帮助读者快速入门。第1章“教程介绍”包括以下几个关键知识点： 1. **预览**：章节开头通常会为读者提供一个简短的概述，介绍本章将要学习的内容，帮助读者了解学习目标。 2. **开始编程**：这部分讲解了如何启动C语言编程环境，设置编译器，并编写简单的“Hello, World!”程序，这是每个程序员的起点。 3. **变量与算术表达式**：详细介绍了C语言中的变量类型（如整型、浮点型等），以及如何进行基本的算术运算，如加减乘除、取余等。 4. **for循环**：介绍了C语言中最常用的循环结构之一，for循环，以及其语法结构和应用。 5. **符号常量**：讲解了使用#define或const关键字定义常量的方法，以及它们在代码中的作用。 6. **字符输入与输出**：涵盖了标准输入输出流，如使用scanf和printf进行输入输出，以及文件复制的例子。 7. **数组**：深入讲解了一维数组的声明、初始化和操作，以及数组在内存中的存储方式。 8. **函数**：介绍了函数的定义、调用，以及参数传递的方式，包括值传递。 9. **按值调用参数**：详细解释了函数调用时，参数是如何通过值传递给函数内部使用的。 10. **字符数组**：讨论了字符串在C语言中的处理，包括字符串常量和字符数组的区别。 11. **外部变量与作用域**：讲解了全局变量和局部变量的概念，以及它们的作用范围。第2章“类型、运算符和表达式”进一步探讨了C语言的核心要素： 1. **变量命名规则**：讲解了C语言中变量命名的规则和约定。 2. **数据类型与大小**：涵盖了各种内置数据类型（如int、char、float等）的大小和取值范围。 3. **常量**：讨论了常量的定义和分类，包括整型常量、浮点型常量、字符常量和字符串常量。 4. **声明**：介绍了变量、函数的声明和定义的区别。 5. **算术运算符**：讲解了加、减、乘、除、取模等运算符的使用。 6. **关系与逻辑运算符**：介绍了比较运算符（如==, !=, <, >等）和逻辑运算符（如&&, ||, !）。 7. **类型转换**：解释了隐式和显式的类型转换，以及可能遇到的问题。 8. **自增自减运算符**：讨论了++和--运算符的前缀和后缀形式及其用法。 9. **位运算符**：涵盖了位移、按位与、按位或、按位异或和按位非等位运算。 10. **赋值运算符与表达式**：讲解了不同类型的赋值运算符（如=, +=, -=等）以及它们在表达式中的行为。 11. **条件表达式**：介绍了三元运算符（? :）的使用，以及它如何根据条件选择执行不同的表达式。 12. **运算符优先级与求值顺序**：阐述了运算符的优先级和结合性，以及它们对表达式求值的影响。第3章“控制流程”则关注程序的流程控制结构： 1. **语句与块**：讲解了C语言中的基本语句和由花括号{}包围的代码块。 2. **if-else语句**：介绍了条件判断的基本形式，以及使用else分支进行条件分支。 3. **else-if语句**：讨论了多个条件的检查，使用else-if链实现多条件分支。 4. **switch语句**：讲解了基于枚举值或整型变量的多分支选择。 5. **while和for循环**：涵盖了两种主要的迭代结构，以及它们的用法。 6. **do-while循环**：介绍了至少执行一次的循环结构。 7. **break和continue**：讲解了如何跳出循环或跳过循环体的剩余部分。 8. **goto语句和标签**：虽然不推荐，但仍然介绍了goto语句作为无条件跳转的工具。第4章“函数与程序结构”继续深入探讨了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

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

b8dianban

粉丝: 0
资源: 1

C语言入门教程：从基础到实践

51单片机的C语言开发教程

Winmine C语言开发教程介绍.zip

C语言MYSQL开发教程

C语言开发教程 WORD版

NES 游戏 C语言开发教程

AVR单片机C语言开发教程与笔记

C语言实例教程 C语言实例教程 C语言实例教程

c语言入门 C语言入门教程 C语言入门教程

C语言开发实例教程

C语言的教程课件大纲-C语言的教程课件大纲-C语言的教程课件大纲

最新资源