C程序设计语言——导言
1. Hello, world
#include
main()
{
printf("Hello, world\n");
}
b. printf是一个用于打印输出的库函数。顺便指出，printf函数并不是C语言本身的一部分，C语言本身并没有定义输入输出功能。printf仅仅是标准库函数中的一个有用的函数而已，这些标准库函数在C语言程序中通常可以使用。但是，ANSI标准定义了printf函数的行为，因此对每个符合该标准的编译器和库来说，该函数的属性都是相同的。
c. 类似于\n的转义字符序列为表示无法输入的字符或不可见的字符提供了一种通用的可扩充的机制。
2.字符输入/输出
标准库提供的输入/输出模型非常简单。无论文本从何处输入，输出到何处，其输入/输出都是按照字符流的方式处理。文本流是由多行字符构成的字符序列，而每行字符则由0个或多个字符组成，行末是一个换行符。标准库负责使每个输入/输出流都遵守这一模型。许多程序不过是这一模型的扩充版本而已。
标准库提供了一次读/写一个字符的函数，其中最简单的是getchar和putchar这两个函数。每次调用时，getchar函数从文本流中读入下一个输入字符，并将其作为结果值返回。调用putchar函数时将打印一个字符，例如putchar(c)将整型变量c的内容以字符的形式打印出来，显示在屏幕上。使用这两个函数的最简单的例子是：将输入逐字符地复制到输出中。
2.1. 将输入复制到输出
#include
/**<将输入复制到输出；版本1 */
main()
{
int c;
c = getchar();
while (c != EOF)
{
putchar(c);
c = getchar();
}
}
b. 关于EOF。EOF表示文件结束，EOF定义在头文件中，是一个整型数，其具体数值不重要，只要它与任何char类型的值都不相同即可。这里使用符号常量，可以确保程序不需要依赖于其对应的任何特定的数值。在黑框中，键入CTRL+Z即表示EOF。用下面的程序得知，EOF在本机上显示为-1。
#include
main()
{
printf("%d",EOF);
} #include
/**<将输入复制到输出；版本2 */
main()
{
int c;
while ((c = getchar()) != EOF)
putchar(c);
}
2.2 字符计数
#include
/**< 统计输入的字符数；版本1 */
main()
{
long nc;
nc = 0;
while (getchar() != EOF)
++nc;
printf("%1d\n", nc);
}
b. ++nc可以用nc = nc + 1进行代替。但++nc效率更高。
考虑一个更精炼的版本：
#include
/**< 统计输入的字符数；版本2 */
main()
{
double nc;
for (nc = 0; getchar() != EOF; ++nc)
;
printf("%.0f\n", nc);
}
2.3. 行计数
#include
/**< 行计数 */
main()
{
int c, nl;
nl = 0;
while ((c = getchar()) != EOF)
if (c == '\n')
++nl;
printf("%d\n", nl);
}
b. 单引号中的字符表示一个整型值，该值等于此字符在机器字符集中对应的数值，即字符常量。比如，'A'是一个字符常量，在ASCII字符集中其值为65。用'A'比用65要好，因为'A'的意义更清楚，且与特定的字符集无关。'\n'在表达式中不过是一个整型数，而"\n"是一个仅包含一个字符的字符串常量。
#include
#define BLANK ' '
/** 练习 1-9
*
* 编写一个将输入复制到输出的程序，
* 将其中连续的多个空格用一个空格代替。
*
*
*/
main()
{
int c, last;
while ((c = getchar()) != EOF)
{
if (c != BLANK || last != BLANK)
putchar(c);
last = c;
}
} #include
#define BACKSLASH '\\'
#define BACKSPACE '\b'
#define TAB '\t'
/** 练习 1-10
*
* 编写一个将输入复制到输出的程序，
* 将制表符替换为\t，
* 将回退符替换为\b，
* 将反斜杠替换为\\，
* 将制表符和回退符以可见的方式显示出来。
*/
main()
{
int c;
while ((c = getchar()) != EOF)
{
if (c == BACKSLASH)
printf("\\\\");
else if (c == BACKSPACE)
printf("\b");
else if (c == TAB)
printf("\t");
else
putchar(c);
}
}
2.4. 单词计数
#include
#define IN 1 /**< 在单词内 */
#define OUT 0 /**< 在单词外 */
/**< 统计输入的行数、单词数与字符数 */
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", nl, nw, nc);
}
b. 关于nl = nw = nc = 0。在兼有值与赋值两种功能的表达式中，赋值结合次序是从右到左。该语句等同于nl = ( nw = ( nc = 0 ) )。
#include
/** 练习 1-12
*
* 编写一个程序，
* 以每行一个单词的形式打印其输入。
*
*
*/
main()
{
int c, INSPACE; /**< INSPACE记录之前是否位于单词中。0为在，1为不在。 */
INSPACE = 0;
while ((c = getchar()) != EOF)
{
if (c == '\t' || c == '\n' || c == ' ')
{
if (INSPACE == 0)/**< 之前在单词中，而现在不在 */
putchar('\n');
INSPACE = 1;
}
else
{
INSPACE = 0;
putchar(c);
}
}
}
3. 函数
#include
/**< 计算x的y次方 */
int power(int x, int y);
main()
{
int i;
for (i = 0; i < 10; ++i)
printf("%d\t%d\t%d\n", i, power(2, i), power(-3, i));
return 0;
}
int power(int x, int y)
{
int i, p;
p = 1;
for (i = 1; i <= y; ++i)
p = p * x;
return p;
}
b. 关于main函数末的return 0语句。main本身也是函数，因此可以向其调用者返回一个值，该调用者实际上就是程序的执行环境。一般而言，返回值为0表示正常终止，返回值非0表示出现异常情况或出错结束条件。为简洁起见，前面的main函数都省略了return语句，但在之后的main函数中都包含return语句，提醒大家注意，程序还要向其执行环境返回状态。
4. 字符数组
#include
#define MAXLINE 1000 /**< 允许的输入行的最大长度 */
int getline(char line[], int maxline);
void copy(char to[], char from[]);
/**< 读入一组文本行，并把其中最长的文本行打印出来 */
main()
{
int len; /**< 当前行长度 */
int max; /**< 目前发现的最大行长度 */
char line[MAXLINE]; /**< 当前输入行 */
char longest[MAXLINE]; /**< 用于保存最长的行 */
max = 0;
while ((len = getline(line, MAXLINE)) > 0)
{
if (len > max)
{
max = len;
copy(longest, line);
}
}
if (max > 0) /**< 存在这样的最长行 */
printf("%s", longest);
return 0;
}
/**< 将一行读入s中并返回其长度 */
int getline(char s[], int lim)
{
int c, i;
for (i = 0; i < lim - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
s[i] =c;
if (c == '\n')
{
s[i] = c;
++i;
}
s[i] = '\0'; /**< 标志字符串的结束 */
return i;
}
/**< 将from复制到to */
void copy(char to[], char from[])
{
int i;
i = 0;
while ((to[i] = from[i]) != '\0')
++i;
}
| h | e | l | l | o | \n | \0 |
#include
#define MAXLINE 1000
#define CRITICALVALUE 80
int getline(char line[], int maxline);
/** 练习 1-17
*
* 打印长度大于80个字符的所有输入行
*
*/
main()
{
int c;
int len = 0;
char line[MAXLINE];
while ((len = getline(line,MAXLINE)) > 0)
if (len > CRITICALVALUE)
printf("%s", line);
return 0;
}
int getline(char s[], int lim)
{
int c, i;
for (i = 0; i < lim - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
s[i] = c;
if (c == '\n')
{
s[i] = c;
++i;
}
s[i] = '\0';
return i;
}
#include
#define MAXLINE 1000
int getline(char line[], int maxline);
void reverse(char line[], int length);
/** 练习 1-19
*
* 编写函数reverse(s)，将字符串中的字符顺序颠倒过来。
* 每次颠倒一个输入行中的字符顺序。
*/
main()
{
int len;
char line[MAXLINE];
while ((len = getline(line, MAXLINE)) > 0)
{
reverse(line, len);
printf("%s", line);
}
return 0;
}
int getline(char s[], int lim)
{
int c, len;
for (len = 0; len < lim - 1 && (c = getchar()) != EOF && c != '\n'; ++len)
s[len] = c;
if (c == '\n')
{
s[len] = c;
++len;
}
s[len] = '\0';
return len;
}
void reverse(char s[], int len)
{
int i;
for (i = 0; i < len / 2; ++i)
{
int tmp = s[i];
s[i] = s[len - 2 - i];
s[len - 2 - i] = tmp;
}
}
5. 外部变量与作用域
外部变量必须定义在所有函数之外，且只能定义一次，定以后编译程序将为它分配存储单元。在每个需要访问外部变量的函数中，必须声明对应的外部变量，此时说明其类型。声明时可以用extern语句显式声明，也可以通过上下文隐式声明。
#include
#define MAXLINE 1000 /**< 允许的输入行的最大长度 */
int max;
char line[MAXLINE];
char longest[MAXLINE];
int getline();
void copy();
/**< 读入一组文本行，并把其中最长的文本行打印出来：特殊版本 */
main()
{
int len; /**< 当前行长度 */
extern int max; /**< 目前发现的最大行长度 */
extern char longest[MAXLINE]; /**< 用于保存最长的行 */
max = 0;
while ((len = getline()) > 0)
{
if (len > max)
{
max = len;
copy();
}
}
if (max > 0) /**< 存在这样的最长行 */
printf("%s", longest);
return 0;
}
/**< 读入并返回其长度 */
int getline(void)
{
int c, i;
extern char line[];
for (i = 0; i < MAXLINE - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
line[i] =c;
if (c == '\n')
{
line[i] = c;
++i;
}
line[i] = '\0'; /**< 标志字符串的结束 */
return i;
}
/**< 复制 */
void copy(char to[], char from[])
{
int i;
extern char line[], longest[];
i = 0;
while ((longest[i] = line[i]) != '\0')
++i;
}
如果程序包含在多个源文件中，而某个变量在文件1中定义，在文件2和文件3中使用，那么在文件2和文件3中就需要使用extern声明来建立该变量与其定义之间的联系。人们通常把变量和函数的extern声明放在一个单独的头文件中，并在每个源文件的开头使用#include语句把所要用的头文件包含进来。
过分依赖外部变量会导致一定的风险，因为它会使程序中的数据关系模糊不清——外部变量的值可能会被意外地或不经意地修改，而程序的修改变得十分困难。上面所示的代码V2比V1要差，原因在于：V2使用了外部变量；V2中的函数把所操纵的变量名直接写入了函数，从而使这两个有用的函数失去了通用性。