《C Primer Plus》第 11 章复习题和编程练习

一、复习题

1. 下面字符串的声明有什么问题？

int main(void)
{char name[] = {'F', 'e', 's', 's'};...
}

答：字符串是以空字符（‘\0’）结尾的一系列字符，上述代码声明的是一个字符数组，并不是字符串。

2. 下面的程序会打印什么？

#include <stdio.h>int main(void)
{char note[] = "See you at the snack bar.";char *ptr;ptr = note;puts(ptr);puts(++ptr);note[7] = '\0';puts(note);puts(++ptr);return 0;
}

答：结果如下：
See you at the snack bar.
ee you at the snack bar.
See you
e you

3. 下面的程序会打印什么？

#include <stdio.h>
#include <string.h>
int main(void)
{char food[] = "Yummy";char *ptr;ptr = food + strlen(food);while (--ptr >= food)puts(ptr);return 0;
}

答：结果如下：
y
my
mmy
ummy
Yummy

4. 下面的程序会打印什么内容？

#include <stdio.h>
#include <string.h>int main()
{char goldwyn[40] = "art of it all";char samuel[40] = "I read p";const char *quote = "the way through.";strcat(goldwyn, quote);strcat(samuel, goldwyn);puts(samuel);return 0;
}

答：该程序先把字符串 quote 拼接在字符串 goldwyn 后面，再把字符串 goldwyn 拼接在字符串 samuel 后面，（注意数组是否能容纳）。结果如下：
I read part of it all the way through.

5. 下面的练习涉及字符串、循环、指针和递增指针。首先，假设定义了下面的函数。

#include <stdio.h>char *pr(char *str)
{char *pc;pc = str;while (*pc)putchar(*pc++)do{putchar(*--pc);} while (pc - str);return (pc);
}

考虑下面的函数调用：
x = pr(“Ho Ho Ho!”);
a. 将打印什么？
b. x 是什么类型？
c. x 的值是什么？
d. 表达式 *–pc 是什么意思？与 --*pc 有何不同？
e. 如果用 *pc-- 替换 *–pc，会打印什么？
f. 两个 while 循环用来测试什么？
g. 如果 pr() 函数的参数是空字符串，会怎么样？
h. 必须在主调函数中做什么，才能让 pr() 函数正常运行？

答：
a. 将打印如下内容：
Ho Ho Ho!!oH oH oH

b. char*，即字符指针

c. 字符串 “Ho Ho Ho!” 的首地址

d. 表达式 *–pc 先对指针 pc 减 1，然后解引用；而 --*pc 先对指针 pc 解引用，然后对解引用后的值减 1

e. 少打印一个 ‘H’，即打印结果为：Ho Ho Ho!!oH oH o

f. 第 1 个 while 循环用来测试是否到达字符串末尾的空字符（‘\0’)，第 2 个 while 循环用来测试是否到达该字符串的首字符

g. 由于 *pc 为空字符（‘\0’），所以不会进入第 1 个 while 循环，而第二个 while 循环先对 pc 递减，则表达式 pc - str 永远为负，该循环一直进行。

h. 主调函数需要声明该函数 char* pr(char str); ，且主调函数需要声明指针变量 x，即 char* x 。

6. 假设有如下声明：

char sign = '$';

sign 占用多少字节的内存？‘$’ 占用多少字节的内存？“$” 占用多少字节的内存？

答：sign 是 char 变量，占 1 个字节的内存。‘$’ 是 char 字面值常量，占 1 个字节内存，而 “$” 是字符串字面值，末尾还有空字符（‘\0’），占 2 个字节内存。

7. 下面的程序会打印什么？

#include <stdio.h>
#include <string.h>
#define M1 "How are ya, sweetie? "
char M2[40] = "Beat the clock.";
char *M3 = "chat";
int main()
{char words[80];printf(M1);puts(M1);puts(M2);puts(M2 + 1);strcpy(words, M2);strcat(words, " Win a toy.");puts(words);words[4] = '\0';puts(words);while （*M3）puts(M3++);puts(--M3);puts(--M3);M3 = M1;puts(M3);return 0;
}

答：输出结果如下：
How are ya, sweetie? How are ya, sweetie?
Beat the clock.
eat the clock.
Beat the clock. Win a toy.
Win
chat
hat
at
t
t
at
How are ya, sweetie?

8. 下面的程序会打印什么？

#include <stdio.h>
int main()
{char str1[] = "gawsie";char str2[] = "bletonism";char *ps;int i = 0;for (ps = str1; *ps != '\0'; ps++){if (*ps == 'a' || *ps == 'e')putchar(*ps);else(*ps)--;putchar(*ps);}putchar('\n');while (str2[i] != '\0'){printf("%c", i % 3 ? str2[i] : '*');++i;}return 0;
}

答：结果如下：
faavrhee
*le*on*sm

9. 本章定义的 s_gets() 函数，用指针表示法代替数组表示法便可减少一个变量 i。请改写该函数

答：
程序设计分析： 指针表示法需要让该指针往后走，直到遇到换行符或者空字符。

代码如下：

char * s_gets(char * st, int n)
{char * ret_val;ret_val = fgets(st, n, stdin);if (ret_val){while (*st != '\n' && *st != '\0')++st;if (*st == '\n')*st = '\0';elsewhile (getchar() != '\n')continue;}return ret_val;
}	

10. strlen() 函数接受一个指向字符串的指针作为参数，并返回该字符串的长度。请编写一个这样的函数。

答：
程序设计分析： 使用 int 变量进行计数，直到查找到该字符串末尾的空字符（空字符不计入）。该函数返回类型为 int，接受一个 char 类型的指针

代码如下：

int my_strlen(char* s)
{int n = 0;while (*s++)++n;return n;
}

11. 对于本章定义的 s_gets() 函数，可以用 strchr() 函数代替其中的 while 循环来查找替换换行符。请改写该函数。

答：
程序设计分析： 使用 strchr() 函数，需要包含头文件 string.h

代码如下：

// 头文件
#include <string.h>char * s_gets(char * st, int n)
{char * ret_val;char * find;ret_val = fgets(st, n, stdin);if (ret_val){find = strchr(st, '\n');if (find)*find = '\0';elsewhile (getchar() != '\n')continue;}return ret_val;
}	

12. 设计一个函数，接受一个指向字符串的指针，返回指向该字符串中第一个空格字符的指针，如果未找到空格字符，则返回空指针。

答：
程序设计分析： 使用循环逐个字符查找，若遇到空格则停止返回，若遇到空字符，则返回空指针。

代码如下：

char* find_blank(char* s)
{while (*s && *s != ' ')++s;// 判断if (*s)return s;elsereturn null;
｝

13. 重写程序清单 11.21，使用 ctype.h 头文件中的函数，需求无论用户选择大写还是小写，该程序都能正确识别答案。

答：
程序设计分析： 设计一个函数，该函数接受一个字符串，然后把该字符串的字母都编程大写。然后再输入答案之后，执行该函数。

代码如下：

// 头文件
#include <stdio.h>
#include <string.h>// 常量声明
#define ANSWER "Grant"
#define SIZE 40// 函数声明
char * s_gets(char * st, int n);
void upper(char* str);int main()
{char try[SIZE];puts("Who is buried in Grant's tomb?");s_gets(try, SIZE);upper(try);while (strcmp(try, ANSWER) != 0){puts("No, that's wrong. Try again.");s_gets(try, SIZE);upper(try);}puts("That's right);return 0;
}// 函数定义
char * s_gets(char * st, int n)
{char * ret_val;char * find;ret_val = fgets(st, n, stdin);if (ret_val){find = strchr(st, '\n');if (find)*find = '\0';elsewhile (getchar() != '\n')continue;}return ret_val;
}void upper(char* str)
{while (*str){*str = toupper(*str);++str;}
}	

二、编程练习

1. 设计并测试一个函数，从输入中获取 n 个字符（包括空白、制表符、换行符），把结果存储在一个数组里，它的地址被传递作为一个参数。

答：
程序设计分析： 该函数的返回类型为 void，接受一个字符指针和 int 值作为参数。

代码如下：

#include <stdio.h>// 常量声明
#define SIZE 100// 函数声明
void get_n_char(char* arr, int n);int main()
{// 所需变量char arr[100] = { 0 };int n = 0;// 输入printf("请输入带输入的字符数量：");scanf("%d", &n);get_n_char(arr, n);return 0;
}// 函数定义
void get_n_char(char* arr, int n)
{int i = 0;do{arr[i] = getchar();} while (arr[i] != EOF && ++i < n);
}

2. 修改编程练习 1 的函数，在 n 个字符后停止，或在督导第 1 个空白、制表符或换行符时停止，那个先遇到哪个停止。不能只使用 scanf()。

答：
程序设计分析： 读取字符后检查是否为空白，若为空白则使用 break 跳出循环。

代码如下：

#include <stdio.h>
#include <ctype.h>// 常量声明
#define SIZE 100// 函数声明
void get_n_char(char* arr, int n);int main()
{// 所需变量char arr[100] = { 0 };int n = 0;// 输入printf("请输入带输入的字符数量：");scanf("%d", &n);get_n_char(arr, n);return 0;
}// 函数定义
void get_n_char(char* arr, int n)
{int i = 0;do{arr[i] = getchar();// 是空白就跳出循环if (isspace(arr[i]))break;} while (arr[i] != EOF && ++i < n);
}

3. 设计并测试一个函数，从一行输入中把一个单词读入一个数组中，并丢弃输入行中的其余字符。该函数应该跳过第 1 个非空白字符前面的所有空白。将一个单词定义为没有空白、制表符或换行符的字符序列。

答：
程序设计分析： 该函数检验两次空白，第 1 次检验直到单词开头，第 2 次检验直到单词末尾。

代码如下：

#include <stdio.h>
#include <ctype.h>// 常量声明
#define SIZE 100// 函数声明
char* get_word(char* arr);int main()
{// 所需变量char arr[SIZE] = { 0 };// 输入一个单词get_word(arr);// 输出验证puts(arr);return 0;
}// 函数定义
char* get_word(char* arr)
{char temp[SIZE] = { 0 };char* p = temp;// 读取一行输入fgets(temp, SIZE, stdin);// 删除前面的空白while (isspace(*p) && *p)++p;// 读取单词while (!isspace(*p) && *p)*arr++ = *p++;return arr;
}

4. 设计并测试一个函数，它类似于编程练习 3 的描述，只不过它通过第 2 个参数指明可以读取的最大字符数。

答：
程序设计分析： 只不过在上一题的代码中添加一个输入字符限制的条件罢了。函数声明、函数调用和函数定义做相关修改。

代码如下：

#include <stdio.h>
#include <ctype.h>// 常量声明
#define SIZE 100
#define LIT 5// 函数声明
char* get_word(char* arr, int n);int main()
{// 所需变量char arr[SIZE] = { 0 };// 输入一个单词get_word(arr, LIT);// 输出验证puts(arr);return 0;
}// 函数定义
char* get_word(char* arr, int n)
{char temp[SIZE] = { 0 };char* p = temp;int i = 0;// 读取一行输入fgets(temp, SIZE, stdin);// 删除前面的空白while (isspace(*p) && *p)++p;// 读取单词while (!isspace(*p) && *p){*arr++ = *p++;// 检测是否超出限制if (++i >= n)break;}return arr;
}

5. 设计并测试一个函数，搜索第 1 个函数形参指定的字符串，在其中查找第 2 个函数形参指定的字符首次出现的位置。如果成功，则返回该字符的指针，如果在字符串中未找到指定字符，则返回空指针（该函数的功能与 strchar() 函数相同）。在一个完整的程序中测试该函数，使用一个循环给函数输入值。

答：
程序设计分析： 该函数返回类型为 char*，接受一个 char* 值和 char 值。在该函数中使用循环遍历字符串，查找目标字符首次出现的位置。

代码如下：

#include <stdio.h>// 常量声明
#define SIZE 40// 函数声明
char* find_char(char* str, char ch);int main()
{// 所需变量char temp[SIZE] = { 0 };char ch = 'c';// 输入printf("请输入一段字符：");while (fgets(temp, SIZE, stdin) && temp[0] != '\n'){char* position = find_char(temp, ch);if (position)printf("%c 字符首次出现的地址为：%p\n", ch, position);elseprintf("未找到字符 %c\n", ch);// 下一个printf("请输入下一段字符：");}return 0;
}// 函数定义
char* find_char(char* str, char ch)
{while (*str){if (*str == ch)return str;else++str;}return NULL;
}

6. 编写一个名为 is_within() 的函数，该函数以一个字符和一个指向字符串的指针作为两个函数的形参。如果指定的字符在字符串中，该函数返回一个非零值（即为真）；否则，返回 0（即为加）。在一个完整的函数中测试该函数，使用一个循环给函数提供输入值。

答：
程序设计分析： 该题目和上一题几乎完全一样，只不过返回值用 0 或非 0 值代替了。

代码如下：

#include <stdio.h>// 常量声明
#define SIZE 40// 函数声明
int is_within(char ch, char* str);int main()
{// 所需变量char temp[SIZE] = { 0 };char ch = 'c';// 输入printf("请输入一段字符：");while (fgets(temp, SIZE, stdin) && temp[0] != '\n'){if (is_within(ch, temp))printf("该字符串中包含字符 %c\n", ch);elseprintf("该字符串中没有字符 %c\n", ch);// 下一个printf("请输入下一段字符：");}return 0;
}// 函数定义
int is_within(char ch, char* str)
{while (*str){if (*str == ch)return 1;else++str;}return 0;
}

7. strncpy(s1, s2, n) 函数把 s2 中的 n 个字符复制至 s1 中，截断 s2，或者根据需要在末尾添加空字符。如果 s2 的长度是 n 或者大于 n，目标字符串不能以空字符结尾。该函数返回 s1.自己编写一个这样的函数，使用一个循环给函数提供输入值。

答：
程序设计分析： 该函数需要对源字符串的长度和限制拷贝的长度进行比较，来判断是否需要在末尾添加换行符。

代码如下：

#include <stdio.h>// 常量声明
#define SIZE 100// 函数声明
char* my_strncpy(char* t, char* s, int n);int main()
{// 所需变量char source[SIZE] = { 0 };char target[SIZE] = { 0 };int n = 0;do{printf("请输入要拷贝的字符串：");fgets(source, SIZE, stdin);// 输入空行退出循环if (source[0] == '\n')break;printf("请输入需要拷贝的字符数：");scanf("%d", &n);// 清理换行符while (getchar() != '\n')continue;// 拷贝输出my_strncpy(target, source, n);puts(target);} while (1);return 0;
}// 函数定义
char* my_strncpy(char* t, char* s, int n)
{char* ret = t;int i = 0;while (s[i] && i < n){t[i] = s[i];++i;}if (i < n)t[i] = '\0';return ret;
}

**8. 编写一个名为 string_in() 的函数，该函数以两个指向字符串的指针作为参数。如果第 2 个字符串包含第 1 个字符串，该函数将返回第 1 个字符串开始的地址。例如，string_in(“hats”, “at”) 将返回 hats 中 a 的地址。否则，返回空指针。在一个完整的程序中测试该函数，使用一个循环给该函数提供值。
**

答：
程序设计分析： 使用 string.h 头文件中的 strchar() 函数，找到目标字符串的首字符，然后使用 strcnmp() 函数进行比较。若不是，则往后继续如此。

代码如下：

#include <stdio.h>
#include <string.h>// 常量声明
#define SIZE 40// 函数声明
char* string_in(char* s, char* t);int main()
{// 所需变量char source[SIZE] = { 0 };char target[SIZE] = { 0 };char* p = NULL;// 输入do{printf("输入源字符串：");fgets(source, SIZE, stdin);// 如果输入空行结束循环if (source[0] == '\n')break;printf("输入需要找的字符串：");scanf("%s", target);// 清理换行符while (getchar() != '\n')continue;// 查找p = string_in(source, target);if (p)printf("地址：%p\n", p);elseprintf("没有\n");} while (1);return 0;
}// 函数定义
char* string_in(char* s, char* t)
{int len = strlen(t);while (s = strchr(s, *t)){if (!strncmp(s, t, len))return s;else++s;}return NULL;
}

9. 编写一个函数把字符串的内容用其反序字符串代替。在一个完整的程序中测试该函数，使用一个循环给函数提供输入值。

答：
程序设计分析： 该函数实现字符串的逆序，使用 strlen() 函数，找到字符串的末尾，然后与开头一个一个对调。

代码如下：

#include <stdio.h>
#include <string.h>// 常量声明
#define SIZE 100// 函数声明
void reverse_str(char* str);int main()
{// 所需变量char str[SIZE] = { 0 };// 输入do{printf("请输入字符串: ");fgets(str, SIZE, stdin);// 空行结束循环if (str[0] == '\n')break;// 把字符串 str 中的换行符删掉int len = strlen(str);if (str[len - 1] == '\n')str[len - 1] = '\0';reverse_str(str);printf("逆序后的结果: ");fputs(str, stdout);putchar('\n');} while (1);return 0;
}// 函数定义
void reverse_str(char* str)
{char* begin = str;char* end = str + strlen(str) - 1;char temp = 0;while (begin < end){temp = *begin;*begin = *end;*end = temp;// 下一对字符++begin;--end;}
}

10. 编写一个函数，该函数以一个字符串作为参数，并可以删除字符串中的空格。在一个程序中测试该函数，使用循环读取输入行，直到用户输入一个空行。该程序应该应用该函数读取每个输入的字符串，并显示处理后的结果。

答：
程序设计分析： 该函数返回 int 值，若读取空行返回 0，否则返回 1。使用循环遍历该字符串，找到空格并删除，然后把后面的字符往前面移动。

代码如下：

#include <stdio.h>// 常量声明
#define SIZE 100// 函数声明
int delete_bs(char* str);int main()
{// 所需变量char str[SIZE] = { 0 };// 进入循环while (delete_bs(str)){// 输出printf("删除空格后的：");fputs(str, stdout);}return 0;
}// 函数定义
int delete_bs(char* str)
{// 输入printf("请输入字符串：");fgets(str, SIZE, stdin);// 判断是否为空行if (str[0] == '\n')return 0;// 删除空格while (*str){// 如果是空格，就把后面的字符往前面挪if (*str == ' '){char* p = str + 1;char* b = str;while (*p && *p == ' ')++p;// 如果到末尾if (*p == '\0')*str = '\0';// 挪移while (*p){*b++ = *p++;}*b = *p;}// 下一个字符++str;}return 1;
}

11. 编写一个程序，读入 10 个字符串或者在读到 EOF 时停止。该程序为用户提供一个有 5 个选项的菜单，5 个选项分别是打印原始字符串列表，以 ASCII 码中的顺序打印字符串，按长度递增顺序打印字符串，按字符串中第一个单词的长度打印字符串，退出。菜单可以循环显示，除非用户选择“退出”选项。当然，该程序要能真正实现菜单中各选项的功能。

答：
程序设计分析： 上述前四个选项各设计为一个函数，然后还有一个打印原字符串函数和菜单函数。（作者的代码有许多冗余的部分，可以试着拆成一个函数，缩减代码的行数）

代码如下：

#include <stdio.h>
#include <ctype.h>
#include <string.h>// 常量声明
#define NUM 10
#define SIZE 100// 函数声明
void menu();
void print_origin(char str[][SIZE], int n);
void print_ascii(char str[][SIZE], int n);
void print_length(char str[][SIZE], int n);
void print_first_word(char str[][SIZE], int n);
void swap(char** s1, char** s2);
int first_word(char* str);int main()
{// 所需变量int i = 0, select = 0;char str[NUM][SIZE] = { 0 };// 输入printf("Please input 10 strings seperate by enter.\n");for (i = 0; i < NUM; ++i){fgets(str[i], SIZE, stdin);}// 进入循环do{// 显示菜单menu();// 选择scanf("%d", &select);switch (select){case 1 :print_origin(str, NUM);break;case 2 :print_ascii(str, NUM);break;case 3 :print_length(str, NUM);break;case 4 :print_first_word(str, NUM);break;default :printf("Input error, retry.\n");}} while (select != 5);return 0;
}// 函数定义
void menu()
{printf("*******************************************************\n");printf("1）print_origin                   2）print_ascii\n");printf("3）print_length                   4）print_first_word\n");printf("5）quit\n");printf("*******************************************************\n");
}void print_origin(char str[][SIZE], int n)
{int i;for (i = 0; i < n; ++i)fputs(str[i], stdout);
}void print_ascii(char str[][SIZE], int n)
{char* pstr[NUM] = { 0 };int i;for (i = 0; i < NUM; ++i)pstr[i] = str[i];// 排序for (i = 0; i < NUM - 1; ++i){int j;for (j = 0; j < NUM - 1 - i; ++j){if (strcmp(pstr[j], pstr[j + 1]) > 0){swap(&pstr[j], &pstr[j + 1]);}}}// 输出printf("Length:\n");for (i = 0; i < NUM; ++i)fputs(pstr[i], stdout);
}void print_length(char str[][SIZE], int n)
{char* pstr[NUM] = { 0 };int i;for (i = 0; i < NUM; ++i)pstr[i] = str[i];// 排序for (i = 0; i < NUM - 1; ++i){int j;for (j = 0; j < NUM - 1 - i; ++j){if (strlen(pstr[j]) > strlen(pstr[j + 1])){swap(&pstr[j], &pstr[j + 1]);}}}// 输出printf("Length:\n");for (i = 0; i < NUM; ++i)fputs(pstr[i], stdout);
}void print_first_word(char str[][SIZE], int n)
{char* pstr[NUM] = { 0 };int i;for (i = 0; i < NUM; ++i)pstr[i] = str[i];// 排序for (i = 0; i < NUM - 1; ++i){int j;for (j = 0; j < NUM - 1 - i; ++j){if (first_word(pstr[j]) > first_word(pstr[j + 1])){swap(&pstr[j], &pstr[j + 1]);}}}// 输出printf("Length:\n");for (i = 0; i < NUM; ++i)fputs(pstr[i], stdout);
}void swap(char** s1, char** s2)
{char* temp = *s1;*s1 = *s2;*s2 = temp;
}int first_word(char* str)
{int len = 0;// 删除前面的空白while (*str && isspace(*str))++str;// 计算长度while (*str && !isspace(*str)){++len;++str;}return len;
}

12. 编写一个程序，读取输入，直到读到 EOF，报告读入的单词数、大写字母数、小写字母数、标点符号数和数字字符数。使用 ctype.h 头文件中的函数。

答：
程序设计分析： 需要额外使用变量来判断是否为一个单词。

代码如下：

#include <stdio.h>
#include <ctype.h>int main()
{// 所需变量int ch = 0;int is_word = 0;int words = 0, u_words = 0, l_words = 0, puncts = 0, digits = 0;// 输入while ((ch = getchar()) != EOF){// 单个字符判断if (isdigit(ch))++digits;else if (isupper(ch))++u_words;else if (islower(ch))++l_words;else if (ispunct(ch))++puncts;// 判断是否为一个单词if (isspace(ch) && is_word){++words;is_word = 0;}if (!isspace(ch) && !is_word)is_word = 1;}// 输出printf("单词数：%d\n", words);printf("大写字母数：%d\n", u_words);printf("小写字母数：%d\n", l_words);printf("标点符号数：%d\n", puncts);printf("数字字符数：%d\n", digits);return 0;
}

13. 编写一个程序，反序显示命令行参数中的单词。例如，命令行参数是 see you later，该程序打印 later you see。

答：
程序设计分析： 该反序只是把命令行的参数倒过来打印。

代码如下：

#include <stdio.h>int main(int argc, char* argv[])
{if (argc < 2)printf("Error! not enough parameter to display!\n");else{for (int i = argc; i > 1; --i){printf("%s ", argv[i - 1]);}putchar('\n');}
}

14. 编写一个通过命令行参数运行的程序，用来计算幂。第 1 个命令行参数是浮点数，可作为幂的底数，第 2 个参数是整数，可作为幂的指数。

答：
程序设计分析： 该程序和普通的幂函数计算一样，只是使用了命令行参数。

代码如下：

#include <stdio.h>
#include <stdlib.h>int main(int argc, char* argv[])
{if (argc != 3){printf("Error argument. Please retry.\n");return 0;}float f = atof(argv[1]);int n = atoi(argv[2]);float result = 1;// 计算幂int i;for (i = 0; i < n; ++i){result *= f;}// 输出printf("该幂为：%.1lf\n", result);return 0;
}

15. 使用字符分类函数实现 atoi() 函数。如果输入的字符串不是纯数字，该函数返回 0。

答：
程序设计分析： 该函数接受一个字符串，把该字符串转换为数字，若包含非数字则返回 0。

代码如下：

#include <stdio.h>
#include <ctype.h>// 函数声明
int myatoi(char* str);int main()
{char temp[50] = { 0 };printf("请输入一串数字：");scanf("%s", temp);printf("该数字为：%d\n", myatoi(temp));return 0;
}// 函数定义
int myatoi(char* str)
{int result = 0;while (*str){if (isdigit(*str))result = result * 10 + (*str - '0');elsereturn 0;// 下一个字符++str;}return result;
}

16. 编写一个程序，用于读取输入，直至读到文件结尾，然后把字符串打印出来。该程序识别和实现下面的命令行参数：

答：
程序设计分析： 把上述操作三个操作分别定义成 3 个函数，然后根据命令行参数进行判断。

代码如下：

#include <stdio.h>
#include <ctype.h>// 常量声明
#define SIZE 256// 函数声明
void print(char* str);
void print_upper(char* str);
void print_lower(char* str);int main(int argc, char* argv[])
{char str[SIZE] = { 0 };char ch = 0;if (argc < 2)ch = 'p';elsech = argv[1][1];  // 忽略 - 号// 输入printf("Enter a string to convert:");fgets(str, SIZE, stdin);switch (ch){case 'P':case 'p' :print(str);break;case 'u' :case 'U':print_upper(str);break;case 'L' :case 'l' :print_lower(str);break;}return 0;
}// 函数定义
void print(char* str)
{printf("Original:\n");fputs(str, stdout);
}void print_upper(char* str)
{char* p = str;while (*p){*p = toupper(*p);++p;}printf("Upper:\n");fputs(str, stdout);
}void print_lower(char* str)
{char* p = str;while (*p){*p = tolower(*p);++p;}printf("Lower:\n");fputs(str, stdout);
}