C语言编程常见问题解答之标准库函数（2）

    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*2^e。这与整数的“<<”运算符有些相似。
    ·double pow(double b，double e)返回b^e。当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*2^exponent。
    ·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)?