线程库

下面简要论述了特定任务及其相关手册页。

创建缺省线程

如果未指定属性对象，则该对象为 NULL，系统会创建具有以下属性的缺省线程：

• 进程范围

• 非分离

• 缺省栈和缺省栈大小

• 零优先级

还可以用 pthread_attr_init() 创建缺省属性对象，然后使用该属性对象来创建缺省线程。有关详细信息，请参见初始化属性一节。

pthread_create 语法

使用 pthread_create(3C) 可以向当前进程中添加新的受控线程。

int pthread_create(pthread_t *tid, const pthread_attr_t *tattr,

    void*(*start_routine)(void *), void *arg);

#include <pthread.h>

pthread_attr_t() tattr;

pthread_t tid;

extern void *start_routine(void *arg);

void *arg;

int ret; 

/* default behavior*/

ret = pthread_create(&tid, NULL, start_routine, arg);

/* initialized with default attributes */

ret = pthread_attr_init(&tattr);

/* default behavior specified*/

ret = pthread_create(&tid, &tattr, start_routine, arg);

使用具有必要状态行为的 attr 调用 pthread_create() 函数。 start_routine 是新线程最先执行的函数。当 start_routine 返回时，该线程将退出，其退出状态设置为由 start_routine 返回的值。请参见pthread_create 语法。

当 pthread_create() 成功时，所创建线程的 ID 被存储在由 tid 指向的位置中。

使用 NULL 属性参数或缺省属性调用 pthread_create() 时，pthread_create() 会创建一个缺省线程。在对 tattr 进行初始化之后，该线程将获得缺省行为。

pthread_create 返回值

pthread_create() 在调用成功完成之后返回零。其他任何返回值都表示出现了错误。如果检测到以下任一情况，pthread_create() 将失败并返回相应的值。

EAGAIN

描述:

超出了系统限制，如创建的线程太多。

EINVAL

描述:

tattr 的值无效。

等待线程终止

pthread_join() 函数会一直阻塞调用线程，直到指定的线程终止。

pthread_join 语法

使用 pthread_join(3C) 等待线程终止。

int pthread_join(thread_t tid, void **status);

#include <pthread.h>

pthread_t tid;

int ret;

void *status;

/* waiting to join thread "tid" with status */

ret = pthread_join(tid, &status);

/* waiting to join thread "tid" without status */

ret = pthread_join(tid, NULL); 

指定的线程必须位于当前的进程中，而且不得是分离线程。有关线程分离的信息，请参见设置分离状态。

当 status 不是 NULL 时，status 指向某个位置，在 pthread_join() 成功返回时，将该位置设置为已终止线程的退出状态。

如果多个线程等待同一个线程终止，则所有等待线程将一直等到目标线程终止。然后，一个等待线程成功返回。其余的等待线程将失败并返回 ESRCH 错误。

在 pthread_join() 返回之后，应用程序可回收与已终止线程关联的任何数据存储空间。

pthread_join 返回值

调用成功完成后，pthread_join() 将返回零。其他任何返回值都表示出现了错误。如果检测到以下任一情况，pthread_join() 将失败并返回相应的值。

ESRCH

描述:

没有找到与给定的线程 ID 相对应的线程。

EDEADLK

描述:

将出现死锁，如一个线程等待其本身，或者线程 A 和线程 B 互相等待。

EINVAL

描述:

与给定的线程 ID 相对应的线程是分离线程。

pthread_join() 仅适用于非分离的目标线程。如果没有必要等待特定线程终止之后才进行其他处理，则应当将该线程分离。

简单线程的示例

在示例 2–1 中，一个线程执行位于顶部的过程，该过程首先创建一个辅助线程来执行 fetch() 过程。fetch() 执行复杂的数据库查找操作，查找过程需要花费一些时间。

主线程将等待查找结果，但同时还执行其他操作。因此，主线程将执行其他活动，然后通过执行 pthread_join() 等待辅助线程。

将新线程的 pbe 参数作为栈参数进行传递。这个线程参数之所以能够作为栈参数传递，是因为主线程会等待辅助线程终止。不过，首选方法是使用 malloc 从堆分配存储，而不是传递指向线程栈存储的地址。如果将该参数作为地址传递到线程栈存储，则该地址可能无效或者在线程终止时会被重新分配。

---

示例 2–1 简单线程程序

void mainline (...)

{

        struct phonebookentry *pbe;

        pthread_attr_t tattr;

        pthread_t helper;

        void *status;

        pthread_create(&helper, NULL, fetch, &pbe);

            /* do something else for a while */

        pthread_join(helper, &status);

        /* it's now safe to use result */

}

void *fetch(struct phonebookentry *arg)

{

        struct phonebookentry *npbe;

        /* fetch value from a database */

        npbe = search (prog_name)

            if (npbe != NULL)

                *arg = *npbe;

        pthread_exit(0);

}   

struct phonebookentry {

        char name[64];

        char phonenumber[32];

        char flags[16];

}

---

分离线程

pthread_detach(3C) 是 pthread_join(3C) 的替代函数，可回收创建时 detachstate 属性设置为 PTHREAD_CREATE_JOINABLE 的线程的存储空间。

pthread_detach 语法

int pthread_detach(thread_t tid);

#include <pthread.h>

pthread_t tid;

int ret;

/* detach thread tid */

ret = pthread_detach(tid); 

pthread_detach() 函数用于指示应用程序在线程 tid 终止时回收其存储空间。如果 tid 尚未终止，pthread_detach() 不会终止该线程。

pthread_detach 返回值

pthread_detach() 在调用成功完成之后返回零。其他任何返回值都表示出现了错误。如果检测到以下任一情况，pthread_detach() 将失败并返回相应的值。

EINVAL

描述:

tid 是分离线程。

ESRCH

描述:

tid 不是当前进程中有效的未分离的线程。

为线程特定数据创建键

单线程 C 程序有两类基本数据：局部数据和全局数据。对于多线程 C 程序，添加了第三类数据：线程特定数据。线程特定数据与全局数据非常相似，区别在于前者为线程专有。

线程特定数据基于每线程进行维护。TSD（特定于线程的数据）是定义和引用线程专用数据的唯一方法。每个线程特定数据项都与一个作用于进程内所有线程的键关联。通过使用 key，线程可以访问基于每线程进行维护的指针 (void *)。

pthread_key_create 语法

int pthread_key_create(pthread_key_t *key,

    void (*destructor) (void *));

#include <pthread.h>

pthread_key_t key;

int ret;

/* key create without destructor */

ret = pthread_key_create(&key, NULL);

/* key create with destructor */

ret = pthread_key_create(&key, destructor); 

可以使用 pthread_key_create(3C) 分配用于标识进程中线程特定数据的键。键对进程中的所有线程来说是全局的。创建线程特定数据时，所有线程最初都具有与该键关联的 NULL 值。

使用各个键之前，会针对其调用一次 pthread_key_create()。不存在对键（为进程中所有的线程所共享）的隐含同步。

创建键之后，每个线程都会将一个值绑定到该键。这些值特定于线程并且针对每个线程单独维护。如果创建该键时指定了 destructor 函数，则该线程终止时，系统会解除针对每线程的绑定。

当 pthread_key_create() 成功返回时，会将已分配的键存储在 key 指向的位置中。调用方必须确保对该键的存储和访问进行正确的同步。

使用可选的析构函数 destructor 可以释放过时的存储。如果某个键具有非 NULL destructor 函数，而线程具有一个与该键关联的非 NULL 值，则该线程退出时，系统将使用当前的相关值调用 destructor 函数。destructor 函数的调用顺序不确定。

pthread_key_create 返回值

pthread_key_create() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况，pthread_key_create() 将失败并返回相应的值。

EAGAIN

描述:

key 名称空间已经用完。

ENOMEM

描述:

此进程中虚拟内存不足，无法创建新键。

删除线程特定数据键

使用 pthread_key_delete(3C) 可以销毁现有线程特定数据键。由于键已经无效，因此将释放与该键关联的所有内存。引用无效键将返回错误。Solaris 线程中没有类似的函数。

pthread_key_delete 语法

int pthread_key_delete(pthread_key_t key);

#include <pthread.h>

pthread_key_t key;

int ret;

/* key previously created */

ret = pthread_key_delete(key); 

如果已删除键，则使用调用 pthread_setspecific() 或 pthread_getspecific() 引用该键时，生成的结果将是不确定的。

程序员在调用删除函数之前必须释放所有线程特定资源。删除函数不会调用任何析构函数。反复调用 pthread_key_create() 和 pthread_key_delete() 可能会产生问题。如果 pthread_key_delete() 将键标记为无效，而之后 key 的值不再被重用，那么反复调用它们就会出现问题。对于每个所需的键，应当只调用 pthread_key_create() 一次。

pthread_key_delete 返回值

pthread_key_delete() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下情况，pthread_key_delete() 将失败并返回相应的值。

EINVAL

描述:

key 的值无效。

设置线程特定数据

使用 pthread_setspecific(3C) 可以为指定线程特定数据键设置线程特定绑定。

pthread_setspecific 语法

int pthread_setspecific(pthread_key_t key, const void *value);

#include <pthread.h>

pthread_key_t key;

void *value;

int ret;

/* key previously created */

ret = pthread_setspecific(key, value); 

pthread_setspecific 返回值

pthread_setspecific() 在成功完成之后返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况，pthread_setspecific() 将失败并返回相应的值。

ENOMEM

描述:

虚拟内存不足。

EINVAL

描述:

key 无效。

---

注 –

设置新绑定时，pthread_setspecific() 不会释放其存储空间。必须释放现有绑定，否则会出现内存泄漏。

---

获取线程特定数据

请使用 pthread_getspecific(3C) 获取调用线程的键绑定，并将该绑定存储在 value 指向的位置中。

pthread_getspecific 语法

void *pthread_getspecific(pthread_key_t key);

#include <pthread.h>

pthread_key_t key;

void *value;

/* key previously created */

value = pthread_getspecific(key); 

pthread_getspecific 返回值

pthread_getspecific 不返回任何错误。

全局和专用线程特定数据的示例

示例 2–2 显示的代码是从多线程程序中摘录出来的。这段代码可以由任意数量的线程执行，但该代码引用了两个全局变量：errno 和 mywindow。这些全局值实际上应当是对每个线程专用项的引用。

---

示例 2–2 线程特定数据－全局但专用

body() {

    ...

    while (write(fd, buffer, size) == -1) {

        if (errno != EINTR) {

            fprintf(mywindow, "%s", strerror(errno));

            exit(1);

        }

    }

    ...

}

---

errno 引用应该从线程所调用的例程获取系统错误，而从其他线程所调用的例程获取系统错误。因此，线程不同，引用 errno 所指向的存储位置也不同。

mywindow 变量指向一个 stdio （标准 IO）流，作为线程专属的流窗口。因此，与 errno 一样，线程不同，引用 mywindow 所指向的存储位置也不同。最终，这个引用指向不同的流窗口。唯一的区别在于系统负责处理 errno，而程序员必须处理对 mywindow 的引用。

下一个示例说明对 mywindow 的引用如何工作。预处理程序会将对 mywindow 的引用转换为对 _mywindow() 过程的调用。

此例程随后调用 pthread_getspecific()。pthread_getspecific() 接收 mywindow_key 全局变量作为输入参数，以输出参数 win 返回该线程的窗口。

---

示例 2–3 将全局引用转化为专用引用

thread_key_t mywin_key;

FILE *_mywindow(void) {

    FILE *win;

    win = pthread_getspecific(mywin_key);

    return(win);

}

#define mywindow _mywindow()

void routine_uses_win( FILE *win) {

    ...

}

void thread_start(...) {

    ...

    make_mywin();

    ...

    routine_uses_win( mywindow )

    ...

}

---

mywin_key 变量标识一类变量，对于该类变量，每个线程都有其各自的专用副本。这些变量是线程特定数据。每个线程都调用 make_mywin() 以初始化其时限并安排其 mywindow 实例以引用线程特定数据。

调用此例程之后，此线程可以安全地引用 mywindow，调用 _mywindow() 之后，此线程将获得对其专用时限的引用。引用 mywindow 类似于直接引用线程专用数据。

示例 2–4 说明如何设置引用。

---

示例 2–4 初始化线程特定数据

void make_mywindow(void) {

    FILE **win;

    static pthread_once_t mykeycreated = PTHREAD_ONCE_INIT;

    pthread_once(&mykeycreated, mykeycreate);

    win = malloc(sizeof(*win));

    create_window(win, ...);

    pthread_setspecific(mywindow_key, win);

}

void mykeycreate(void) {

    pthread_key_create(&mywindow_key, free_key);

}

void free_key(void *win) {

    free(win);

}

---

首先，得到一个唯一的键值，mywin_key。此键用于标识线程特定数据类。第一个调用 make_mywin() 的线程最终会调用 pthread_key_create()，该函数将唯一的 key 赋给其第一个参数。第二个参数是 destructor 函数，用于在线程终止后将该线程的特定于该线程的数据项实例解除分配。

接下来为调用方的线程特定数据项的实例分配存储空间。获取已分配的存储空间，调用 create_window()，以便为该线程设置时限。win 指向为该时限分配的存储空间。最后，调用 pthread_setspecific()，将 win 与该键关联。

以后，每当线程调用 pthread_getspecific() 以传递全局 key，线程都会获得它在前一次调用 pthread_setspecific() 时设置的与该键关联的值）。

线程终止时，会调用在 pthread_key_create() 中设置的 destructor 函数。每个 destructor 函数仅在终止线程通过调用 pthread_setspecific() 为 key 赋值之后才会被调用。

获取线程标识符

请使用 pthread_self(3C) 获取调用线程的 thread identifier。

pthread_self 语法

pthread_t  pthread_self(void);

#include <pthread.h>

pthread_t tid;

tid = pthread_self();

pthread_self 返回值

pthread_self() 返回 …

学习过了devic一章，基本上都是常见的设备的概念介绍 ,开始proc，

#include <stdio.h>
#include <string.h>
float get_cpu_clock_speed ()
{
  FILE* fp;
  char buffer[1024];
  size_t bytes_read;
  char* match;
  float clock_speed;

  fp =fopen(”/proc/cpuinfo”,”r”);
  bytes_read = fread(buffer,1,sizeof(buffer),fp);
  fclose(fp);
  printf(”2xxxxxxxx%s”,buffer);
    if(0 == bytes_read || sizeof(buffer) == bytes_read)
    return 0;
  buffer[bytes_read]=’0′;
  printf(”hello word”);p
  match = strstr(buffer,”cpu MHz”);
  if(match == NULL)
    return 0;
  sscanf(match,”cpu MHz:%s”,&clock_speed);
  return clock_speed;

}
int main()  {

    printf(”cpu clock speed :%4.0f MHz”,get_cpu_clock_speed());
    return 0;
}

 a．巴尼在饮店工作，他给他的两位顾客表演10个杯子游戏。 　
 b．巴尼：这有一排10个杯子，前5个杯子装着可乐，后5个杯子空着，你能挪4个杯子，使满杯和空杯间隔排列吗? 　　
 c．巴尼：好，只需第2个杯子和第7个杯子交换位置，第4个杯子和第9个杯子交换位置。 　
 d．奎伯教授总想一些奇特的方法，碰巧听到了这个问题。
奎伯教授：为什么要挪4个杯子，我们能否只动2个杯子?
 e．奎伯教授：很简单，把第2个杯中的可乐倒进第7个杯中，把第4个杯中的可乐倒进第9个杯中。           
不寻常的奎伯
尽管奎伯教授通过巧辩解决了这个问题，但普遍问题并不像这个问题这么平常。例如，同样的问题，如果是100个满杯和100个空杯需要对调多少次才能使满杯和空杯间隔排列?　
用200个杯子做实验不很实际，我们首先分析较小的n值的解决方法，这里n是满杯或空杯数。你可以用两种颜色的记号来解题(或者牌的正反面、硬币的正反面、不同面值的硬币等等)当n=1时无解。n=2时显然只对调一次。n=3时也对调一次。进一步努力，你可以发现简单的公式，n是偶数时，对调数为n/2。n是奇数时，为(n—1)/2。所以，如果是100个满杯和100个空杯，需要对调50次。　
这需要移动100个杯子，奎伯的幽默作法把移动杯数减少了一半。
又有一个类似的分隔同题，但比较难解。在同一排中有n个一类物体，相邻的是n个另一类物体(如上面用玻璃杯、记号、牌等来表示)你还是要把这一排列变为互相间隔状态，但我们移动原则不同了。我们必须移动一对记号放到队列中任何空白处，移动中不能改变这两个记号的顺序。例如，这是n=3时的做法：

XXXOOO
  XOOOXX
  X00  XOX
    OXOXOX　
一般的解法是什么呢?n=1时无解。你很快也发现，n=2时也无解。对所有大于2的n，最小的移动次数是n。　
当n=4时，解决这个同题就很不易，或许你已经解决了，或许当n大于等于3时你能用公式来表示这个问题的解。
这些问题变化一下，可以产生一些其它的难题：
(1)规则同前，只是当你移动一对记号时，如果是不同颜色的，在移动前交换它们的位置。也就是黑红对在移动前变为红黑对，8个记号移动5次可以完成，10个记号移动5次也可以完成。我们还不知道一般的解决方法，或许你能找到。
(2)规则和原题一样，只是一种颜色的记号有n个，另一种颜色的记号有n+1个，并且只有颜色不同的一对才能移动。可以证明：无论n为何值，都需移动n2次，且这是最小的移动次数。　
(3)三种不同颜色的记号，移动每对相邻的记号使三种颜色相互间隔，如果n=3(即总共9个记号)需移5次。在以上的变化中，我们都设变化为最后排列时排列中没有空隙，如果允许空隙存住，移动4次就能得到结果

一些变化的假设迄今还没有提出来，更不必说解决了。比如，在以上的变化中，一次移动3个或更多相邻记号。
还有，如果先移动1个记号，再移动2个相邻的记号，接下来是3个以至4个等等。已知各有n个两种颜色的记号，移动n次能解决问题吗?
第二个问题。

a．奎伯教授又给你出了一个难题。 奎伯教授：拿3个空塑料杯，放进11便士的硬币，使得每个杯中的数是奇数。

b．奎伯教授：这并不难，可以有许多办法。你可以一个杯里放3个，一个杯里放7个，第3个杯里放1个。

c．奎伯教授：但是，你能在3个杯中放10个便士使每个杯中仍是奇数吗?这是可能的，但需要你想一个巧妙的办法。

d．奎伯教授：我希望你锲而不舍，你所要做的就是把一个杯子放进另一个杯子中去，这不是很容易吗?每个杯子中就都是奇数了。 通过把一个杯子放进另一个杯子的灵感解决了奎伯的智力难题。同一组硬币可以属于不止一个杯子。用集合理论用语，我们的答案是一个7元素的集合加上一个3元素的集合，这个3元素的集合包括一个单元素子集。这个答案也可以用如下的圆表示： 　 你可能找到了其它的答案。很容易找到10个答案，但总共能找到15个答案。 　 找到这15个答案以后，你就可以通过硬币数的变化，杯子数的变化以及每个杯子中硬币数的变化对这个问题归纳总结。

这个是在书上看到的，乒乓问题，
 a．米拉德·费尔默中学乒乓球俱乐部的5名成员决定举办一次淘汰赛。 　
 b．教练解释他的比赛安排。
教练：5是一个奇数，所以第一轮比赛一名队员轮空。第二轮比赛仍有一个轮空，需比赛4场。 　
 c．第二年乒乓球运动非常流行，俱乐部已拥有37名成员。教练还是按使轮空次数最少来安排比赛，你能算出要比多少场吗?
 d．你还没算出来吗?你还在画表吗?你失去了好机会！每场比赛淘汰一名队员，有36名队员要被淘汰，要比36场，对吗?

有多少人轮空

　

如果你用直观的方法解决这个问题，你可以实际画一下37个人实际的比赛表。你可以看到无论怎样画，总有4个轮空。轮空数是比赛者人数n的函数，怎样来计算这个数呢?

　

n已知，可按如下方祛确定轮空数。用2的最小指数幂，要求它大于等于n，减去n，差额用二进制来表示。二进制表达式中1的个数就是转空数。在我们的例子中，我们用64(2⁶)减去37得到27，用二进制表示27=11011，有4个1，所以比赛中共有4个轮空，这是满足这种奇妙算法的有趣验证。

　

这种问题所描述的比赛被称为是淘汰赛。计算机专家们总结这种算法是通过成对比较，确定一组几个元素中最大元素。我们看到要确定最大值，实际需要n-1次比较，计算机处理器可以比较3组，4组，5组等等这样的集合。

　

数据处理这个问题在计算机理论和应用上非常重要，所有的书都阐述这个问题。你可以很容易想到许多实际问题在数据处理方面的重要性。据估计，在科技、商业和工业方面花费在数据处理问题上的计算时间要占计算机运行时间的1/4

我的思考是37对2移位，移动以为如果是对2取摸等于0则轮空的人数加1。

发现wikipedia的设计模式讲的还不错，而且还带各种代码，学习学习
http://en.wikipedia.org/wiki/Design_pattern_(computer_science)
20  http://ubuntu:ubuntuftp@ftp.ubuntu.org.cn/   
21.         http://mirrors.huihoo.org/       
23.         http://bingle.pku.edu.cn          、
24.         http://so.hustonline.net/
25.         ftp://ftp:ftp@www.chinalinux.org.cn/
26     http://www.fdigg.net/
 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>

/* Read text from the socket and print it out.  Continue until the
   socket closes.  Return non-zero if the client sent a “quit”
   message, zero otherwise.  */

int server (int client_socket)
{
  while (1) {
    int length;
    char* text;

    /* First, read the length of the text message from the socket.  If
       read returns zero, the client closed the connection.  */
    if (read (client_socket, &length, sizeof (length)) == 0)
      return 0;
    /* Allocate a buffer to hold the text.  */
    text = (char*) malloc (length);
    /* Read the text itself, and print it.  */
    read (client_socket, text, length);
    printf (”%s”, text);
    /* Free the buffer.  */
    free (text);
    /* If the client sent the message “quit”, we’re all done.  */
    if (!strcmp (text, “quit”))
      return 1;
  }
}

int main (int argc, char* const argv[])
{
  const char* const socket_name = argv[1];
  int socket_fd;
  struct sockaddr_un name;
  int client_sent_quit_message;

  /* Create the socket.  */
  socket_fd = socket (PF_LOCAL, SOCK_STREAM, 0);
  /* Indicate this is a server.  */
  name.sun_family = AF_LOCAL;
  strcpy (name.sun_path, socket_name);
  bind (socket_fd, &name, SUN_LEN (&name));
  /* Listen for connections.  */
  listen (socket_fd, 5);

  /* Repeatedly accept connections, spinning off one server() to deal
     with each client.  Continue until a client sends a “quit” message.  */
  do {
    struct sockaddr_un client_name;
    socklen_t client_name_len;
    int client_socket_fd;

    /* Accept a connection.  */
    client_socket_fd = accept (socket_fd, &client_name, &client_name_len);
    /* Handle the connection.  */
    client_sent_quit_message = server (client_socket_fd);
    /* Close our end of the connection.  */
    close (client_socket_fd);
  }
  while (!client_sent_quit_message);

  /* Remove the socket file.  */
  close (socket_fd);
  unlink (socket_name);

  return 0;
}

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>

/* Write TEXT to the socket given by file descriptor SOCKET_FD.  */

void write_text (int socket_fd, const char* text)
{
  /* Write the number of bytes in the string, including
     NUL-termination.  */
  int length = strlen (text) + 1;
  write (socket_fd, &length, sizeof (length));
  /* Write the string.  */
  write (socket_fd, text, length);
}

int main (int argc, char* const argv[])
{
  const char* const socket_name = argv[1];
  const char* const message = argv[2];
  int socket_fd;
  struct sockaddr_un name;

  /* Create the socket.  */
  socket_fd = socket (PF_LOCAL, SOCK_STREAM, 0);
  /* Store the server’s name in the socket address.  */
  name.sun_family = AF_LOCAL;
  strcpy (name.sun_path, socket_name);
  /* Connect the socket.  */
  connect (socket_fd, &name, SUN_LEN (&name));
  /* Write the text on the command line to the socket.  */
  write_text (socket_fd, message);
  close (socket_fd);
  return 0;
}

无意间lighttpd的源代码，发现一处跟平常实现不同的函数，就是字母转换大小写。验证。

int light_isdigit(int c) {        return (c >= '0' && c <= '9');}这个很好理解。不说了int light_isxdigit(int c) {        if (light_isdigit(c)) return 1;        c |= 32;        return (c >= 'a' && c <= 'f');}这个主要是c |=32用的好，查看asii码表可以知道，a-z的-范围在97到127之间int light_isalpha(int c)        c |= 32;        return (c >= 'a' && c <= 'z');}int light_isalnum(int c) {        return light_isdigit(c) || light_isalpha(c);}int buffer_to_lower(buffer *b) {        char *c;        if (b->used == 0) return 0;        for (c = b->ptr; *c; c++) {                if (*c >= 'A' && *c <= 'Z') {                        *c |= 32;                }        }        return 0;}int buffer_to_upper(buffer *b) {        char *c;        if (b->used == 0) return 0;        for (c = b->ptr; *c; c++) {                if (*c >= 'a' && *c <= 'z') {                        *c &= ~32;                }        }        return 0;}t light_isdigit(int c) {        return (c >= '0' && c <= '9');}int light_isxdigit(int c) {        if (light_isdigit(c)) return 1;        c |= 32;        return (c >= 'a' && c <= 'f');}int light_isalpha(int c) {        c |= 32;        return (c >= 'a' && c <= 'z');}int light_isalnum(int c) {        return light_isdigit(c) || light_isalpha(c);}int buffer_to_lower(buffer *b) {        char *c;        if (b->used == 0) return 0;        for (c = b->ptr; *c; c++) {                if (*c >= 'A' && *c <= 'Z') {                        *c |= 32;                }        }        return 0;}int buffer_to_upper(buffer *b) {        char *c;        if (b->used == 0) return 0;        for (c = b->ptr; *c; c++) {                if (*c >= 'a' && *c <= 'z') {                        *c &= ~32;                }        }        return 0;}

另外附近两种
char *toLowercase(char *src)
{
    char *p;
   
    p = src;
    while (*p != ‘0′)
    {
        *p = tolower(*p);
        p++;
    }
   
    return src;
}

char *toUppercase(char *src)
{
    char *p;
   
    p = src;
    while (*p != ‘0′)
    {
        *p = toupper(*p);
        p++;
    }
   
    return src;   
}

/**
 * strtolower – string to lowner
 *
 */
static char *strtolower( char *s ){
    int i, len = sizeof(s);
    for( i = 0; i < len; i++ ){
        s[i] = ( s[i] >= ‘A’ && s[i] <= ‘Z’ ? s[i] + ‘a’ – ‘A’ : s[i] );
    }
    return(s);
}
 
/**
 * strtoupper – string to upper
 *
 */
static char *strtoupper( char *s ){
    int i, len = sizeof(s);
    for( i = 0; i < len; i++ ){
        s[i] = ( s[i] >= ‘a’ && s[i] <= ‘z’ ? s[i] + ‘A’ – ‘a’ : s[i] );
    }
    return(s);
}
 
/**
 * strpos – find char at string position
 *
 */
static int strpos (const char *s, char c){
    int i, len;
    if (!s || !c) return -1;
    len = strlen(s);
    for (i=0; i<len; i++){
        if (s[i] == c) return i;
    }
    return -1;     
}