C标准库函数浅析

longsteg 2012-11-02

展开全文

使用C语言的一半价值在于使用其标准库函数。当然，灵活的for循环以及数组和指针之间的相似性也是C语言的重要价值。在解决实际问题时，能方便地操作字符串和文件等对象是最重要的，有些语言能出色地完成其中的一部分工作，另一些语言能出色地完成其中的另一部分工作，然而，没有几种语言能象C语言那样能出色地完成全部工作。
c标准库中还缺少很多函数，例如投有图形函数，甚至没有全屏幕文本操作函数，signal机制也相当弱(见12．10)，并且根本没有对多任务或使用常规内存以外的内存提供支持。尽管C标准库存在上述缺陷，但它毕竟为所有的程序都提供了一套基本功能，不管这些程序是运行在多任务、多窗口的环境下，还是运行在简单的终端上，或者是运行在一台昂贵的烤面包机上。
C标准库中所缺的函数可以从其它途径获得，例如编译程序开发商和第三方的函数库都会提供一些函数，这些函数都是事实上的标准函数。然而，标准库中的函数已经为程序设计提供了一个非常坚实的基础。

    12．1 为什么应该使用标准库函数而不要自己编写函数?
    标准库函数有三点好处：准确性、高效性和可移植性。
    准确性：编译程序的开发商通常会保证标准库函数的准确性。更重要的是。至少开发商做了全面的检测来证实其准确性，这比你所能做到的更加全面(有些昂贵的测试工具能使这项工作更加容易)。
    高效性：优秀的C程序员会大量使用标准库函数，而内行的编译程序开发商也知道这一点。如果开发商能提供一套出色的标准库函数，他就会在竞争中占优势。当对相互竞争的编译程序的效率进行比较时，一套出色的标准库函数将起到决定性的作用。因此，开发商比你更有动力，并且有更多的时间，去开发一套高效的标准库函数。
    可移植性：在软件要求不断变化的情况下，标准库函数在任何计算机上，对任何编译程序都具有同样的功能，并且表达同样的含义，因此它们是C程序员屈指可数的几种依靠之一。
    有趣的是，你很难找到一项关于标准库函数的最标准的信息。对于每一个函数，都需要有一个(在极少数情况下需要两个)保证能将该函数的原型提供给你的头文件 (在调用任何一个函数时，都应该包含其原型，见8．2)。有趣的是什么呢?这个头文件可能并不是真正包含该函数原型的文件，在有些(非常糟糕!)情况下，甚至由编译程序手册推荐的头文件都不一定正确。对于宏定义，typedef和全局变量，同样会发生这种情况。
    为了找到“正确的”头文件，你可以在一份ANSI／ISO c标准的拷贝中查阅相应的函数。如果你手头没有这样一份拷贝，你可以使用表12．2。
    请参见：
    8．2为什么要使用函数原型?
    12．2 为了定义我要使用的标准库函数，我需要使用哪些头文件?

    12．2 为了定义我要使用的标准库函数，我需要使用哪些头文件?
    你需要使用ANSI／ISO标准规定的你应该使用的那些头文件，见表12．2。
    有趣的是，这些文件并不一定定义你要使用的函数。例如，如果你要使用宏EDOM，你的编译程序保证你能通过包含(errno．h)得到这个宏，而 (errno．h)可能定义了宏EDOM，也可能只包含定义这个宏的头文件。更糟的是，编译程序的下一个版本可能会在另一个地方定义宏EDOM。
    因此，你不用去寻找真正定义一个函数的头文件并使用这个文件，而应该使用那个被假定为定义了该函数的头文件，这样做是肯定可行的。
    有几个名字在多个头文件中被定义：NULL，size_t和wchar_t。如果你需要其中一个名字的定义，可以使用任意一个定义了该名字的头文件((stddef．h>是一个较好的选择，它不仅小，而且包含了常用的宏定义和类型定义)。

               表12．2标准库函数的头文件
----------------------------------------------------------------------
函数                               头文件
----------------------------------------------------------------------
abort                                stdlib. h
abs                                  stdlib. h
acos                                 math. h
asctime                              time. h
asin                                 math. h
assert                               assert.h
atan                                 math. h
atan2                                math. h
atexit                               stdlib. h
atof                                 stdlib. h
atoi                                 stdlib. h
atol                                 stdlib. h
bsearch                              stdlib. h
BUFSIZ                               stdio. h
calloc                               stdlib. h
ceil                                 math. h
clearerr                             stdio. h
clock                                time. h
CLOCKS-PER-SEC                       time. h
clock_t                              time. h
cos                                  math. h
cosh                                 math. h
ctime                                time. h
difftime                             time. h
div                                  stdlib. h
div_t                                stdlib. h
EDOM                                 errno. h
EOF                                  stdio. h
ERANGE                               errno. h
errno                                errno. h
exit                                 stdlib. h
EXIT_FAILURE                         stdlib. h
EXIT_SUCCESS                         stdlib. h
exp                                  math. h
fabs                                 math. h
fclose                               stdio. h
feof                                 stdio.h
ferror                               stdio.h
fflush                               stdio. h
fgetc                                stdio.h
fgetpos                              stdio. h
fgets                                stdio.h
FILE                                 stdio. h
FILENAME-MAX                        stdio. h
floor                                math. h
fmod                                 math. h
fopen                                stdio. h
FOPEN_MAX                            stdio. h
fpos_t                               stdio. h
fpnntf                               stdio. h
fputc                                stdio.h
fputs                                stdio. h
head                                 stdio. h
free                                 stdlib. h
freopen                              stdio. h
frexp                                math. h
fscanf                               stdio. h
fseek                                stdio. h
fsetpos                              stdio. h
ftell                                stdio. h
fwrite                               stdio. h
getc                                 stdio.h
getchar                              stdio. h
getenv                               stdlib. h
gets                                 stdio.h
gmtime                               time. h
HUGE-VAL                             math.h
_IOFBF                               stdio. h
_IOLBF                               stdio. h
_IONBF                               stdio. h
isalnum                              ctype. h
isalpha                              ctype. h
iscntrl                              ctype. h
isdigit                              ctype. h
isgraph                              ctype. h
islower                              ctype. h
isprint                              ctype. h
ispunct                              ctype. h
isspace                              ctype. h
isupper                              ctype. h
isxdigit                             ctype. h
jmp_buf                              setjmp. h
labs                                 stdlib. h
LC_ALL                               locale. h
LC_COLLATE                           locale. h
LC_CTYPE                             locale. h
LC_MONETARY                          locale. h
LC_NUMERIC                           locale. h
LC_TIME                              locale. h
struct lconv                         locale. h
ldexp                                math. h
ldiv                                 stdlib. h
ldiv_t                               stdlib. h
localeconv                           locale. h
localtime                            time. h
log                                  math. h
log10                                math. h
longjmp                              setjmp. h
L_tmpnam                             stdio. h
malloc                               stdlib. h
mblen                                stdlib. h
mbstowcs                             stdlib. h
mbtowc                               stdlib. h
MB_CUR_MAX                           stdlib. h
memchr                               string. h
memcmp                               string. h
memcpy                               string. h
memmove                              string. h
memset                               string. h
mktime                              time. h
modf                                 math. h
NDEBUG                               assert. h
NULL                                 locale. h.stddef. h.stdio. h.stdlib. h.string. h.time. h
offsetof                             stddef. h
perror                               stdio.h
pow                                  math. h
printf                               stdio.h
ptrdiff_t                            stddef. h
putc                                 stdio. h
putchar                              stdio. h
puts                                 stdio. h
qsort                                stdlib. h
raise                                signal. h
rand                                 stdlib. h
RAND_MAX                             stdlib. h
realloc                              stdlib. h
remove                               stdio. h
rename                               stdio. h
rewind                               stdio. h
scanf                                stdio.h
SEEK_CUR                             stdio. h
SEEK_END                             stdio. h
SEEK_SET                             stdio. h
setbuf                               stdio. h
setjmp                               setjmp. h
setlocale                            locale. h
setvbuf                              stdio. h
SIGABRT                              signal. h
SIGFPE                               signal. h
SIGILL                               signal. h
SIGINT                               signal. h
signal                               signal. h
SIGSEGV                              signal. h
SIGTERM                              signal. h
sig_atomic_t                         signal. h
SIG_DFL                              signal. h
SIG_ERR                              signal. h
SIG_IGN                              signal. h
sin                                  math. h
sinh                                 math. h
size_t                               stddef. h.stdlib. h.string. h
sprintf                              stdio. h
sqrt                                 math. h
srand                                stdlib. h
sscanf                               stdio. h
stderr                               stdio.h
stdin                                stdio. h
stdout                               stdio. h
strcat                               string. h
strchr                               string. h
strcmp                               string. h
strcoll                              string. h
strcpy                               string. h
strcspn                              string. h
strerror                             string.h
strftime                             time. h
strlen                               string. h
strncat                              string. h
strncmp                              string. h
strncpy                              string. h
strpbrk                              string. h
strrchr                              string. h
strspn                               string. h
strstr                               string. h
strtod                               stdlib. h
strtok                               string. h
strtol                               stdlib. h
strtoul                              stdlib. h
strxfrm                              string. h
system                               stblib. h
tan                                  math. h
tanh                                 math. h
time                                 time. h
time_t                               time. h
struct tm                            time. h
tmpfile                              stdio. h
tmpnam                               stdio. h
TMP_MAX                              stdio. h
tolower                              ctype. h
toupper                              ctype. h
ungetc                               stdio. h
va_arg                               stdarg. h
va_end                               stdarg. h
valist                               stdarg. h
va_ start                            stdarg. h
vfprintf                             stdio. h
vprintf                              stdio. h
vsprintf                             stdio. h
wchar_t                              stddef. h. stdlib. h
wcstombs                             stdlib. h
wctomb                               stdlib. h
-------------------------------------------------------------------------

    请参见：
     5．12 #include(file~和#include“file”有什么不同?
    12．1 为什么应该使用标准库函数而不要自己编写函数?

    12．3 怎样编写参数数目可变的函数?
    你可以利用(stdarg．h)头文件，它所定义的一些宏可以让你处理数目可变的参数。
    注意：这些宏以前包含在名为(varargs．h)或类似的一个头文件中。你的编译程序中可能还有这样一个文件，也可能没有；即使现在有，下一个版本中可能就没有了。因此，还是使用(stadrg．h)为好。
   如果对传递给c函数的参数不加约束，就没有一种可移植的方式让c函数知道它的参数的数目和类型。如果一个c函数的参数数目不定(或类型不定)，就需要引入某种规则来约束它的参数。例如，printf()函数的第一个参数是一个字符串，它将指示其后都是一些什么样的参数：
printf(" Hello, world! /n" ); /* no more arguments */
printf("%s/n" , "Hello, world!");   /* one more string argument */
printf("%s, %s/n" , "Hello" , "world!");   /* two more string arguments */
printf("%s, %d/n", "Hello", 42);   /* one string, one int */
   例12．3给出了一个简单的类似printf()的函数，它的第一个参数是格式字符串，根据该字符串可以确定其余参数的数目和类型。与真正的 printf()函数一样，如果格式字符串和其余参数不匹配，那么结果是没有定义的，你无法知道程序此后将做些什么(但很可能是一些糟糕的事情)。
例12．3一个简单的类似printf()的函数
# include       <stdio. h>
# include       <stdlib. h>
# include       <string. h>
# include       <stdarg. h>

static char *
int2str (int n)
{
       int     minus = (n < 0) ;
       static char     buf[32];
       char      * p = &buf[3l];
       if (minus)
                n = —n;
       *P = '/0',
       do {
                *---p = '0'+n%10;
                n/=10;
       } while (n>0);
       if (minus)
          *- - p = '-';
       return p;
}
/*
* This is a simple printf-like function that handles only
* the format specifiers %%, %s, and %d.
*/
void
simplePrintf(const char * format, . . . )
{
      va_list     ap; / * ap is our argument pointer. * /
      int         i;
      char        * s ;
      /*
        * Initialize ap to start with the argument
        * after "format"
        */
      va_start(ap, format);
      for (; * format; format + + ) {
             if (* format !='%'){
                     putcharC * format);
                    continue;
             }
             switch ( * ++format) {
             case 's' :
                    / * Get next argument (a char * ) * /
                    s = va_arg(ap, char * );
                    fputs(s, stdout);
                    break;
             case 'd':/ * Get next argument (an int) * /
                     i = va_arg(ap, int);
                     s = int2str(i) ;
                     fputs(s, stdout) ;
                     break s
             case ' /0' : format---;
                    breaks
             default :putchar ( * format) ;
                    break;
              }
       }
       / * Clean up varying arguments before returning * /
       va_end(ap);
}
void
main()
{
             simplePrintK "The %s tax rate is %d%%. /n" ,
                     "sales", 6);
}

请参见：
12．2为了定义我要使用的标准库函数，我需要使用哪些头文件?

    12．4 独立(free—standing)环境和宿主(hosted)环境之间有什么区别?
    并不是所有的C程序员都在编写数据库管理系统和字处理软件，有些C程序员要为嵌入式系统(embedded system)编写代码，例如防抱死刹车系统和智能型的烤面包机。嵌入式系统可以不要任何类型的文件系统，也可以基本上不要操作系统。ANSI／1SO标准称这样的系统为“独立(free—standing)”系统，并且不要求它们提供除语言本身以外的任何东西。与此相反的情况是程序运行在RC机、大型机或者介于两者之间的计算机上，这被称为“宿主(hosted)”环境。
    即使是开发独立环境的程序员也应该重视标准库：其一，独立环境往往以与标准兼容的方式提供某种功能(例如求平方根函数，重新设计该函数显然很麻烦，因而毫无意义)；其二，在将嵌入式程序植入烤面包机这样的环境之前，通常要先在PC机上测试该程序，而使用标准库函数能增加可同时在测试环境和实际环境中使用的代码的总量。

请参见：
12．1为什么应该使用标准库函数而不要自己编写函数?

12．5 对字符串进行操作的标准库函数有哪些?
    简单的回答是：(string．h)中的函数。
    C语言没有固有的字符串类型，但c程序可以用以NUL(’＼O’)字符结束的字符数组来代替字符串。
    C程序(以及c程序员)应该保证数组足够大，以容纳所有将要存入的内容。这一点可以通过以下三种方法来实现：
    (1)分配大量的空间，并假定它足够大，不考虑它不够大时将产生的问题(这种方法效率高，但在空间不足时会产生严重的问题)；
    (2)总是分配并重新分配所需大小的空间(如果使用realloc()函数，这种方法的效率不会太低；这种方法需要使用大量代码，并且会耗费大量运行时间)；
    (3)分配应该足够的空间，并禁止占用更多的空间(这种方法既安全又高效，但可能会丢失数据)。
    注意：C++提供了第4种方法：直接定义一种string类型。由于种种原因，用C++完成这项工作要比用C简单得多。即便如此，用C++还是显得有点麻烦。幸运的是，尽管定义一个标准的C++ string类型并不简单，但这种类型使用起来却非常方便。
    有两组函数可用于C语言的字符串处理。第一组函数(strcpy，strcat，等等)按第一种或第二种方法工作。这组函数完全按需要拷贝字符串或使用内存，因此最好留出所需的全部空间，否则程序就可能出错。大多数C程序员使用第一组函数。第二组函数(strncpy，strncat，等等)按第三种方法工作。这组函数需要知道应该使用多大的空间，并且永远不会占用更多的空间，因此它们会忽略所有已无法容纳的数据。
    函数strncpy()和strncat()中的参数“n”(第三个)的意义是不同的：
    对strncpy()函数来说，它意味着只能使用“n”个字符的空间，包括末尾的NUL字符。
strncpy() 函数也恰好只拷贝“n”个字符。如果第二个参数没有这么多字符，strncpy()函数会用NUL字符填充剩余的空间。如果第二个参数有多于“n”个的字符，那么strncpy()函数在还没有拷贝到NUL字符之前就结束工作了。这意味着，在使用strncpy()函数时，你应该总是自己在目标字符串的末尾加上NUL字符，而不要指望strncpy()函数为你做这项工作。
    对strncat()函数来说，它意味着最多只能拷贝“n”个字符，如果需要还要加上一个NUL字符。因为你真正知道的是目标字符串能存放多少个字符，所以通常你要用strlen()函数来计算可以拷贝的字符数。
    函数strncpy()和strncat()之间的区别是“历史性”的(这是一个技术用语，指的是“它对某些人确实起到了一定的作用，并且它可能是处理问题的正确途径，但为什么正确至今仍然说不清楚”)。
    例12．5a给出了一个使用strncpy()和strncat()函数的程序。

．注意：你应该去了解一下"string-n”函数，虽然它们使用起来有些困难，但用它们编写的程序兼容性更好，错误更少。

    如果你愿意的话，可以用函数strcpy()和strcat()重新编写例12．5a中的程序，并用很长的足以溢出缓冲区的参数运行它。会出现什么现象呢?计算机会挂起吗?你会得到"GeneralProtection Exception”或内存信息转储这样的消息吗?请参见7．24中的讨论。
    例12．5a使用"string—n”函数的一个例子
# include <stdio. h>
# include <string. h>
/*
Normally, a constant like MAXBUF would be very large, to
help ensure that the buffer doesn't overflow. Here, it's very
small, to show how the "string-n" functions prevent it from
ever overflowing.
*/
# define MAXBUF 16
int
main (int argc, char* * argv)
{
         char buf[MAXBUF];
         int i;
         buf[MAXBUF - 1] = '/0';
         strncpy(buf, argv[0], MAXBUF-1);
         for (i = 1; i<argc; ++i) {
                strncat(buf, "   " ,
                  MAXBUF -1 - strlen (buf) ) ;
                strncat(buf, argv[i],
                  MAXBUF -1 - strlen (buf ) ) ;
        }
        puts (buf );
        return 0;
}

    注意：许多字符串函数都至少有两个参数，在描述它们时，与其称之为“第一个参数”和“第二个参数”，还不如称之为“左参数”和“右参数”。
    函数strcpy()和strncpy()用来把字符串从一个数组拷贝到另一个数组，即把右参数的值拷贝到左参数中，这与赋值语句的顺序是一样的。
    函数strcat()和strncat()用来把一个字符串连接到另一个字符串的末尾。例如，如果数组a1的内容为“dog”，数组a2的内容为“wood”，那么在调用strcat(al，a2)后，a1将变为“dogwood”。
    函数strcmp()和strncmp()用来比较两个字符串。当左参数小于、等于或大于右参数时，它们都分别返回一个小于、等于或大于零的值。常见的比较两个字符串是否相等的写法有以下两种：
    if (strcmp(sl, s2)) {
       / * si !=s2 * /
    }
和
    if (! strcmp(s1, s2)) {
      /* s1 ==s2 * /
    }
    上述代码可能并不易读，但它们是完全有效并且相当常见的c代码，你应该记住它们。如果在比较字符串时还需要考虑当前局部环境(locale，见12．8)，则要使用strcoll()函数。
有一些函数用来在字符串中进行检索(在任何情况下，都是在左参数或第一个参数中进行检索)。函数strchr()和strrchr()分别用来查找某个字符在一个字符串中第一次和最后一次出现的位置(如果函数strchr()和strrchr()有带“n”字母的版本，那么函数memchr()和 memrchr()是最接近这种版本的函数)。函数strspn()、strcspn()(“c”表示"complement")和strpbrk()用来查找包含指定字符或被指定字符隔开的子字符串：
n = strspn("Iowa" , "AEIOUaeiou");
/ * n = 2( "Iowa" starts with 2 vowels * /
n=strcspn("Hello world" ,"/t" ) ;
/ * n = 5; white space after 5 characters * /
p = strbrk("Hellb world" ,"/t" ) ;
/ * p points to blank * /

函数strstr()用来在一个字符串中查找另一个字符串：
p = strstr("Hello world", "or");
/ * p points to the second "or" * /

    函数strtok()按照第二个参数中指定的字符把一个字符串分解为若干部分。函数strtok()具有“破坏性”，它会在原字符串中插入NUL字符(如果原字符串还要做其它的改变，应该拷贝原字符串，并将这份拷贝传递给函数strtok())。函数strtok()是不能“重新进入”的，你不能在一个信号处理函数中调用strtok()函数，因为在下一次调用strtok()函数时它总是会“记住”上一次被调用时的某些参数。strtok()函数是一个古怪的函数，但它在分解以逗号或空白符分界的数据时是非常有用的。例12．5b给出了一个程序，该程序用strtok()函数把一个句子中的单词分解出来：
    例12．5b一个使用strtok()的例子
# include <stdio. h>
# include <string. h>
static char buf[] = "Now is the time for all good men . . . " ;
int
main()
{
         char * p;
         p = strtok(buf, " ") ;
         while (p ) {
                 printf("%s/n" ,p);
                 p = strtok(NULL, "   ");
          }
         return 0;
}

    请参见：
    4．18怎样读写以逗号分界的文本?
    第6章字符串操作
    7．23 NULL和NUI。有什么不同?
    9．9   字符串和数组有什么不同?
    12．8 什么是“局部环境(10cale)”?
    12．10 什么是信号(signal)?用信号能做什么?

    12．6 对内存进行操作的标准库函数有哪些?
    有些函数可用来拷贝、比较和填写任意的内存块，它们都带有void。类型(并不指向任何具体类型的指针)的参数，可以处理指向任何类型的指针。
    有两个函数(有点象strncpy()函数)可用来拷贝信息。第一个函数是memmove()，它把内存中的内容从一个地方拷贝到另一个地方，不管源区域和目标区域是否有相互覆盖的部分。为什么要提到这两个区域是否相互覆盖呢?假设缓冲区中已有部分数据，而你要把它们移到“后面”，以腾出缓冲区前面的空间。例12．6给出了一个试图进行这项工作的程序，但它做得并不正确：
    例12．6一个试图移动数据，结果毁掉数据的程序
static char buf[] =
{'R','I','G','H','T','/0','-','-','-'};
int
main()
{
   int i;
   for (i = 0; i<6; ++i)
   {
      buf[i + 3] = buf[i]i
   }
}

上述程序的意图是把buf从"RIGHT"改为“RIGRIGHT”，这样就可以在前面三个字节中存入其它数据。不幸的是，程序并没有真正实现这个意图。如果把for循环展开(或者通过调试程序来观察程序正在做什么)，你就会发现程序实际上是在这样做：
buf[3] = buf[0];
buf[4] = buf[l];
buf[5] = buf[2];
buf[6] = buf[3];
buf[7] = buf[4];
buf[8] = buf[5];
buf[9] = buf[6];

数据的移动效果如图12．6a所示(新拷贝的数据用粗黑体表示)——该程序毁掉了它原来想移动的某些数据。

R    I    G    H    T   /0   -    -    -
R    I    G    R    T   /0    -    -    -
R    I    G    R    I   /0    -    -   -
R    I    G    R    I    G    -    -    -
R    I    G    R    I    G    R    -    -
R    I    G    R    I    G    R    I    -
R    I    G    R    I    G    R    I    G

图12·6a“移动”相互覆盖的数据的错误方法

    在移动或拷贝相互覆盖的数据时，有这样一个简单的原则：如果源区域和目标区域相互覆盖，并且源区域在目标区域的前面，则应该从源区域的末尾开始按逆向顺序依次移动数据，直到达到源区域的头部；如果源区域在目标区域的后面，则应该从源区域的头部开始移动数据，直到达到源区域的末尾。请看图12．6b。
R    I    G    H    T    /0    -    -    -
R    I    G    H    T    /0    -    -    /n
R    I    G    H    T    /0    -    T    /0
R    I    G    H    T    /O    H    T    /0
R    I    G    H    T    G    H    T    /0
R    I    G    H    I    G    H    T    /O
R    I    G    R    I    G    H    T    /O
<    <    <    L    E    F    T    /O
L    <    <    L    E    F    T    /O
L    E    <    L    E    F     T    /O
L    E    F    L    E    F    T    /0
L    E    F    T    E    F    T    /O
L    E    F    T    /0   F    T    /O

图12．6b“移动”相互覆盖的数据的正确方法

    解释这些情况的目的是为了指出这样一点：memmove()函数知道上述原则，它能保证用正确的方法拷贝数据，不管数据是否相互覆盖。如果在拷贝或移动数据时你并不知道源区域和目标区域是否相互覆盖，你就应该使用memmove()函数。如果你能确定它们并没有相互覆盖，那么可以使用memcpy()函数，这样能稍快一些。
    memcmp()函数与strncmp()函数基本相似，只是它在遇到NUL字符时不会结束。memcmp()函数不能用来比较结构的值。假设你有下面这样一个结构：
    struct foo{
    short s；
    long 1；
    }
并且假设你的程序将运行在一个short类型为两个字节(16位)，long类型为4个字节(32位)的系统上。在32位的计算机中，许多编译程序会在s和 l之间加入两个字节的“无用信息”，以使I从下一个字的边界开始。如果你的程序运行在低位优先(低位字节存放在低位地址中)的计算机上，那么上述结构展开后可能会如下所示：
struct foo byte[O] s的低位字节
struct foo byte[1] s的高位字节
struct foo byte[2] 无用信息(使l从一个long类型边界开始)
struct foo byte[3] 无用信息(使l从一个long类型边界开始)
struct foo byte[4] l的最低位字节
struct foo byte[5] l的次低位字节
struct foo byte[6] l的次高位字节
struct foo byte[7] 1的最高位字节
用memcmp()函数比较具有相同的s和l值的两个foo结构时，其结果并不一定相等，因为所加入的“无用信息”并不一定相同。
    memchr()函数与strchr()函数基本相似，只不过它是在指定的一块内存空间中查找一个字符串，并且它在遇到第一个NUL字符时不会结束。
    memset()函数对所有的C程序员都是很有用的，它能把某种字节拷贝到指定的内存空间中。memset()函数的一种常见的用法是把某种结构全部初始化为零字节。如果p是指向一个结构的指针，那么语句memset(p，'/0'，size01 * p)；
将把p所指向的对象全部改写为零(NUL或'/O')字节(那些使结构成员从字边界开始的“无用信息”也会被改写，但这样做没有关系，因为这些信息没有用，所以谁也不会在乎它们被改写成什么样子)。

   请参见：
   4．1当errno为一个非零值时，是否有错误发生?
   4．3怎样重定向一个标准流?
    9．9字符串和数组有什么不同?

   12．7 怎样判断一个字符是数字、字母或其它类别的符号?
   在头文件ctype．h中定义了一批函数，它们可用来判断一个字符属于哪一类别。下面列出了这些函数：
---------------------------------------------------------------------------------------
    函数         字符类别             返回非零值的字符
---------------------------------------------------------------------------------------
isdigit()     十进制数               0--9
isxdigit()    十六进制数             0--9，a—f，或A--F
isalnum()    字母数字符号           0--9，a--Z，或A--Z
isalpha()    字母                   a--Z或A--Z
islower()     小写字母               a--Z
isupper()    大写字母              A--Z
isspace()    空白符          空格符，水平制表符，垂直制表符，换行符，换页符，或回车符
isgraph()    非空白字符             任何打印出来不是空白的字符(ASCII码从21到7E)
isprint()    可打印字符             所有非空白字符，加上空格符
ispunct()    标点符                 除字母数字符号以外的所有非空白字符
iscntrl()    控制字符               除可打印字符外的所有字符(ASCII码从00到1F，加上7F)
----------------------------------------------------------------------------------------
    与前文提到过的使用标准库函数的好处相似，调用上述这些宏而不是自己编写测试字符类别的程序也有三点好处。首先，这些宏运算速度快，因为它们的实现方式通常都是利用位屏蔽技术来检查一个表，所以即使是进行一项相当复杂的检查，也比真正去比较字符的值要快得多。
    其次，这些宏都是正确的。如果你自己编写一个测试程序，你很容易犯逻辑上或输入上的错误，例如引入了一个错误的字符(或漏掉了一个正确的字符)。
    第三，这些宏是可移植的。信不信由你，并非所有的人都使用同样的含PC扩充字符的ASCII字符集。也许今天你还不太在意，但是，当你发现你的下一台计算机使用的是Unicode字符集而不是ASCII字符集，你就会庆幸自己原来没有按照字符集中的字符值来编写程序。
    头文件ctype．h中还定义了两个可以对字母进行大小写转换的函数，即函数toupper()和tolower()。如果toupper()函数的参数不是小写字母或tolOWel"()函数的参数不是大写字母，那么这两个函数的行为是没有定义的，因此，在调用这两个函数之前，你应该用函数 islower()或isupper()来检查一下。

    请参见：
    5．1什么是宏(macro)?怎样使用宏?
    6．2怎样删去字符串尾部的空格?
    6．3怎样删去字符串头部的空格?
    20．18怎样判断一个字符是不是字母?
    20．19怎样判断一个字符是不是数字?

    12．8 什么是“局部环境(locale)”?
    局部环境是对特定环境下程序要遵循的特定规则的一种描述，它对程序的国际化很有帮助。
    如果你要打印一笔钱的数目，你总是使用美元符号吗?不，如果你的程序要在英国运行，你就要使用英镑符号。在有些国家，货币符号要写在钱数的前面，而在有些国家，货币符号要写在钱数的后面。一个负数的负号要放在哪里呢?在美国写成1，234．56的一个数字，在另外一些国家中可能要写成1．234，56。同样的值在不同的国家中会有不同的表示规则。时间和日期又是如何表示的呢?简而言之，也是因国而异。如果一个程序员要编写一个必须在全世界运行的程序，那么这些情况就是使他头疼的部分技术原因。
    幸运的是：部分差异已经被标准化了。C编译程序支持不同的“局部环境”，即程序在不同地方的不同表示规则。例如，函数strcoll()(string collate，字符串的依序整理)和strcmp()函数相似，但它能反映出不同国家和语言对字符串值进行排序和整理(collate)的方式。函数 setlocale()和localeconv()提供了这方面的支持。
    不幸的是：并没有一种标准化了的关于这些有趣的局部环境的清单。你的编译程序唯一能保证提供的只有“C”局部环境。这是一种通用的美式英语规则，对于码值在32和127之间的ASCII字符，这种规则工作得最好。尽管如此，如果你想正确地编写一个能在全世界运行的程序，那么从局部规则这个角度来考虑问题就是一个好的开端(接下来，如果你能再找到几种你的编译程序能支持的局部环境，或者让你的编译程序接受你定义的几种局部环境，那就更好了)。

    12．9 有没有办法从一个或多个函数中跳出?
    在极少数确实需要这样做的情况下，可以利用标准库函数setjmp()和longjmp()实现一种能从一个或多个函数中跳出的跳转(goto)。要正确地使用setjmp()和longjmp()函数，必须满足几个条件。
    首先，你必须包含setjmp．h头文件，该文件提供了setjmp()和longimp()函数的原型，并定义了jmp—buf类型。你需要把一个 jmp—bur类型的变量作为一个参数传递给setjmp()和longjmp()函数，这个变量将包含使跳转发生所需的信息。
    其次，你必须调用setjmp()函数来初始化jmp—bur变量。如果setjmp()函数返回0，则说明jmp_buf变量已被初始化；如果 setjmp()函数返回其它值，则说明程序刚才通过调用longjmp()函数跳转到了对应于该值的位置。在后一种情况下，setjmp()函数的返回值就是程序传递给longjmp()函数的第二个参数。
    从概念上讲，longjmp()函数的作用就好象是这样：当它被调用时，当前正在执行的函数便会返回；然后，调用这个函数的函数将返回；依此类推，直到调用setjmp()的函数成为正在执行的函数。程序的执行将跳转到调用setjmp()函数的位置，并从setjmp()函数返回那一点继续往下执行，但此时setjmp()函数的返回值已被置为传递给longjmp()函数的第二个参数。
    换句话说，如果函数f()调用了setjmp()，然后又调用了函数g()，而函数g()调用了函数h()，函数h()调用了longjmp()，那么程序运行起来就好象h()立即返回了，然后g()立即返回，然后f()执行一次回到调用setjmp()的位置的跳转。
    这就是说，为了使对10ngjmp()的调用能正常工作，程序必须已经调用setjmp()，并且还没有从调用setjmp()的函数中返回。如果这些条件得不到满足，那么longjmp()的行为是没有定义的(这意味着你的程序很可能会崩溃)。例12．9中的程序说明了setjmp()和 longjmp()的用法。这个程序显然是为此而设计的，因为如果不使用setjmp()和longjmp()，程序就会更简洁些。总的来说，当你想使用 setjmp()和longjmp()时，最好先找一种可以不使用它们的编程方法，因为它们容易被误用，并且会使程序难于阅读和维护。
    例12．9 一个使用setjmp()和longjmp()的例子
# include       <setjmp. h>
# include       <stdio. h>
# include       <string. h>
# include       <stdlib. h>
# define RETRY_PROCESS 1
# define QUIT_PROCESS 2
jmp_buf env;
int     nitems;
int
procItem()
{
       char     buf[256];
       if (gets (buf) &&.strcmp(buf, "done")) {
              if (strcmp(buf, "quit") ==0)
                    longjmp (env, QUIT_PROCESS );
              if (strcmp(buf, "restart") ==0)
                    longjmp(env, RETRY_PROCESS);
              nitems+ + ;
              return 1;
       }
       return 0;
}
void
process()
{
        printf ("Enter items, followed by 'done'. /n") ;
        printf("At any time, you can type 'quit' to exit/n");
        printf ("or 'restart' to start over again/n");
        nitems = 0;
        while (procItem())
}
void
main() {
        for (; ;) {
              switch (setjmp(env)) {
              case 0:
              case RETRY_PROCESS:
                       process () ;
                       printf("You typed in %d items. /n" ,
                             nitems);
                       break ;
              case QUIT_PROCESS:
              default:
                     exit(O);
              }
        }
}

   请参见：
   1．8 goto，longjmp()和setjmp()之间有什么区别?
   7．20 什么是栈(stack)?

   12．10 什么是信号(signal)?用信号能做什么?
   信号是程序执行过程中出现的异常情况。它可能是由程序中的错误造成的，例如引用内存中的一个非法地址；或者是由程序数据中的错误造成的，例如浮点数被0除；或者是由外部事件引发的，例如用户按了Ctrl+Break键。
    你可以利用标准库函数signal()指定要对这些异常情况采取的处理措施(实施处理措施的函数被称为“信号处理函数”)。signal()的原型为：
    #include    <signal．h>
    void(*signal(int hum，void(*func)(int)))(int)；
这恐怕是你在C标准函数库中能见到的最复杂的说明了。如果你先定义一个typedef，理解起来就容易一些了。下面给出的sigHandler_t类型是指向一个程序的指针，该函数有一个int类型的参数，并且返回一个void类型：
   typedef void(*sigHandler_t)(int)；
   sigHandler_t signal(int num , sigHandler_t func)；
    signal()有两个参数，分别为int类型和sigHandler_t类型，其返回值为sigHandler_t类型。以func参数形式传递给 signal()的那个函数将成为第num号异常情况的新的信号处理函数。signal()的返回值是信号hum原来的信号处理函数。在设置了一个暂时的信号处理函数之后，你可以利用该值恢复程序先前的行为。num的可能值依赖于系统，并且在signal．h中列出。func的可能值可以是你的程序中的任意函数，或者是SIG_DFL和SLG_IGN这两个特别定义的值之一。SIG_DFL是指系统的缺省处理措施，通常是暂停执行程序；SIG_IGN表示信号将被忽略。
    当下面这行代码被执行后，程序将不去响应按Ctrl+Break键这个信号，除非修改signal()函数，使其重新响应该信号。尽管hum的可能值依赖于系统，但SIGINT这个值通常用来表示用户试图中断程序运行的信号(在DOS下，为Ctrl+C或Ctrl+Break)。
   signal(SIGINT，SIG_IGN)

请参见：
20．16 怎样使Ctrl+Break失效?

   12．11 为什么变量名不能以下划线开始?
   凡是以两个或一个下划线开始，后面紧跟着一个大写字母的标识符，不管它出现在哪里，都是保留给编译程序或标准库函数使用的。此外，凡是以一个下划线开始，后面不管跟着什么内容的标识符，如果它出现在文件范围内(即它不是出现在一个函数内)，那么它也是被保留的。
    如果你用一个保留的标识符来作一个变量的名称，结果是没有定义的(程序可能无法编译，或者可以编译但会崩溃)。即使你能非常幸运地找到一个目前还没有被你的编译程序或函数库使用的标识符，你也应该记住这样的标识符是保留起来供将来使用的。因此，最好还是避免使用以下划线开始的变量名或函数名。

请参见：
19．1可以在变量名中使用下划线吗?

    12．12 为什么编译程序提供了两个版本的malloc()函数?
    包含了头文件stdlib．h后，你就可以在程序中使用malloc()和free()函数了。这些函数是编译程序从C函数库中包含到你的程序中的。有些编译程序还提供了一个独立的库，你可以要求编译程序用其中的版本来代替标准库中的malloc()和free()版本(只需在命令行中加入类似一 lmalloc这样的标志)。
    malloc()和free()的替代版本和标准版本的功能完全一样，只不过前者被认为在对内存分配错误不那么宽容的代价下，能产生更好的执行效果。笔者在15年的C语言编程经历中从未使用过这些替代版本，但为了回答这个问题，笔者编写了一个大量使用malloe()和free()的简单的测试程序，并用一种非常著名的C编译程序，分使用和不使用malloc库两种情况对其进行了编译。结果笔者没有发现明显的差异，并且笔者怀疑该开发商在实现这两种版本时使用了相同的代码，因为两个版本的程序的大小是一样的。正因为如此，笔者也就不便指出该开发商的名字了。
    以上的情况说明，也许不必去使用malloc()的其它版本，并且也不要指望它们会提高程序的性能。如果剖视(profiling)表明程序把大量时间花费在malloc()和free()上，并且通过改进算法也无法解决这个问题，那么你可以自己编写一个“缓冲池(pool)”分配函数，也许能提高程序的性能。
    大量调用malloc()和free()函数的程序往往是为相同类型的数据分配内存和释放内存，这些数据具有固定的长度。当知道要分配和释放的数据的大小后，自己编写的缓冲池分配函数会比malloc()和free()运行得更快。一个缓冲池分配函数的工作方式是这样的：调用malloc()一次分配许多大小相同的结构，然后每次交付一个供使用。该函数通常从来不调用free()，它所使用的内存将一直保留到程序退出。例12．12给出了一个用于自定义类型struct foo的缓冲池分配函数。
    例12．12一个缓冲池分配函数的例子
# include         <stdio. h>
/ * declaration of hypothetical structure "foo" * /
struct foo {
       int   dummy1;
       char dummy2;
       long dummy3;
};
/ * start of code for foo pool allocator * /
# include         <stdlib. h>
/ * number of foos to mallocO at a time * /
# define NFOOS 64
/*
* A union is used to provide a linked list that
* can be overlaid on unused foos.
*/
union foo_u {
        union foo_u     *next;
        struct foo       f;
};
static union foo_u        * free_list ;
struct foo *
alloc_foo()
{
         struct foo     * ret = 0;
         if (!free_list) {
                int    i;
                free_list = (union foo_u * ) malloc(NFOOS
                                 * sizeof (union foo_u));
                if (free_list) {
                      for (i = 0; i<NFOOS-1; i+ + )
                              free_list[i]. next =
                                     &iree_list[i + 1];
                      free_list [NFOOS -1 ]. next = NULL;
         if (free_list) {
               ret = &free_list ->f;
               free_list = free_list ->next;
         }
         return ret;
}
void
free_foo(struct foo * fp)
{
         union foo_u   * up= (union foo_u * ) fp;
         up ->next = free_list)
         free_list = up;
}
int
main(int argc, char * * argv)
{
         int       i;
         int       n;
         struct   foo    ** a ;
         if (argc <2) {
                 fprintf(stderr, "usage: %s f/n" , argv[0]);
                 fprintf(stderr. "where f is the number of");
                 fprintf(stderr, "'foo's to allocate/n" ) ;
                 exit(1);
         }
         i = atoi(argv[l]);
         a = (struct foo * * ) malloc(sizeof (struct foo * ) * i);
         for (n = 0; n<i; n+ + )
                 a[n] = alldc-foo() ;
         for (n = 0j n<i; n+ + )
                 free_foo(a[n]);
         return 0;
}

    笔者用30000这样一个参数编译并运行了上述程序，并将其结果与用malloc()和free()代替alloc_foo()和free_foo()的一个类似的程序进行比较，发现前者使用的CPU时间为O．46秒，而后者为0．92秒。
    需要注意的是，使用缓冲池分配函数只能是最后的选择，它也许能提高速度，但它会造成内存的巨大浪费。此外，如果你不调用free()，而又没能小心地把从缓冲池中申请到的内存返回去，就会导致微妙的内存分配错误。
   请参见：
    7．21什么是堆(heap)?
   7．26 free()函数是怎样知道要释放的内存块的大小的?

   12．13 适用于整数和浮点数的数学函数分别有哪些?
   运算符+，-，*和/(加、减、乘和除)对整数和浮点数都适用，而运算符%(求余)仅适用于整数。
    适用于浮点数的大多数函数在头文件math．h中说明。为了提高精确度，这些函数大多以双精度浮点数的精度进行操作。如果传递过来的参数不在其定义域内 (函数的定义域是指函数参数有效值的集合)，这些函数会返回一些不确定的值，并将变量errno置为EDOM。如果返回值太大或太小，无法用一个 double类型表示(造成上溢或下溢)，这些函数会返回HUGEVAL(表示上溢)或O(表示下溢)，并将errno置为 ERANGE,EDOM，ERANGE和HUGEVAL都在math．h中定义。
    下面列出了在math．h中说明的函数的描述：
    ·double COS(double)，double sin(double)和double tan(double)的参数都是一个弧度值，其返回值分别为该值的正弦值、余弦值和正切值。
    ·double acos(double)，double asin(double)和double atan(double)的参数都是一个值，其返回值分别为该值的反正弦值、反余弦值和反正切值。传递给acos()和asin()的值必须在-1和1之间。
    ·double atan2(double x，double y)返回x／y的反正切值，不管x／y是否能表示成double类型(例如y为0时)。
    ·double cosh(double)，double sinh(double)和double tanh(double)的参数都是一个弧度值，其返回值分别为该值的双曲正弦值、双曲余弦值和双曲正切值。
    ·double exp(double x)，double log(double x)和double logl0(double x)的参数都是一个值，其返回值分别为e。，x的自然对数值和x的以10为底的对数值。当x为0或一个负数时，后两个函数都将分别导致一个范围错误 (ERANGE)或一个定义域错误(EDOM)。
    ·double sqrt(double)将返回其参数的平方根值。当该参数为负数时，该函数将导致一个定义域错误(EDOM)。
    ·double ldexp(double n，double e)返回n*2e。这与整数的“<<”运算符有些相似。
    ·double pow(double b，double e)返回be。当b为O而e小于等于0时，或者当b小于O而e不是一个整数值时，该函数将导致一个定义域错误(EDOM)。
    ·double frexp(double n，int*i)返回n的尾数(mantissa)，并将n的指数(exponent)存放在i所指向的整型变量中。尾数在o．5和1之间(不包括1本身)，而指数是这样一个数，它将使n=mantissa*2exponent。
    ·double modl(double n，int *i)返回n的小数部分，并将n的整数部分存放在i所指向的整型变量中。
    ·double celt(double)和double floor(double)分别返回大于其参数的最小整数和小于其参数的最大整数。例如，ceil(-1．1)返回-1．O，而floor(-1．1)返回-2．0。
    ·double fmod(double x，double y)返回x／y的余数。这与整数的％运算符相似，但该函数的参数和返回值并不局限于整数。当y为O时，该函数将导致一个定义域错误(EDOM)。
    ·double fabs(double)返回其参数的绝对值(一个数量相同的数字，但永远是正数)。例如，labs(-3．14)返回3．14。

请参见：
2．11 对不同类型的变量进行算术运算会有问题吗?

    12．14 什么是多字节字符(multibyte characters)?
    多字节字符是使国际化的程序更容易编写的另一种途径。具体地说，它们有助于支持永远无法纳入8位字符的语言，例如汉语和日语。如果你的程序永远不需要使用除英语之外的其它任何语言，你可以不必了解多字节字符。
    你不得不承认这样一个事实：可能到处都有人想使用你的软件，但并不是人人都懂英语。幸运的是，已经有了可以把欧洲语言的各种特殊字符纳入8位字符集的标准(不幸的是，这样的标准有好几种，并且它们相互并不一致)。
到了亚洲，这个问题变得更复杂。有些语言的字符超过256个，例如汉语和日语，它们永远无法纳入8位字符集中(一个8位字符能存放O和255之间的一个数字，因此它能只有256种不同的值)。
    幸运的是，C标准库已经开始解决这个问题。<stddef．h>定义了wchar_t类型，它的长度足以存放c程序能处理的任何语言中的任何字符。根据到目前为止的所有协议，16位已经足够了。这通常就是short类型，但最好还是相信编译程序开发商所提供的wchar_t的正确性，以免在 short类型的长度发生变化时遇到麻烦。
    函数mblen()，mbtowc()和wctomb()能将单字节字符串转换为多字节字符。如果你想了解更多的有关这些函数的信息，请查阅你的编译程序手册。

请参见：
12．15怎样操作由多字节字符组成的字符串?

    12．15 怎样操作由多字节字符组成的字符串?
    假设你的程序既要处理英文文本(很容易纳As位字符，并且还能空出一位)，又要处理日文文本(需要16位才能包含所有的可能性)。如果你用相同的代码来处理这两种不同国家的文本，你是否需要给每个字符，甚至英文符都分配16位呢?也许不必这样做，因为有些多字节字符的编码方法会保存关于是否需要多于一个字节的空间的信息。
    mbstowcs()(“多字节字符串到宽字符串”)和wcstombs()(“宽字符串到多字节字符串”)用于wchar—t类型的数组(其中每个字符占16位或两个字节)和多字节字符串(可能的话，一个字符会被存入一个字节中)。
    你无法保证你的编译程序能以紧缩的方式存储多字节字符串(因为没有一种普遍接受的方法)。如果你的编译程序能帮助你处理多字节字符串，mbstowcs()和wcstombs()就是完成这部分工作的函数。

请参见：
12．14什么是多字节字符(multibyte characters)?