C语言编程基础:格式化输出、循环、符号常量及字符处理
立即解锁
发布时间: 2025-08-22 00:24:50 阅读量: 1 订阅数: 6 


C语言编程基础与实践
### C语言编程基础:格式化输出、循环、符号常量及字符处理
#### 1. 格式化输出说明
在C语言中,`printf` 函数的格式化说明符有多种用法,宽度和精度可以省略。以下是一些常见的格式化说明符及其作用:
| 说明符 | 作用 |
| ---- | ---- |
| `%6f` | 以浮点数形式输出,宽度至少为6个字符 |
| `%.2f` | 以浮点数形式输出,小数点后保留2位,宽度无限制 |
| `%f` | 以浮点数形式输出 |
| `%d` | 以十进制整数形式输出 |
| `%6d` | 以十进制整数形式输出,宽度至少为6个字符 |
| `%6.2f` | 以浮点数形式输出,宽度至少为6,小数点后保留2位 |
此外,`printf` 还支持 `%o`(八进制)、`%x`(十六进制)、`%c`(字符)、`%s`(字符串)和 `%%`(百分号本身)。
#### 2. for 循环语句
对于特定任务,编写程序有多种方式。以温度转换程序为例,使用 `for` 循环可以有不同的实现方式。
```c
#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));
}
```
与之前的实现相比,此版本消除了大部分变量,仅保留 `fahr` 并将其定义为 `int` 类型。下限、上限和步长仅作为 `for` 循环中的常量出现,计算摄氏度的表达式作为 `printf` 的第三个参数,而不是单独的赋值语句。
`for` 循环是 `while` 循环的一种泛化形式。其结构包含三个部分,用分号分隔:
1. **初始化**:在进入循环体之前执行一次,如 `fahr = 0`。
2. **条件判断**:控制循环的执行,如 `fahr <= 300`。若条件为真,则执行循环体;若为假,则终止循环。
3. **增量操作**:每次循环体执行后执行,如 `fahr = fahr + 20`。
`while` 和 `for` 循环的选择取决于哪种方式更清晰。`for` 循环通常适用于初始化和增量操作是单个语句且逻辑相关的情况,因为它比 `while` 循环更紧凑,且将循环控制语句集中在一处。
以下是 `for` 循环的执行流程 mermaid 流程图:
```mermaid
graph TD;
A[开始] --> B[初始化];
B --> C{条件判断};
C -- 真 --> D[执行循环体];
D --> E[增量操作];
E --> C;
C -- 假 --> F[结束];
```
#### 3. 符号常量
在程序中使用“魔法数字”(如 300 和 20)是不好的做法,因为它们对后续阅读程序的人传达的信息较少,且难以系统地修改。可以使用 `#define` 语句为这些数字定义有意义的符号常量。
```c
#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));
}
```
`LOWER`、`UPPER` 和 `STEP` 是符号常量,不是变量,因此不需要在声明中出现。符号常量名通常用大写字母表示,以便与小写变量名区分。注意,`#define` 语句末尾没有分号。
#### 4. 字符输入输出
标准库支持的输入输出模型非常简单,文本输入输出被视为字符流。标准库提供了一些逐字符读写的函数,其中 `getchar` 和 `putchar` 是最简单的。
- `getchar`:每次调用时,从文本流中读取下一个输入字符并返回该字符的值。
- `putchar`:每次调用时,将整数变量 `c` 的内容作为字符输出,通常显示在屏幕上。
##### 4.1 文件复制
利用 `getchar` 和 `putchar` 可以编写简单的文件复制程序。
```c
#include <stdio.h>
/* copy input to output; 1st version */
main()
{
int c;
c = getchar();
while (c != EOF) {
putchar(c);
c = getchar();
}
}
```
这里使用 `int` 类型的变量 `c` 是为了区分输入结束符 `EOF` 和有效数据。`EOF` 是在 `<stdio.h>` 中定义的整数,其具体数值不重要,只要与任何 `char` 值不同即可。
更简洁的实现方式如下:
```c
#include <stdio.h>
/* copy input to output; 2nd version */
main()
{
int c;
while ((c = getchar()) != EOF)
putchar(c);
}
```
在这个版本中,将字符赋值给 `c` 的操作放在 `while` 循环的测试部分,使程序更紧凑。
##### 4.2 字符计数
字符计数程序与文件复制程序类似,以下是两种实现方式:
```c
#include <stdio.h>
/* count characters in input; 1st version */
main()
{
long nc;
nc = 0;
while (getchar() != EOF)
++nc;
printf("%ld\n", nc);
}
```
```c
#include <stdio.h>
/* count characters in input; 2nd version */
main()
{
double nc;
for (nc = 0; getchar() != EOF; ++nc)
;
printf("%.0f\n", nc);
}
```
使用 `long` 或 `double` 类型的变量是为了处理可能较大的输入量,避免 `int` 类型溢出。
##### 4.3 行计数
行计数程序通过统计换行符的数量来计算输入的行数。
```c
#include <stdio.h>
/* count lines in input */
main()
{
int c, nl;
nl = 0;
while ((c = getchar()) != EOF)
if (c == '\n')
++nl;
printf("%d\n", nl);
}
```
在这个程序中,使用 `==` 进行相等判断,要注意与赋值运算符 `=` 区分。
##### 4.4 单词计数
单词计数程序统计输入中的行数、单词数和字符数。
```c
#include <stdio.h>
#define IN 1 /* inside a word */
#define OUT 0 /* outside a word */
/* count lines, words, and characters in input */
main()
{
int c, nl, nw, nc, state;
state = OUT;
nl = nw = nc = 0;
while ((c = getchar()) != EOF) {
++nc;
if (c == '\n')
++nl;
if (c == ' ' || c == '\n' || c == '\t')
state = OUT;
else if (state == OUT) {
state = IN;
++nw;
}
}
printf("%d %d %d\n", nl, nw, nc);
}
```
使用符号常量 `IN` 和 `OUT` 使程序更易读。`||` 表示逻辑或,`&&` 表示逻辑与,表达式按从左到右的顺序计算,一旦确定真假就停止计算。
#### 5. 数组的使用
可以编写一个程序来统计每个数字、空白字符(空格、制表符、换行符)和其他字符的出现次数。
```c
#include <stdio.h>
/* count digits, white space, others */
main()
{
int c, i, nwhite, nother;
int ndigit[10];
nwhite = nother = 0;
for (i = 0; i < 10; ++i)
ndigit[i] = 0;
while ((c = getchar()) != EOF)
if (c >= '0' && c <= '9')
++ndigit[c-'0'];
else if (c == ' ' || c == '\n' || c == '\t')
++nwhite;
else
++nother;
printf("digits =");
for (i = 0; i < 10; ++i)
printf(" %d", ndigit[i]);
printf(", white space = %d, other = %d\n",
nwhite, nother);
}
```
在C语言中,数组下标从0开始,因此 `ndigit` 数组的元素为 `ndigit[0]` 到 `ndigit[9]`。通过 `c - '0'` 可以得到字符 `c` 对应的数字值,作为数组的有效下标。
以下是字符分类判断的 mermaid 流程图:
```mermaid
graph TD;
A[开始] --> B{是否为数字};
B -- 是 --> C[ndigit[c-'0'] 加1];
B -- 否 --> D{是否为空白字符};
D -- 是 --> E[nwhite 加1];
D -- 否 --> F[nother 加1];
C --> G{是否结束};
E --> G;
F --> G;
G -- 否 --> B;
G -- 是 --> H[结束];
```
通过以上内容,我们学习了C语言中的格式化输出、`for` 循环、符号常量、字符处理以及数组的使用等基础知识,这些知识在实际编程中非常实用。后续可以通过练习相关的习题,进一步巩固这些知识。
### C语言编程基础:格式化输出、循环、符号常量及字符处理
#### 6. 习题解析
为了更好地掌握前面所学的知识,下面对相关习题进行解析。
##### 6.1 习题1 - 3:修改温度转换程序,在表格上方打印标题
要实现这个功能,只需要在原有的温度转换程序中添加打印标题的语句即可。以下是修改后的代码:
```c
#include <stdio.h>
/* print Fahrenheit-Celsius table */
main()
{
int fahr;
printf("Fahrenheit Celsius\n");
for (fahr = 0; fahr <= 300; fahr = fahr + 20)
printf("%3d %6.1f\n", fahr, (5.0/9.0)*(fahr-32));
}
```
在这个程序中,首先使用 `printf` 函数打印了表格的标题 “Fahrenheit Celsius”,然后再进行温度转换表格的输出。
##### 6.2 习题1 - 4:编写程序打印对应的摄氏度到华氏度表格
摄氏度到华氏度的转换公式为 $F = \frac{9}{5}C + 32$,根据这个公式可以编写如下程序:
```c
#include <stdio.h>
/* print Celsius-Fahrenheit table */
main()
{
int celsius;
printf("Celsius Fahrenheit\n");
for (celsius = 0; celsius <= 100; celsius = celsius + 10)
printf("%3d %6.1f\n", celsius, (9.0/5.0)*celsius + 32);
}
```
在这个程序中,使用 `for` 循环从 0 到 100 以 10 为步长遍历摄氏度的值,然后根据转换公式计算对应的华氏度,并使用 `printf` 函数输出表格。
##### 6.3 习题1 - 5:修改温度转换程序,以逆序打印表格
要实现逆序打印表格,只需要修改 `for` 循环的初始化、条件和增量部分。以下是修改后的代码:
```c
#include <stdio.h>
/* print Fahrenheit-Celsius table in reverse order */
main()
{
int fahr;
printf("Fahrenheit Celsius\n");
for (fahr = 300; fahr >= 0; fahr = fahr - 20)
printf("%3d %6.1f\n", fahr, (5.0/9.0)*(fahr-32));
}
```
在这个程序中,`for` 循环从 300 开始,每次减 20,直到 0 为止,从而实现了表格的逆序输出。
##### 6.4 习题1 - 6:验证表达式 `getchar() != EOF` 的值为 0 或 1
可以编写一个简单的程序来验证这个表达式的值:
```c
#include <stdio.h>
main()
{
int result;
result = (getchar() != EOF);
printf("%d\n", result);
}
```
在这个程序中,首先读取一个字符,然后判断该字符是否为 `EOF`,将判断结果赋值给 `result` 变量,最后使用 `printf` 函数输出结果。如果读取的字符不是 `EOF`,则结果为 1;如果是 `EOF`,则结果为 0。
##### 6.5 习题1 - 7:编写程序打印 `EOF` 的值
```c
#include <stdio.h>
main()
{
printf("%d\n", EOF);
}
```
这个程序非常简单,直接使用 `printf` 函数打印 `EOF` 的值。
##### 6.6 习题1 - 8:编写程序统计空白、制表符和换行符的数量
```c
#include <stdio.h>
main()
{
int c, blanks, tabs, newlines;
blanks = tabs = newlines = 0;
while ((c = getchar()) != EOF) {
if (c == ' ')
++blanks;
else if (c == '\t')
++tabs;
else if (c == '\n')
++newlines;
}
printf("Blanks: %d, Tabs: %d, Newlines: %d\n", blanks, tabs, newlines);
}
```
在这个程序中,使用 `while` 循环读取输入字符,根据字符的类型分别对空白、制表符和换行符的数量进行统计,最后输出统计结果。
##### 6.7 习题1 - 9:编写程序将输入复制到输出,将一个或多个连续的空白替换为单个空白
```c
#include <stdio.h>
main()
{
int c, in_blank;
in_blank = 0;
while ((c = getchar()) != EOF) {
if (c == ' ') {
if (!in_blank) {
putchar(c);
in_blank = 1;
}
} else {
putchar(c);
in_blank = 0;
}
}
}
```
在这个程序中,使用 `in_blank` 变量来标记是否处于连续空白的状态。如果读取到空白字符,且当前不在连续空白状态,则输出该空白字符并标记为处于连续空白状态;如果读取到非空白字符,则输出该字符并标记为不在连续空白状态。
##### 6.8 习题1 - 10:编写程序将输入复制到输出,将每个制表符替换为 `\t`,每个退格符替换为 `\b`,每个反斜杠替换为 `\\`
```c
#include <stdio.h>
main()
{
int c;
while ((c = getchar()) != EOF) {
if (c == '\t') {
putchar('\\');
putchar('t');
} else if (c == '\b') {
putchar('\\');
putchar('b');
} else if (c == '\\') {
putchar('\\');
putchar('\\');
} else {
putchar(c);
}
}
}
```
在这个程序中,使用 `while` 循环读取输入字符,根据字符的类型进行相应的替换和输出。如果读取到制表符、退格符或反斜杠,则分别输出对应的转义字符;如果读取到其他字符,则直接输出该字符。
##### 6.9 习题1 - 11:如何测试单词计数程序?哪些类型的输入最有可能发现潜在的错误?
测试单词计数程序可以从以下几个方面进行:
- **正常输入**:输入包含不同数量的单词、行和字符的文本,检查程序的输出是否正确。
- **边界情况**:输入空文本、只有一个单词的文本、只有一行的文本等,检查程序是否能正确处理这些边界情况。
- **特殊字符**:输入包含特殊字符(如标点符号、非字母数字字符)的文本,检查程序是否能正确识别单词。
最有可能发现潜在错误的输入类型包括:
- **连续的空白字符**:检查程序是否能正确处理连续的空白字符,避免将其误判为多个单词。
- **特殊字符和空白字符的组合**:检查程序是否能正确识别包含特殊字符和空白字符的单词。
- **空输入**:检查程序在输入为空时是否能正确输出结果。
##### 6.10 习题1 - 12:编写程序每行输出一个单词
```c
#include <stdio.h>
#define IN 1 /* inside a word */
#define OUT 0 /* outside a word */
main()
{
int c, state;
state = OUT;
while ((c = getchar()) != EOF) {
if (c == ' ' || c == '\t' || c == '\n') {
if (state == IN) {
putchar('\n');
state = OUT;
}
} else {
if (state == OUT)
state = IN;
putchar(c);
}
}
if (state == IN)
putchar('\n');
}
```
在这个程序中,使用 `state` 变量来标记是否处于单词内部。如果读取到空白字符,且当前处于单词内部,则输出换行符并标记为不在单词内部;如果读取到非空白字符,且当前不在单词内部,则标记为处于单词内部并输出该字符。最后,如果最后一个字符是单词的一部分,则输出换行符。
#### 7. 总结
通过前面的学习和习题练习,我们对C语言的一些基础知识有了更深入的理解。以下是对所学内容的总结:
| 知识点 | 描述 |
| ---- | ---- |
| 格式化输出 | `printf` 函数的格式化说明符可以控制输出的格式,宽度和精度可以省略。 |
| `for` 循环 | 是 `while` 循环的泛化形式,适用于初始化和增量操作是单个语句且逻辑相关的情况。 |
| 符号常量 | 使用 `#define` 语句定义有意义的符号常量,避免使用“魔法数字”。 |
| 字符输入输出 | `getchar` 和 `putchar` 函数可以实现逐字符的输入输出,`EOF` 用于表示输入结束。 |
| 数组 | 用于存储多个相同类型的元素,下标从 0 开始。 |
在实际编程中,我们可以灵活运用这些知识来解决各种问题。同时,通过不断地练习习题,可以提高我们的编程能力和解决问题的能力。希望大家在今后的学习中能够继续深入探索C语言的奥秘。
以下是整个学习过程的 mermaid 流程图:
```mermaid
graph LR;
A[学习格式化输出] --> B[学习 for 循环];
B --> C[学习符号常量];
C --> D[学习字符输入输出];
D --> E[学习数组的使用];
E --> F[练习习题];
F --> G[总结知识];
```
通过这个流程图,我们可以清晰地看到整个学习过程的步骤和顺序。从基础知识的学习到实际的习题练习,再到最后的知识总结,形成了一个完整的学习闭环。希望大家在学习过程中能够按照这个流程,逐步掌握C语言的编程技巧。
0
0
复制全文
相关推荐










