Linux C

这是一本名為“Linux C 函数參考”的在线函数参考手册. 原文来自于 https://people.cs.nycu.edu.tw/~yslin/library/linuxc/. 原文为繁体字,部分为日语, 遂决定进行繁转简.

声明: 本人不拥有文章所有权.

isalnum

isalnum（测试字符是否为英文或数字）

相关函数：isalpha，isdigit，islower，isupper

表头文件：#include <ctype.h>

定义函数：int isalnum(int c)

函数说明：检查参数c是否为英文字母或阿拉伯数字，在标准c中相当于使用"isalpha(c) || isdigit(c)"做测试。

返回值：若参数c为字母或数字，则返回TRUE，否则返回NULL(0)。

附加说明：此为宏定义，非真正函数。

范例：

/* 找出str字符串中为英文字母或数字的字符 */
#include <ctype.h>
main()
{
    char str[] = "123c@#FDsP[e?";
    int i;
    for (i = 0; str[i] != 0; i++)
        if (isalnum(str[i])) printf("%c is an alphanumeric character\n", str[i]);
}

执行： 1 is an apphabetic character

2 is an apphabetic character

3 is an apphabetic character

c is an apphabetic character

F is an apphabetic character

D is an apphabetic character

s is an apphabetic character

P is an apphabetic character

e is an apphabetic character

isalpha

isalpha（测试字符是否为英文字母）

相关函数：isalnum，islower，isupper

表头文件：#include <ctype.h>

定义函数：int isalpha (int c)

函数说明：检查参数c是否为英文字母，在标准c中相当于使用"isupper(c)||islower(c)"做测试。

返回值：若参数c为英文字母，则返回TRUE，否则返回NULL(0)。

附加说明：此为宏定义，非真正函数。

范例：

/* 找出str字符串中为英文字母的字符 */
#include <ctype.h>
main()
{
    char str[]="123c@#FDsP[e?";
    int i;
    for (i=0; str[i]!=0; i++) if(isalpha(str[i])) printf("%c is an alphanumeric character\n",str[i]);
}

执行： c is an apphabetic character

F is an apphabetic character

D is an apphabetic character

s is an apphabetic character

P is an apphabetic character

e is an apphabetic character

isascii

isascii（测试字符是否为ASCII码字符）

iscntrl

iscntrl（測試字符是否為ASCII 碼的控制字符）相關函數 isascii 表頭文件 #include <ctype.h> 定義函數 int iscntrl(int c)；函數說明檢查參數c是否為ASCII控制碼，也就是判斷c的範圍是否在0到30之間。返回值：若參數c為ASCII控制碼，則返回TRUE，否則返回NULL(0)。附加說明此為宏定義，非真正函數。

isdigit

isdigit（测试字符是否为阿拉伯数字）

isgraphis

isgraphis（测试字符是否为可打印字符）

islower

islower（测试字符是否为小写字母）

isprint

isprint（测试字符是否为可打印字符）

isspace

isspace（测试字符是否为空格字符）

ispunct

ispunct（测试字符是否为标点符号或特殊符号）

相关函数：isspace，isdigit，isalpha

表头文件：#include <ctype.h>

定义函数：int ispunct(int c)

函数说明：检查参数c是否为标点符号或特殊符号。返回TRUE也就是代表参数c为非空格、非数字和非英文字母。

返回值：若参数c为标点符号或特殊符号，则返回TRUE，否则返回NULL(0)。

附加说明：此为宏定义，非真正函数。

范例：

/* 列出字符串str中的标点符号或特殊符号 */
#include <ctype.h>
main()
{
    char str[]="123c@ #FDsP[e?";
    int i;
    for(i=0; str[i]!=0; i++) if(ispunct(str[i])) printf("%c\n",str[i]);
}

执行： @ # [ ?

isupper

isupper（测试字符是否为大写英文字母）

isxdigit

isxdigit（测试字符是否为16进制数字）

atof

atof（将字符串转换成浮点型数）

相关函数：atoi，atol，strtod，strtol，strtoul

表头文件：#include <stdlib.h>

定义函数：double atof(const char *nptr);

函数说明：atof()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。参数nptr字符串可包含正负号、小数点或E(e)来表示指数部分，如123.456或123e-2。

返回值：返回转换后的浮点型数。

附加说明：atof()与使用strtod(nptr,(char**)NULL)结果相同。

范例：

/* 将字符串a与字符串b转换成数字后相加 */
#include <stdlib.h>
main()
{
    char *a="-100.23";
    char *b="200e-2";
    float c;
    c=atof(a)+atof(b);
    printf("c=%.2f\n",c);
}

执行： c=-98.23

atoi

atoi（将字符串转换成整型数）

相关函数：atof，atol，strtod，strtol，strtoul

表头文件：#include <stdlib.h>

定义函数：int atoi(const char *nptr);

函数说明：atoi()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。

返回值：返回转换后的整型数。

附加说明：atoi()与使用strtol(nptr，(char**)NULL，10)；结果相同。

范例：

/* 将字符串a与字符串b转换成数字后相加 */
#include <stdlib.h>
main()
{
    char a[]="-100";
    char b[]="456";
    int c;
    c=atoi(a)+atoi(b);
    printf("c=%d\n",c);
}

执行： c=356

atol

atol（将字符串转换成长整型数）

相关函数：atof，atoi，strtod，strtol，strtoul

表头文件：#include <stdlib.h>

定义函数：long atol(const char *nptr);

函数说明：atol()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。

返回值：返回转换后的长整型数。

附加说明：atol()与使用strtol(nptr,(char**)NULL,10)；结果相同。

范例：

/* 将字符串a与字符串b转换成数字后相加 */
#include <stdlib.h>
main()
{
    char a[]="1000000000";
    char b[]=" 234567890";
    long c;
    c=atol(a)+atol(b);
    printf("c=%d\n",c);
}

执行： c=1234567890

gcvt

gcvt（将浮点型数转换为字符串，取四舍五入）

strtol

strtol（将字符串转换成长整型数）

相关函数：atof，atoi，atol，strtod，strtoul

表头文件：#include <stdlib.h>

定义函数：long int strtol(const char *nptr, char **endptr, int base);

函数说明：strtol()会将参数nptr字符串根据参数base来转换成长整型数。参数base范围从2至36，或0。参数base代表采用的进制方式，如base值为10则采用10进制，若base值为16则采用16进制等。当base值为0时则是采用10进制做转换，但遇到如'0x'前置字符则会使用16进制做转换。一开始strtol()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，再遇到非数字或字符串结束时('\0')结束转换，并将结果返回。若参数endptr不为NULL，则会将遇到不合条件而终止的nptr中的字符指针由endptr返回。

返回值：返回转换后的长整型数，否则返回ERANGE并将错误代码存入errno中。

附加说明：ERANGE指定的转换字符串超出合法范围。

范例：

/* 将字符串a，b，c分别采用10，2，16进制转换成数字 */
#include <stdlib.h>
main()
{
    char a[]="1000000000";
    char b[]="1000000000";
    char c[]="ffff";
    printf("a=%d\n",strtol(a,NULL,10));
    printf("b=%d\n",strtol(b,NULL,2));
    printf("c=%d\n",strtol(c,NULL,16));
}

执行： a=1000000000 b=512 c=65535

strtoul

strtoul（将字符串转换成无符号长整型数）

相关函数：atof，atoi，atol，strtod，strtol

表头文件：#include <stdlib.h>

定义函数：unsigned long int strtoul(const char *nptr, char **endptr, int base);

函数说明：strtoul()会将参数nptr字符串根据参数base来转换成无符号的长整型数。参数base范围从2至36，或0。参数base代表采用的进制方式，如base值为10则采用10进制，若base值为16则采用16进制数等。当base值为0时则是采用10进制做转换，但遇到如'0x'前置字符则会使用16进制做转换。一开始strtoul()会扫描参数nptr字符串，跳过前面的空格字符串，直到遇上数字或正负符号才开始做转换，再遇到非数字或字符串结束时('\0')结束转换，并将结果返回。若参数endptr不为NULL，则会将遇到不合条件而终止的nptr中的字符指针由endptr返回。

返回值：返回转换后的长整型数，否则返回ERANGE并将错误代码存入errno中。

附加说明：ERANGE指定的转换字符串超出合法范围。

范例：参考strtol()

toascii

toascii（将整型数转换成合法的ASCII码字符）

相关函数：isascii，toupper，tolower

表头文件：#include <ctype.h>

定义函数：int toascii(int c)

函数说明：toascii()会将参数c转换成7位的unsigned char值，第八位则会被清除，此字符即会被转成ASCII码字符。

返回值：将转换成功的ASCII码字符值返回。

范例：

#include <ctype.h>
main()
{
    int a=217;
    char b;
    printf("before toascii() : a value =%d(%c)\n",a,a);
    b=toascii(a);
    printf("after toascii() : a value =%d(%c)\n",b,b);
}

执行： beforetoascii() : a value =217()

aftertoascii() : a value =89(Y)

tolower

tolower（将大写字母转换成小写字母）

toupper

toupper（将小写字母转换成大写字母）

内存控制篇 3

TODO

calloc

calloc（配置内存空间）

相关函数：malloc，free，realloc，brk

表头文件：#include <stdlib.h>

定义函数：void *calloc(size_t nmemb, size_t size);

函数说明：calloc()用来配置nmemb个相邻的内存单位，每一单位的大小为size，并返回指向第一个元素的指针。这和下列的方式效果相同:malloc(nmemb*size);不过，在利用calloc()配置内存时会将内存内容初始化为0。

返回值：若配置成功则返回一指针，失败则返回NULL。

范例：

/* 动态配置10个struct test空间 */
#include <stdlib.h>
struct test
{
    int a[10];
    char b[20];
}
main()
{
    struct test *ptr=calloc(sizeof(
    struct test),10);
}

free

free（释放原先配置的内存）

相关函数：malloc，calloc，realloc，brk

表头文件：#include <stdlib.h>

定义函数：void free(void *ptr);

函数说明：参数ptr为指向先前由malloc()、calloc()或realloc()所返回的内存指针。调用free()后ptr所指的内存空间便会被收回。假若参数ptr所指的内存空间已被收回或是未知的内存地址，则调用free()可能会有无法预期的情况发生。若参数ptr为NULL，则free()不会有任何作用。

getpagesize

getpagesize（取得内存分页大小）

malloc

malloc（配置内存空间）

相关函数：calloc，free，realloc，brk

表头文件：#include <stdlib.h>

定义函数：void * malloc(size_t size);

函数说明：malloc()用来配置内存空间，其大小由指定的size决定。

返回值：若配置成功则返回一指针，失败则返回NULL。

范例：

void p = malloc(1024);
/*配置1k的内存*/

mmap

mmap（建立内存映射）

munmap

munmap（解除内存映射）

日期时间篇 4

TODO

asctime

asctime（将时间和日期以字符串格式表示）

相关函数：time，ctime，gmtime，localtime

表头文件：#include <time.h>

定义函数：char *asctime(const struct tm *timeptr);

函数说明：asctime()将参数timeptr所指的tm结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果以字符串形态返回。此函数已经由时区转换成当地时间，字符串格式为:"Wed Jun 30 21:49:08 1993\n"

返回值：若再调用相关的时间日期函数，此字符串可能会被破坏。此函数与ctime不同处在于传入的参数是不同的结构。

附加说明：返回一字符串表示目前当地的时间日期。

范例：

#include <time.h>
main()
{
    time_t timep;
    time(&timep);
    printf("%s",asctime(gmtime(&timep)));
}

执行： Sat Oct 28 02:10:06 2000

ctime

ctime（将时间和日期以字符串格式表示）

相关函数：time，asctime，gmtime，localtime

表头文件：#include <time.h>

定义函数：char *ctime(const time_t *timep);

函数说明：ctime()将参数timep所指的time_t结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果以字符串形态返回。此函数已经由时区转换成当地时间，字符串格式为"Wed Jun 30 21:49:08 1993\n"。若再调用相关的时间日期函数，此字符串可能会被破坏。

返回值：返回一字符串表示目前当地的时间日期。

范例：

#include <time.h>
main()
{
    time_t timep;
    time(&timep);
    printf("%s",ctime(&timep));
}

执行： Sat Oct 28 10:12:05 2000

gettimeofday

gettimeofday（取得目前的时间）

相关函数：time，ctime，ftime，settimeofday

表头文件：#include <sys/time.h> #include <unistd.h>

定义函数：int gettimeofday(struct timeval *tv, struct timezone *tz)

函数说明：gettimeofday()会把目前的时间有tv所指的结构返回，当地时区的信息则放到tz所指的结构中。 timeval结构定义为: struct timeval{ long tv_sec; /秒/ long tv_usec; /微秒/ }; timezone结构定义为: struct timezone{ int tz_minuteswest; /和Greenwich时间差了多少分钟/ int tz_dsttime; /日光节约时间的状态/ }; 上述两个结构都定义在/usr/include/sys/time.h。tz_dsttime所代表的状态如下 DST_NONE /不使用/ DST_USA /美国/ DST_AUST /澳洲/ DST_WET /西欧/ DST_MET /中欧/ DST_EET /东欧/ DST_CAN /加拿大/ DST_GB /大不列颠/ DST_RUM /罗马尼亚/ DST_TUR /土耳其/ DST_AUSTALT /澳洲（1986年以后）/

返回值：成功则返回0，失败返回－1，错误代码存于errno。附加说明EFAULT指针tv和tz所指的内存空间超出存取权限。

范例：

#include <sys/time.h>
#include <unistd.h>
main()
{
    struct timeval tv;
    struct timezone tz;
    gettimeofday(&tv, &tz);
    printf("tv_sec: %d\n", tv.tv_sec);
    printf("tv_usec: %d\n", tv.tv_usec);
    printf("tz_minuteswest: %d\n", tz.tz_minuteswest);
    printf("tz_dsttime: %d\n", tz.tz_dsttime);
}

执行： tv_sec: 974857339

tv_usec: 136996

tz_minuteswest: -540

tz_dsttime: 0

gmtime

gmtime（取得目前时间和日期）

相关函数：time, asctime, ctime, localtime

表头文件：#include <time.h>

定义函数：struct tm *gmtime(const time_t *timep);

函数说明：gmtime()将参数timep所指的time_t结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果由结构tm返回。结构tm的定义为 struct tm { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; int tm_year; int tm_wday; int tm_yday; int tm_isdst; }; int tm_sec 代表目前秒数，正常范围为0-59，但允许至61秒 int tm_min 代表目前分数，范围0-59 int tm_hour 从午夜算起的时数，范围为0-23 int tm_mday 目前月份的日数，范围01-31 int tm_mon 代表目前月份，从一月算起，范围从0-11 int tm_year 从1900年算起至今的年数 int tm_wday 一星期的日数，从星期一开始算，范围为0-6 int tm_yday 从今年1月1日算起至今的天数，范围为0-365 int tm_isdst 日光节约时间的旗标此函数返回的时间日期未经时区转换，而是UTC时间。

返回值：返回结构tm代表目前UTC时间

范例：

#include <time.h>
main()
{
    char *wday[]=
    {
        "Sun","Mon","Tue","Wed","Thu","Fri","Sat"
    };
    time_t timep;
    struct tm *p;
    time(&timep);
    p = gmtime(&timep);
    printf("%d%d%d", (1900 + p->tm_year), (1 + p->tm_mon), p->tm_mday);
    printf("%s%d:%d:%d\n", wday[p->tm_wday], p->tm_hour, p->tm_min, p->tm_sec);
}

执行： 2000/10/28 Sat 8:15:38

localtime

localtime（取得当地目前时间和日期）

相关函数：time, asctime, ctime, gmtime

表头文件：#include <time.h>

定义函数：struct tm *localtime(const time_t *timep);

函数说明：localtime()将参数timep所指的time_t结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果由结构tm返回。结构tm的定义请参考gmtime()。此函数返回的时间日期已经转换成当地时区。

返回值：返回结构tm代表目前的当地时间。

范例：

#include <time.h>
main()
{
    char *wday[]=
    {
        "Sun","Mon","Tue","Wed","Thu","Fri","Sat"
} ; time_t timep; struct tm *p; time(&timep); p=localtime(&timep); /*取得当地时间*/ printf("%d%d%d", (1900+p->tm_year), (1+p->tm_mon), p->tm_mday); printf("%s%d:%d:%d\n", wday[p->tm_wday], p->tm_hour, p->tm_min, p->tm_sec);
}

执行： 2000/10/28 Sat 11:12:22

mktime

mktime（将时间结构数据转换成经过的秒数）

相关函数：time，asctime，gmtime，localtime

表头文件：#include <time.h>

定义函数：time_t mktime(struct tm *timeptr);

函数说明：mktime()用来将参数timeptr所指的tm结构数据转换成从公元1970年1月1日0时0分0秒算起至今的UTC时间所经过的秒数。

返回值：返回经过的秒数。

范例：

/* 用time()取得时间（秒数），利用localtime() 转换成struct tm 再利用mktime()将struct tm转换成原来的秒数 */
#include <time.h>
main()
{
    time_t timep;
    struct tm *p;
    time(&timep);
    printf("time() : %d\n",timep);
    p=localtime(&timep);
    timep = mktime(p);
    printf("time()->localtime()->mktime():%d\n",timep);
}

执行： time():974943297

time()->localtime()->mktime():974943297

settimeofday

settimeofday（设置目前时间）

相关函数：time，ctime，ftime，gettimeofday

表头文件：#include <sys/time.h> #include <unistd.h>

定义函数：int settimeofday(const struct timeval *tv, const struct timezone *tz);

函数说明：settimeofday()会把目前时间设成由tv所指的结构信息，当地时区信息则设成tz所指的结构。详细的说明请参考gettimeofday()。注意，只有root权限才能使用此函数修改时间。

返回值：成功则返回0，失败返回－1，错误代码存于errno。

错误代码：EPERM 并非由root权限调用settimeofday()，权限不够。 EINVAL 时区或某个数据是不正确的，无法正确设置时间。

time

time（取得目前的时间）

相关函数：ctime，ftime，gettimeofday

表头文件：#include <time.h>

定义函数：time_t time(time_t *t);

函数说明：此函数会返回从公元1970年1月1日的UTC时间从0时0分0秒算起到现在所经过的秒数。如果t并非空指针的话，此函数也会将返回值存到t指针所指的内存。

返回值：成功则返回秒数，失败则返回((time_t)-1)值，错误原因存于errno中。

范例：

#include <time.h>
main()
{
    int seconds= time((time_t *)NULL);
    printf("%d\n",seconds);
}

执行： 9.73E+08

内存及字符串操作篇 5

TODO

bcmp

bcmp（比较内存内容）

相关函数：bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp

表头文件：#include <string.h>

定义函数：int bcmp(const void *s1, const void *s2, int n);

函数说明：bcmp()用来比较s1和s2所指的内存区间前n个字节，若参数n为0，则返回0。

返回值：若参数s1和s2所指的内存内容都完全相同则返回0值，否则返回非零值。

附加说明：建议使用memcmp()取代。

范例：参考memcmp()。

bcopy

bcopy（拷贝内存内容）

相关函数：memccpy，memcpy，memmove，strcpy，strncpy

表头文件：#include <string.h>

定义函数：void bcopy(const void *src, void *dest, int n);

函数说明：bcopy()与memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址，不过参数src与dest在传给函数时是相反的位置。

返回值：

附加说明：建议使用memcpy()取代

范例：

#include <string.h>
main()
{
    char dest[30]="string(a)";
    char src[30]="string\0string";
    int i;
    bcopy(src,dest,30);
    /* src指针放在前 */
    printf("bcopy(): ");
    for(i=0; i<30; i++) printf("%c",dest[i]);
    memcpy(dest, src,30);
    /* dest指针放在后 */
    printf("\nmemcpy() : ");
    for(i=0; i<30; i++) printf("%c",dest[i]);
}

执行： bcopy() : string string

memcpy() : string string

bzero

bzero（将一段内存内容全清为零）

index

index（查找字符串中第一个出现的指定字符）

相关函数：rindex，strchr，strrchr

表头文件：#include <string.h>

定义函数：char *index(const char *s, int c);

函数说明：index()用来找出参数s字符串中第一个出现的参数c地址，然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。

返回值：如果找到指定的字符则返回该字符所在地址，否则返回0。

范例：

#include <string.h>
main()
{
    char *s ="0123456789012345678901234567890";
    char *p;
    p = index(s,'5');
    printf("%s\n",p);
}

执行： 5.68E+25

memccpy

memccpy（拷贝内存内容）

相关函数：bcopy，memcpy，memmove，strcpy，strncpy

表头文件：#include <string.h>

定义函数：void *memccpy(void *dest, const void *src, int c, size_t n);

函数说明：memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是，memccpy()会在复制时检查参数c是否出现，若是则返回dest中值为c的下一个字节地址。

返回值：返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。

范例：

#include <string.h>
main()
{
    char a[]="string[a]";
    char b[]="string(b)";
    memccpy(a,b,'B',sizeof(b));
    printf("memccpy():%s\n",a);
}

执行： memccpy():string(b)

memchr

memchr（在某一内存范围中查找一特定字符）

相关函数：index，rindex，strchr，strpbrk，strrchr，strsep，strspn，strstr

表头文件：#include <string.h>

定义函数：void *memchr(const void *s, int c, size_t n);

函数说明：memchr()从头开始搜寻s所指的内存内容前n个字节，直到发现第一个值为c的字节，则返回指向该字节的指针。

返回值：如果找到指定的字节则返回该字节的指针，否则返回0。

范例：

#include <string.h>
main()
{
    char *s="0123456789012345678901234567890";
    char *p;
    p=memchr(s,'5',10);
    printf("%s\n",p);
}

执行： 5.68E+25

memcmp

memcmp（比较内存内容）

相关函数：bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp

表头文件：#include <string.h>

定义函数：int memcmp(const void *s1, const void *s2, size_t n);

函数说明：memcmp()用来比较s1和s2所指的内存区间前n个字符。字符串大小的比较是以ASCII码表上的顺序来决定，次顺序亦为字符的值。memcmp()首先将s1第一个字符值减去s2第一个字符的值，若差为0则再继续比较下个字符，若差值不为0则将差值返回。例如，字符串"Ac"和"ba"比较则会返回字符'A'(65)和'b'(98)的差值(－33)。

返回值：若参数s1和s2所指的内存内容都完全相同则返回0值。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0的值。

范例：

#include <string.h>
main()
{
    char *a ="aBcDeF";
    char *b="AbCdEf";
    char *c="aacdef";
    char *d="aBcDeF";
    printf("memcmp(a,b):%d\n",memcmp((void*)a,(void*)b,6));
    printf("memcmp(a,c):%d\n",memcmp((void*)a,(void*)c,6));
    printf("memcmp(a,d):%d\n",memcmp((void*)a,(void*)d,6));
}

执行： memcmp(a,b):1 /字符串a>字符串b，返回1/ memcmp(a,c):-1 /* 字符串a<字符串c,返回－1*/ memcmp(a,d):0 /字符串a＝字符串d，返回0/

memcpy

memcpy（拷贝内存内容）

相关函数：bcopy，memccpy，memcpy，memmove，strcpy，strncpy

表头文件：#include <string.h>

定义函数：void *memcpy(void *dest, const void *src, size_t n);

函数说明：memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是，memcpy()会完整的复制n个字节，不会因为遇到字符串结束'\0'而结束。

返回值：返回指向dest的指针。

附加说明：指针src和dest所指的内存区域不可重叠。

范例：

#include <string.h>
main()
{
    char a[30]="string (a)";
    char b[30]="string\0string";
    int i;
    strcpy(a,b);
    printf("strcpy():");
    for(i=0; i<30; i++) printf("%c",a[i]);
    memcpy(a,b,30);
    printf("\nmemcpy() :");
    for(i=0; i<30; i++) printf("%c",a[i]);
}

执行： strcpy() : string a )

memcpy() : string string

memmove

memmove（拷贝内存内容）

相关函数：bcopy，memccpy，memcpy，strcpy，strncpy

表头文件：#include <string.h>

定义函数：void *memmove(void *dest, const void *src, size_t n);

函数说明：memmove()与memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址上。不同的是，当src和dest所指的内存区域重叠时，memmove()仍然可以正确的处理，不过执行效率上会比使用memcpy()略慢些。

返回值：返回指向dest的指针。

附加说明：指针src和dest所指的内存区域可以重叠。

范例：参考memcpy()。

memset

memset（将一段内存空间填入某值）

rindex

rindex（查找字符串中最后一个出现的指定字符）

相关函数：index，memchr，strchr，strrchr

表头文件：#include <string.h>

定义函数：char *rindex(const char *s, int c);

函数说明：rindex()用来找出参数s字符串中最后一个出现的参数c地址，然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。

返回值：如果找到指定的字符则返回该字符所在的地址，否则返回0。

范例：

#include <string.h>
main()
{
    char *s ="0123456789012345678901234567890";
    char *p;
    p=rindex(s,'5');
    printf("%s\n",p);
}

执行： 567890

strcasecmp

strcasecmp（忽略大小写比较字符串）

相关函数：bcmp，memcmp，strcmp，strcoll，strncmp

表头文件：#include <string.h>

定义函数：int strcasecmp(const char *s1, const char *s2);

函数说明：strcasecmp()用来比较参数s1和s2字符串，比较时会自动忽略大小写的差异。

返回值：若参数s1和s2字符串相同则返回0。s1长度大于s2长度则返回大于0的值，s1长度若小于s2长度则返回小于0的值。

范例：

#include <string.h>
main()
{
    char *a="aBcDeF";
    char *b="AbCdEf";
    if(!strcasecmp(a,b)) printf("%s=%s\n",a,b);
}

执行： aBcDeF=AbCdEf

strcat

strcat（连接两字符串）

相关函数：bcopy，memccpy，memcpy，strcpy，strncpy

表头文件：#include <string.h>

定义函数：char *strcat(char *dest, const char *src);

函数说明：strcat()会将参数src字符串拷贝到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。

返回值：返回参数dest的字符串起始地址

范例：

#include <string.h>
main()
{
    char a[30]="string(1)";
    char b[]="string(2)";
    printf("before strcat() : %s\n",a);
    printf("after strcat() : %s\n",strcat(a,b));
}

执行： beforestrcat() : string(1)

afterstrcat() : string(1)string(2)

strchr

strchr（查找字符串中第一个出现的指定字符）

相关函数：index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok

表头文件：#include <string.h>

定义函数：char *strchr(const char *s, int c);

函数说明：strchr()用来找出参数s字符串中第一个出现的参数c地址，然后将该字符出现的地址返回。

返回值：如果找到指定的字符则返回该字符所在地址，否则返回0。

范例：

#include <string.h>
main()
{
    char *s="0123456789012345678901234567890";
    char *p;
    p=strchr(s,'5');
    printf("%s\n",p);
}

执行： 5.68E+25

strcmp

strcmp（比较字符串）

相关函数：bcmp，memcmp，strcasecmp，strncasecmp，strcoll

表头文件：#include <string.h>

定义函数：int strcmp(const char *s1, const char *s2);

函数说明：strcmp()用来比较参数s1和s2字符串。字符串大小的比较是以ASCII码表上的顺序来决定，此顺序亦为字符的值。strcmp()首先将s1第一个字符值减去s2第一个字符值，若差值为0则再继续比较下个字符，若差值不为0则将差值返回。例如字符串"Ac"和"ba"比较则会返回字符"A"(65)和'b'(98)的差值(－33)。

返回值：若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0的值。

范例：

#include <string.h>
main()
{
    char *a="aBcDeF";
    char *b="AbCdEf";
    char *c="aacdef";
    char *d="aBcDeF";
    printf("strcmp(a,b) : %d\n",strcmp(a,b));
    printf("strcmp(a,c) : %d\n",strcmp(a,c));
    printf("strcmp(a,d) : %d\n",strcmp(a,d));
}

执行： strcmp(a,b) : 32 strcmp(a,c) :-31 strcmp(a,d) : 0

strcoll

strcoll（采用目前区域的字符排列次序来比较字符串）

相关函数：strcmp，bcmp，memcmp，strcasecmp，strncasecmp

表头文件：#include <string.h>

定义函数：int strcoll(const char *s1, const char *s2);

函数说明：strcoll()会依环境变量LC_COLLATE所指定的文字排列次序来比较s1和s2字符串。

返回值：若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0的值。

附加说明：若LC_COLLATE为"POSIX"或"C"，则strcoll()与strcmp()作用完全相同。

范例：参考strcmp()。

strcpy

strcpy（拷贝字符串）

相关函数：bcopy，memcpy，memccpy，memmove

表头文件：#include <string.h>

定义函数：char *strcpy(char *dest, const char *src);

函数说明：strcpy()会将参数src字符串拷贝至参数dest所指的地址。

返回值：返回参数dest的字符串起始地址。

附加说明：如果参数dest所指的内存空间不够大，可能会造成缓冲溢出(buffer Overflow)的错误情况，在编写程序时请特别留意，或者用strncpy()来取代。

范例：

#include <string.h>
main()
{
    char a[30]="string(1)";
    char b[]="string(2)";
    printf("before strcpy() :%s\n",a);
    printf("after strcpy() :%s\n",strcpy(a,b));
}

执行： beforestrcpy() :string(1)

afterstrcpy() :string(2)

strcspn

strcspn（返回字符串中连续不含指定字符串内容的字符数）

strdup

strdup（复制字符串）

相关函数：calloc，malloc，realloc，free

表头文件：#include <string.h>

定义函数：char *strdup(const char *s);

函数说明：strdup()会先用malloc()配置与参数s字符串相同的空间大小，然后将参数s字符串的内容复制到该内存地址，然后把该地址返回。该地址最后可以利用free()来释放。

返回值：返回一字符串指针，该指针指向复制后的新字符串地址。若返回NULL表示内存不足。

范例：

#include <string.h>
main()
{
    char a[]="strdup";
    char *b;
    b=strdup(a);
    printf("b[]=\"%s\"\n",b);
}

执行： b[]="strdup"

strlen

strlen（返回字符串长度）

strncasecmp

strncasecmp（忽略大小写比较字符串）

相关函数：bcmp，memcmp，strcmp，strcoll，strncmp

表头文件：#include <string.h>

定义函数：int strncasecmp(const char *s1, const char *s2, size_t n);

函数说明：strncasecmp()用来比较参数s1和s2字符串前n个字符，比较时会自动忽略大小写的差异。

返回值：若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值，s1若小于s2则返回小于0的值。

范例：

#include <string.h>
main()
{
    char *a="aBcDeF";
    char *b="AbCdEf";
    if(!strncasecmp(a,b,6)) printf("%s =%s\n",a,b);
}

执行： aBcDeF=AbCdEf

strncat

strncat（连接两字符串）

相关函数：bcopy，memccpy，memcpy，strcpy，strncpy

表头文件：#include <string.h>

定义函数：char *strncat(char *dest, const char *src, size_t n);

函数说明：strncat()会将参数src字符串拷贝n个字符到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。

返回值：返回参数dest的字符串起始地址。

范例：

#include <string.h>
main()
{
    char a[30]="string(1)";
    char b[]="string(2)";
    printf("before strncat() :%s\n", a);
    printf("after strncat() :%s\n", strncat(a,b,6));
}

执行： beforestrncat() : string(1)

afterstrncat() : string(1) string

strncpy

strncpy（拷贝字符串）

相关函数：bcopy，memccpy，memcpy，memmove

表头文件：#include <string.h>

定义函数：char *strncpy(char *dest, const char *src, size_t n);

函数说明：strncpy()会将参数src字符串拷贝前n个字符至参数dest所指的地址。

返回值：返回参数dest的字符串起始地址。

范例：

#include <string.h>
main()
{
    char a[30]="string(1)";
    char b[]="string(2)";
    printf("before strncpy() : %s\n",a);
    printf("after strncpy() : %s\n",strncpy(a,b,6));
}

执行： beforestrncpy() : string(1)

afterstrncpy() : string(1)

strpbrk

strpbrk（查找字符串中第一个出现的指定字符）

相关函数：index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok

表头文件：#include <string.h>

定义函数：char *strpbrk(const char *s, const char *accept);

函数说明：strpbrk()用来找出参数s字符串中最先出现存在参数accept字符串中的任意字符。

返回值：如果找到指定的字符则返回该字符所在地址，否则返回0。

范例：

#include <string.h>
main()
{
    char *s="0123456789012345678901234567890";
    char *p;
    p=strpbrk(s,"a1 839");
    /*1会最先在s字符串中找到*/
    printf("%s\n",p);
    p=strpbrk(s,"4398");
    /*3会最先在s字符串中找到*/
    printf("%s\n",p);
}

执行： 1.23E+29

strrchr

strrchr（查找字符串中最后出现的指定字符）

相关函数：index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok

表头文件：#include <string.h>

定义函数：char *strrchr(const char *s, int c);

函数说明：strrchr()用来找出参数s字符串中最后一个出现的参数c地址，然后将该字符出现的地址返回。

返回值：如果找到指定的字符则返回该字符所在地址，否则返回0。

范例：

#include <string.h>
main()
{
    char *s="0123456789012345678901234567890";
    char *p;
    p=strrchr(s,'5');
    printf("%s\n",p);
}

执行： 567890

strspn

strspn（返回字符串中连续不含指定字符串内容的字符数）

相关函数：strcspn，strchr，strpbrk，strsep，strstr

表头文件：#include <string.h>

定义函数：size_t strspn(const char *s, const char *accept);

函数说明：strspn()从参数s字符串的开头计算连续的字符，而这些字符都完全是accept所指字符串中的字符。简单地说，若strspn()返回的数值为n，则代表字符串s开头连续有n个字符都是属于字符串accept内的字符。

返回值：返回字符串s开头连续包含字符串accept内的字符数目。

范例：

#include <string.h>
main()
{
    char *str="Linux was first developed for 386/486-based PCs.";
    char *t1="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    printf("%d\n",strspn(str,t1));
}

执行： 5 /计算大小写字母。不包含" "，所以返回Linux的长度。/

strstr

strstr（在一字符串中查找指定的字符串）

相关函数：index，memchr，rindex，strchr，strpbrk，strsep，strspn，strtok

表头文件：#include <string.h>

定义函数：char *strstr(const char *haystack, const char *needle);

函数说明：strstr()会从字符串haystack中搜寻字符串needle，并将第一次出现的地址返回。

返回值：返回指定字符串第一次出现的地址，否则返回0。

范例：

#include <string.h>
main()
{
    char *s="012345678901234567890123456789";
    char *p;
    p=strstr(s,"901");
    printf("%s\n",p);
}

执行： 9.01E+21

strtok

strtok（分割字符串）

相关函数：index，memchr，rindex，strpbrk，strsep，strspn，strstr

表头文件：#include <string.h>

定义函数：char *strtok(char *s, const char *delim);

函数说明：strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串，当strtok()在参数s的字符串中发现到参数delim的分割字符时则会将该字符改为\0字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回下一个分割后的字符串指针。

返回值：返回下一个分割后的字符串指针，已无从分割则返回NULL。

范例：

#include <string.h>
main()
{
    char s[]="ab-cd : ef;
    gh :i-jkl;
    mnop;
    qrs-tu: vwx-y;
    z";
    char *delim="-: ";
    char *p;
    printf("%s ",strtok(s,delim));
    while((p=strtok(NULL,delim))) printf("%s ",p);
    printf("\n");
}

执行： ab cd ef;gh i jkl;mnop;qrs tu vwx y;z /－与:字符已经被\0字符取代/

常用数学函数篇 6

TODO

abs

abs（计算整型数的绝对值）

acos

acos（取反余弦函数数值）

相关函数：asin, atan, atan2, cos, sin, tan

表头文件：#include <math.h>

定义函数：double acos(double x);

函数说明：acos()用来计算参数x的反余弦值，然后将结果返回。参数x范围为－1至1之间，超过此范围则会失败。

返回值：返回0至PI之间的计算结果，单位为弧度，在函数库中角度均以弧度来表示。

错误代码：EDOM参数x超出范围。

附加说明：使用GCC编译时请加入－lm。

范例：

#include <math.h>
main()
{
    double angle;
    angle = acos(0.5);
    printf("angle = %f\n", angle);
}

执行： angle = 1.047198

asin

asin（取反正弦函数值）

相关函数：acos, atan, atan2, cos, sin, tan

表头文件：#include <math.h>

定义函数：double asin(double x)

函数说明：asin()用来计算参数x的反正弦值，然后将结果返回。参数x范围为－1至1之间，超过此范围则会失败。

返回值：返回－PI/2至PI/2之间的计算结果。

错误代码：EDOM参数x超出范围

附加说明：使用GCC编译时请加入－lm

范例：

#include <math.h>
main()
{
    double angle;
    angle = asin(0.5);
    printf("angle = %f\n",angle);
}

执行： angle = 0.523599

atan

atan（取反正切函数值）

相关函数：acos，asin，atan2，cos，sin，tan

表头文件：#include <math.h>

定义函数：double atan(double x);

函数说明：atan()用来计算参数x的反正切值，然后将结果返回。

返回值：返回-PI/2至PI/2之间的计算结果。

附加说明：使用GCC编译时请加入-lm

范例：

#include <math.h>
main()
{
    double angle;
    angle = atan(1);
    printf("angle = %f\n",angle);
}

执行： angle = 1.570796

atan2

atan2（取得反正切函数值）

相关函数：acos，asin，atan，cos，sin，tan

表头文件：#include <math.h>

定义函数：double atan2(double y, double x);

函数说明：atan2()用来计算参数y/x的反正切值，然后将结果返回。

返回值：返回-PI/2至PI/2之间的计算结果。

附加说明：使用GCC编译时请加入-lm。

范例：

#include <math.h>
main()
{
    double angle;
    angle = atan2(1,2);
    printf("angle = %f\n", angle);
}

执行： angle = 0.463648

ceil

ceil（取不小于参数的最小整型数）

cos

cos（取余弦函数值）

相关函数：acos，asin，atan，atan2，sin，tan

表头文件：#include <math.h>

定义函数：double cos(double x);

函数说明：cos()用来计算参数x的余弦值，然后将结果返回。

返回值：返回-1至1之间的计算结果。

附加说明：使用GCC编译时请加入-lm。

范例：

#include <math.h>
main()
{
    double answer = cos(0.5);
    printf("cos(0.5) = %f\n",answer);
}

执行： cos(0.5) = 0.877583

cosh

cosh（取双曲线余弦函数值）

exp

exp（计算指数）

frexp

frexp（将浮点型数分为底数与指数）

ldexp

ldexp（计算2的次方值）

log

log（计算以e为底的对数值）

log10

log10（计算以10为底的对数值）

pow

pow（计算次方值）

sin

sin（取正弦函数值）

相关函数：acos，asin，atan，atan2，cos，tan

表头文件：#include <math.h>

定义函数：double sin(double x);

函数说明：sin()用来计算参数x的正弦值，然后将结果返回。

返回值：返回-1至1之间的计算结果。

附加说明：使用GCC编译时请加入-lm。

范例：

#include <math.h>
main()
{
    double answer = sin(0.5);
    printf("sin(0.5) = %f\n",answer);
}

执行： sin(0.5) = 0.479426

sinh

sinh（取双曲线正弦函数值）

sqrt

sqrt（计算平方根值）

tan

tan（取正切函数值）

tanh

tanh（取双曲线正切函数值）

用户组篇 7

TODO

endgrent

endgrent（结束组用户数据存取）

endpwent

endpwent（结束密码文件数据存取）

endutent

endutent（结束用户登录数据存取）

fgetgrent

fgetgrent（从指定的文件来读取组格式数据）

fgetpwent

fgetpwent（从指定的文件来读取密码格式数据）

getegid

getegid（取得有效的组识别码）

相关函数：getgid，setgid，setregid

表头文件：#include <unistd.h> #include <sys/types.h>

定义函数：uid_t getegid(void);

函数说明：getegid()用来取得执行目前进程的有效组识别码。有效的组识别码用来决定进程执行的权限范围。如果进程调用setegid()，有效的组识别码可能会与实际的组识别码不同。

返回值：返回有效的组识别码。

范例：

/* 显示进程的实际和有效的组识别码 */
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
main()
{
    printf("egid is %d\n", getegid());
}

执行： egid is 0

geteuid

geteuid（取得有效的用户识别码）

相关函数：getuid，setreuid，seteuid

表头文件：#include <unistd.h> #include <sys/types.h>

定义函数：uid_t geteuid(void);

函数说明：geteuid()用来取得执行目前进程的有效用户识别码。有效的用户识别码用来决定进程执行的权限范围。如果进程调用seteuid()，有效的用户识别码可能会与实际的用户识别码不同。

返回值：返回有效的用户识别码。

范例：

/* 显示进程的实际和有效的用户识别码 */
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
main()
{
    printf("euid is %d\n", geteuid());
}

执行： euid is 0

getgid

getgid（取得组识别码）

相关函数：getegid，setgid，setregid

表头文件：#include <unistd.h> #include <sys/types.h>

定义函数：gid_t getgid(void);

函数说明：getgid()用来取得执行目前进程的组识别码。

返回值：返回组识别码。

范例：

/* 显示进程的组识别码 */
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
main()
{
    printf("gid is %d\n", getgid());
}

执行： gid is 0

getgrent

getgrent（取得组数据文件内容）

相关函数：fgetgrent，setgrent，endgrent

表头文件：#include <grp.h> #include <sys/types.h>

定义函数：struct group *getgrent(void);

函数说明：getgrent()用来从组文件（/etc/group）中读取组数据，每一次调用只读取一行数据。第一次调用时，会打开组文件并返回第一个组数据；之后每调用一次就会返回下一组数据，直到文件末尾或发生错误。getgrent()会返回一个group结构指针。返回后，group结构指针指向已分配的内存空间，之后不要再使用getgrent()读取，不然内存空间会被覆盖。

返回值：如果成功返回group结构指针，如果出错或文件已结束则返回NULL。

附加说明：组文件格式请参考/etc/group。 struct group { char gr_name; / 组名称 */ char gr_passwd; / 组密码 / gid_t gr_gid; / 组识别码 */ char *gr_mem; / 组账号 */ };

范例：

/* 将/etc/group中的账号数据由标准输出设备打印出来 */
#include <grp.h>
#include <sys/types.h>
#include <stdio.h>
main()
{
    struct group *group;
    while ((group = getgrent()) != NULL) printf("name:%s,password:%s,gid:%d\n", group->gr_name, group->gr_passwd, group->gr_gid);
    endgrent();
}

执行： name:root,password:x,

gid:0name:bin,password:x,

gid:1name:daemon,password:x,

gid:2name:sys,password:x,

gid:3name:adm,password:x,

gid:4name:tty,password:x,

gid:5name:disk,password:x,

gid:6name:lp,password:x,

gid:7name:mem,password:x,

gid:8name:kmem,password:x,

gid:9 …….

getgrgid

getgrgid（从组识别码取得组数据）

getgrnam

getgrnam（从组名称取得组数据）

getgroups

getgroups（取得一组组识别码）

相关函数：initgroups，setgroups，getgid

表头文件：#include <unistd.h> #include <sys/types.h>

定义函数：int getgroups(int size, gid_t list[]);

函数说明：getgroups()用来将目前进程所属用户的组识别码列表放到参数list所指向的内存空间中。参数size代表list数组的最大容量。如果size为0，则getgroups()仅返回用户所属的组识别码总数。

返回值：如果成功则返回组识别码总数，如果出错则返回-1。

错误代码：EFAULT：参数list的地址无效。

范例：

/* 显示进程所属用户的组识别码 */
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
main()
{
    gid_t list[100];
    int i;
    int num = getgroups(100, list);
    for (i = 0; i < num; i++) printf("%d\n", list[i]);
}

执行： 0 1 2 3 4 5 6 7 8 9 …….

tgetpw

tgetpw（从用户识别码取得用户数据）

getpwent

getpwent（取得密码文件数据内容）

相关函数：getpw，fgetpwent，setpwent，endpwent

表头文件：#include <pwd.h> #include <sys/types.h>

定义函数：struct passwd *getpwent(void);

函数说明：getpwent()用来从密码文件（/etc/passwd）中读取用户数据，每一次调用只读取一行数据。第一次调用时，会打开密码文件并返回第一个用户数据；之后每调用一次就会返回下一用户数据，直到文件末尾或发生错误。getpwent()会返回一个passwd结构指针。返回后，passwd结构指针指向已分配的内存空间，之后不要再使用getpwent()读取，不然内存空间会被覆盖。

返回值：如果成功返回passwd结构指针，如果出错或文件已结束则返回NULL。

附加说明：密码文件格式请参考/etc/passwd。 struct passwd { char pw_name; / 用户名称 */ char pw_passwd; / 用户密码 / uid_t pw_uid; / 用户识别码 / gid_t pw_gid; / 组识别码 */ char pw_gecos; / 用户全名 */ char pw_dir; / 主目录 */ char pw_shell; / 使用的shell */ };

范例：

/* 将/etc/passwd中的账号数据由标准输出设备打印出来 */
#include <pwd.h>
#include <sys/types.h>
#include <stdio.h>
main()
{
    struct passwd *user;
    while ((user = getpwent()) != NULL) printf("name:%s,uid:%d,home:%s\n", user->pw_name, user->pw_uid, user->pw_dir);
    endpwent();
}

执行： name:root,

uid:0,home:/rootname:bin,

uid:1,home:/binname:daemon,

uid:2,home:/sbinname:adm,

uid:3,home:/var/admname:lp,

uid:4,home:/var/spool/lpdname:sync,

uid:5,home:/sbinname:shutdown,

uid:6,home:/sbinname:halt,

uid:7,home:/sbin …….

getpwnam

getpwnam（从用户名称取得用户数据）

getpwuid

getpwuid（从用户识别码取得用户数据）

getuid

getuid（取得用户识别码）

相关函数：geteuid，setreuid，seteuid

表头文件：#include <unistd.h> #include <sys/types.h>

定义函数：uid_t getuid(void);

函数说明：getuid()用来取得执行目前进程的用户识别码。

返回值：返回用户识别码。

范例：

/* 显示进程的用户识别码 */
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
main()
{
    printf("uid is %d\n", getuid());
}

执行： uid is 0

getutent

getutent（从utmp文件中取得账号登录数据）

相关函数：getutid，getutline，setutent，endutent，pututline，utmpname

表头文件：#include <utmp.h>

定义函数：struct utmp *getutent(void);

函数说明：getutent()用来从utmp文件（/var/run/utmp）中读取用户登录数据，每一次调用只读取一行数据。第一次调用时，会打开utmp文件并返回第一个用户数据；之后每调用一次就会返回下一用户数据，直到文件末尾或发生错误。getutent()会返回一个utmp结构指针。返回后，utmp结构指针指向已分配的内存空间，之后不要再使用getutent()读取，不然内存空间会被覆盖。

返回值：如果成功返回utmp结构指针，如果出错或文件已结束则返回NULL。 struct utmp { short int ut_type; /* 登录类型 / pid_t ut_pid; / 登录进程的pid / char ut_line[UT_LINESIZE]; / 设备名 / char ut_id[4]; / 登录记录id / char ut_user[UT_NAMESIZE]; / 用户名 / char ut_host[UT_HOSTSIZE]; / 远程主机名 / struct exit_status ut_exit; / 进程退出状态 / long int ut_session; / 会话id / struct timeval ut_tv; / 登录时间 / int32_t ut_addr_v6[4]; / 远程主机IP地址 / char __unused[20]; / 保留 */ };

范例：

#include <utmp.h>
#include <stdio.h>
main()
{
    struct utmp *ut;
    while ((ut = getutent()) != NULL) printf("%s %s %s\n", ut->ut_user, ut->ut_line, ut->ut_host);
    endutent();
}

执行： reboot ~

root tty1

dmtsai tty2

dmtsai pts/0

getutid

getutid（从utmp文件中查找特定记录）

相关函数：getutent，getutline，setutent，endutent，pututline，utmpname

表头文件：#include <utmp.h>

定义函数：struct utmp *getutid(const struct utmp *ut);

函数说明：getutid()用来从utmp文件中查找参数ut所指定的记录。ut结构中有ut_type和ut_id两个字段。如果ut_type为RUN_LVL、BOOT_TIME、OLD_TIME、NEW_TIME之一，则查找ut_type相符的记录；否则查找ut_id相符的记录。找到则返回utmp结构指针，以后续调用可返回下一个匹配的记录。

返回值：如果成功返回utmp结构指针，如果出错或文件已结束则返回NULL。

范例：

#include <utmp.h>
#include <stdio.h>
main()
{
    struct utmp ut, *u;
    ut.ut_type = BOOT_TIME;
    u = getutid(&ut);
    if (u != NULL)
        printf("Boot time %s\n", ctime(&(u->ut_tv.tv_sec)));
    endutent();
}

执行： Boot time Mon Jan 20 10:59:27 2003

getutline

getutline（从utmp文件中查找特定设备记录）

相关函数：getutent，getutid，setutent，endutent，pututline，utmpname

表头文件：#include <utmp.h>

定义函数：struct utmp *getutline(const struct utmp *ut);

函数说明：getutline()用来从utmp文件中查找参数ut所指定的ut_line设备记录，找到则返回utmp结构指针。

返回值：如果成功返回utmp结构指针，如果出错或文件已结束则返回NULL。

范例：

#include <utmp.h>
#include <stdio.h>
main()
{
    struct utmp ut, *u;
    strcpy(ut.ut_line, "tty1");
    u = getutline(&ut);
    if (u != NULL)
        printf("%s %s %s\n", u->ut_user, u->ut_line, u->ut_host);
    endutent();
}

执行： root tty1

initgroups

initgroups（初始化组列表）

相关函数：setgroups，getgroups，getgid

表头文件：#include <grp.h> #include <sys/types.h>

定义函数：int initgroups(const char *user, gid_t group);

函数说明：initgroups()用来从组文件（/etc/group）中读取参数user所属组的组识别码，然后调用setgroups()将组识别码添加到进程的组列表中。参数group为附加的组识别码。

返回值：如果成功返回0，如果出错则返回-1。

pututline

pututline（将utmp记录写入文件）

相关函数：getutent，getutid，getutline，setutent，endutent，utmpname

表头文件：#include <utmp.h>

定义函数：void pututline(const struct utmp *ut);

函数说明：pututline()用来将参数ut所指向的utmp结构写入utmp文件。

返回值：

seteuid

seteuid（设置有效的用户识别码）

相关函数：setuid，setreuid，geteuid

表头文件：#include <unistd.h> #include <sys/types.h>

定义函数：int seteuid(uid_t euid);

函数说明：seteuid()用来设置当前进程的有效用户识别码。参数euid为新的有效用户识别码。如果进程有root权限，则可以将有效用户识别码设置为任意值；否则只能设置为实际用户识别码或保存的设置用户识别码。

返回值：如果成功返回0，如果出错则返回-1。

错误代码：EPERM：进程权限不足。

范例：

#include <unistd.h>
#include <sys/types.h>
main()
{
    seteuid(500);
}

setfsgid

setfsgid（设置文件系统组识别码）

setfsuid

setfsuid（设置文件系统用户识别码）

setgid

setgid（设置组识别码）

相关函数：getgid，setregid，getegid

表头文件：#include <unistd.h> #include <sys/types.h>

定义函数：int setgid(gid_t gid);

函数说明：setgid()用来设置当前进程的组识别码。如果进程有root权限，则可以将组识别码设置为任意值；否则只能设置为实际组识别码或有效组识别码。设置后实际组识别码和有效组识别码都会改变。

返回值：如果成功返回0，如果出错则返回-1。

错误代码：EPERM：进程权限不足。

范例：

#include <unistd.h>
#include <sys/types.h>
main()
{
    setgid(500);
}

setgrent

setgrent（从头读取组数据文件）

setgroups

setgroups（设置组识别码列表）

相关函数：initgroups，getgroups，getgid

表头文件：#include <grp.h> #include <sys/types.h>

定义函数：int setgroups(size_t size, const gid_t *list);

函数说明：setgroups()用来将参数list所指的组识别码列表设置为当前进程的组识别码。参数size为list数组的大小。此函数需要root权限才能执行。

返回值：如果成功返回0，如果出错则返回-1。

错误代码：EPERM：进程权限不足。 EFAULT：参数list的地址无效。

setpwent

setpwent（从头读取密码数据文件）

setregid

setregid（设置实际及有效的组识别码）

setreuid

setreuid（设置实际及有效的用户识别码）

setuid

setuid（设置用户识别码）

相关函数：getuid，setreuid，seteuid

表头文件：#include <unistd.h> #include <sys/types.h>

定义函数：int setuid(uid_t uid);

函数说明：setuid()用来设置当前进程的用户识别码。如果进程有root权限，则可以将用户识别码设置为任意值；否则只能设置为实际用户识别码或有效用户识别码。设置后实际用户识别码和有效用户识别码都会改变。

返回值：如果成功返回0，如果出错则返回-1。

错误代码：EPERM：进程权限不足。

范例：

#include <unistd.h>
#include <sys/types.h>
main()
{
    setuid(500);
}

setutent

setutent（从头读取utmp文件）

utmpname

utmpname（指定utmp文件名）

相关函数：getutent，getutid，getutline，setutent，endutent，pututline

表头文件：#include <utmp.h>

定义函数：void utmpname(const char *file);

函数说明：utmpname()用来指定utmp文件名称，供后续的getutent()、getutid()、getutline()及pututline()使用。如果不调用utmpname()，默认使用/var/run/utmp文件。

返回值：

数据结构及算法篇 8

TODO

crypt

crypt（密码加密函数）

bsearch

bsearch（二分查找数据）

lfind

lfind（线性查找数据）

lsearch

lsearch（线性查找数据，找不到则添加）

qsort

qsort（快速排序）

rand

rand（产生随机数）

srand

srand（设置随机数种子）

文件操作篇 9

TODO

close

close（关闭文件）

相关函数：open，fcntl，shutdown，unlink，fclose

表头文件：#include <unistd.h>

定义函数：int close(int fd);

函数说明：close()用来关闭参数fd所指向的文件。当文件关闭后，该文件描述符可以被重新使用。所有与文件相关的记录锁也会被移除。

返回值：如果成功返回0，如果出错则返回-1。

错误代码：EBADF：参数fd无效的文件描述符。

范例：

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
    int fd;
    fd = open("/tmp/test.txt", O_CREAT | O_RDWR, 0777);
    if (fd != -1)
    {
        printf("打开文件成功\n");
        close(fd);
    }
else printf("打开文件失败\n");
}

creat

creat（创建文件）

dup

dup（复制文件描述符）

相关函数：open，close，fcntl，dup2

表头文件：#include <unistd.h>

定义函数：int dup(int oldfd);

函数说明：dup()用来复制参数oldfd所指向的文件描述符。复制成功后，新的文件描述符和原来的文件描述符共享同一个文件指针。dup()会使用当前最小的未使用文件描述符作为新的文件描述符。

返回值：如果成功返回新的文件描述符，如果出错则返回-1。

错误代码：EBADF：参数oldfd无效的文件描述符。 EMFILE：进程已打开的文件描述符数量已达上限。

范例：

#include <unistd.h>
#include <stdio.h>
main()
{
    int newfd;
    newfd = dup(1);
    /* 复制标准输出 */
    if (newfd != -1)
        printf("复制成功，新文件描述符为%d\n", newfd);
}

dup2

dup2（复制文件描述符）

相关函数：open，close，fcntl，dup

表头文件：#include <unistd.h>

定义函数：int dup2(int oldfd, int newfd);

函数说明：dup2()用来复制参数oldfd所指向的文件描述符，并将它复制到参数newfd所指定的文件描述符。如果newfd已经打开，则先将其关闭。成功复制后，两个文件描述符共享同一个文件指针。

返回值：如果成功返回新的文件描述符，如果出错则返回-1。

错误代码：EBADF：参数oldfd无效的文件描述符。 EMFILE：进程已打开的文件描述符数量已达上限。

范例：

#include <unistd.h>
#include <stdio.h>
main()
{
    dup2(1, 3);
    /* 复制标准输出到文件描述符3 */
    printf("复制成功\n");
}

fcntl

fcntl（文件描述符控制）

flock

flock（文件加锁/解锁）

fsync

fsync（将缓冲区数据写入磁盘）

lseek

lseek（移动文件的读写指针）

mkstemp

mkstemp（创建临时文件）

相关函数：tmpfile，tmpnam，mktemp

表头文件：#include <stdlib.h>

定义函数：int mkstemp(char *template);

函数说明：mkstemp()用来创建临时文件。参数template为文件名模板，最后六个字符必须是"XXXXXX"，这些字符会被替换为随机字符，生成唯一的文件名。创建的文件权限为0600。

返回值：如果成功返回文件描述符，如果出错则返回-1。

范例：

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
main()
{
    char template[] = "/tmp/tempXXXXXX";
    int fd;
    fd = mkstemp(template);
    if (fd != -1)
    {
        printf("临时文件%s创建成功\n", template);
        close(fd);
    }
}

执行：临时文件/tmp/tempGxHsZI创建成功

open

open（打开文件）

相关函数：creat，close，read，write，fcntl，lseek

表头文件：#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h>

定义函数：int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode);

函数说明：open()用来打开或创建文件。参数pathname为文件路径，参数flags为打开方式。 flags取值： O_RDONLY：只读模式 O_WRONLY：只写模式 O_RDWR：读写模式 O_CREAT：如果文件不存在则创建 O_EXCL：与O_CREAT一起使用时，如果文件已存在则返回错误 O_TRUNC：如果文件存在则将文件长度截断为0 O_APPEND：追加模式参数mode为创建文件时的权限。open()返回最小的未用文件描述符。

返回值：如果成功返回文件描述符，如果出错则返回-1。

错误代码：EACCES：权限不足。 EEXIST：文件已存在且设置了O_CREAT和O_EXCL。 EINTR：调用被信号中断。 EISDIR：pathname指向目录。 EMFILE：进程已打开的文件描述符数量已达上限。 ENOENT：文件或目录不存在。

范例：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
main()
{
    int fd;
    fd = open("/tmp/test.txt", O_CREAT | O_RDWR, 0777);
    if (fd != -1)
    {
        printf("打开文件成功，文件描述符=%d\n", fd);
        close(fd);
    }
else printf("打开文件失败\n");
}

read

read（从文件读取数据）

相关函数：write，open，close，lseek，fcntl

表头文件：#include <unistd.h>

定义函数：ssize_t read(int fd, void *buf, size_t count);

函数说明：read()用来从参数fd所指向的文件中读取数据，读取的数据存放到参数buf所指向的内存中。参数count为要读取的字节数。实际读取的字节数可能会小于count，例如在读取到文件末尾时。

返回值：如果成功返回实际读取的字节数，如果返回0表示已到达文件末尾，如果出错则返回-1。

错误代码：EBADF：参数fd无效的文件描述符或不可读。 EFAULT：参数buf指向的内存空间不可访问。 EINTR：调用被信号中断。 EIO：发生I/O错误。

范例：

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
    int fd;
    char buf[100];
    fd = open("/tmp/test.txt", O_RDONLY);
    if (fd != -1)
    {
        int n = read(fd, buf, sizeof(buf));
        if (n > 0)
            write(STDOUT_FILENO, buf, n);
        close(fd);
    }
}

sync

sync（将缓冲区数据写入磁盘）

write

write（写入文件）

相关函数：read，open，close，lseek，fcntl

表头文件：#include <unistd.h>

定义函数：ssize_t write(int fd, const void *buf, size_t count);

函数说明：write()用来将参数buf所指向的内存中的数据写入参数fd所指向的文件中。参数count为要写入的字节数。实际写入的字节数可能会小于count。

返回值：如果成功返回实际写入的字节数，如果出错则返回-1。

错误代码：EBADF：参数fd无效的文件描述符或不可写。 EFAULT：参数buf指向的内存空间不可访问。 EINTR：调用被信号中断。 EIO：发生I/O错误。 ENOSPC：磁盘空间不足。

范例：

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
    int fd;
    char buf[] = "Hello, World!";
    fd = open("/tmp/test.txt", O_CREAT | O_RDWR, 0777);
    if (fd != -1)
    {
        write(fd, buf, sizeof(buf) - 1);
        close(fd);
    }
}

文件内容操作篇 10

TODO

clearerr

clearerr（清除文件流的错误标志）

fclose

fclose（关闭文件）

相关函数：close，fflush，fopen，setbuf

表头文件：#include <stdio.h>

定义函数：int fclose(FILE *stream);

函数说明：fclose()用来关闭先前fopen()打开的文件。此动作会让缓冲区内的数据写入文件中，并释放系统所提供的文件资源。

返回值：若关闭文件动作成功则返回0，有错误发生时则返回EOF并把错误代码存到errno。

错误代码：EBADF表示参数stream非已打开的文件。

范例：请参考fopen()。

fdopen

fdopen（将文件描述词转为文件指针）

feof

feof（检查文件流是否读到了文件尾）

相关函数：fopen，fgetc，fgets，fread

表头文件：#include <stdio.h>

定义函数：int feof(FILE *stream);

函数说明：feof()用来检测是否读取到了文件尾，参数stream为fopen()所返回的文件指针。如果已到文件尾则返回非零值，其他情况返回0。

返回值：返回非零值代表已到达文件尾。

fflush

fflush（更新缓冲区）

相关函数：write，fopen，fclose，setbuf

表头文件：#include <stdio.h>

定义函数：int fflush(FILE *stream);

函数说明：fflush()会强迫将缓冲区内的数据写回参数stream指定的文件中。如果参数stream为NULL，fflush()会将所有打开的文件数据更新。

返回值：成功返回0，失败返回EOF，错误代码存于errno中。

错误代码：EBADF 参数stream指定的文件未被打包，或打开状态为只读。其它错误代码参考write()。

fgetc

fgetc（由文件中读取一个字符）

相关函数：open，fread，fscanf，getc

表头文件：#include <stdio.h>

定义函数：int fgetc(FILE *stream);

函数说明：fgetc()从参数stream所指的文件中读取一个字符。若读到文件尾而无数据时便返回EOF。

返回值：getc()会返回读取到的字符，若返回EOF则表示到了文件尾。

范例：

#include <stdio.h>
main()
{
    FILE *fp;
    int c;
    fp = fopen("exist", "r");
    while ((c = fgetc(fp)) != EOF) printf("%c", c);
    fclose(fp);
}

fgets

fgets（由文件中读取一字符串）

相关函数：open，fread，fscanf，getc

表头文件：#include <stdio.h>

定义函数：char *fgets(char *s, int size, FILE *stream);

函数说明：fgets()用来从参数stream所指的文件内读入字符并存到参数s所指的内存空间，直到出现换行字符、读到文件尾或是已读了size-1个字符为止，最后会加上NULL作为字符串结束。

返回值：gets()若成功则返回s指针，返回NULL则表示有错误发生。

范例：

#include <stdio.h>
main()
{
    char s[80];
    fputs(fgets(s, 80, stdin), stdout);
}

执行： this is a test /输入/ this is a test /输出/

fileno

fileno（返回文件流所使用的文件描述词）

fopen

fopen（打开文件）

fputc

fputc（将一指定字符写入文件流中）

相关函数：fopen，fwrite，fscanf，putc

表头文件：#include <stdio.h>

定义函数：int fputc(int c, FILE *stream);

函数说明：fputc会将参数c转为unsigned char后写入参数stream指定的文件中。

返回值：fputc()会返回写入成功的字符，即参数c。若返回EOF则代表写入失败。

范例：

#include <stdio.h>
main()
{
    FILE *fp;
    char a[26] = "abcdefghijklmnopqrstuvwxyz";
    int i;
    fp = fopen("noexist", "w");
    for (i = 0; i < 26; i++) fputc(a[i], fp);
    fclose(fp);
}

fputs

fputs（将一指定的字符串写入文件内）

相关函数：fopen，fwrite，fscanf，fputc，putc

表头文件：#include <stdio.h>

定义函数：int fputs(const char *s, FILE *stream);

函数说明：fputs()用来将参数s所指的字符串写入到参数stream所指的文件内。

返回值：若成功则返回写出的字符个数，返回EOF则表示有错误发生。

范例：请参考fgets()。

fread

fread（从文件流读取数据）

相关函数：fopen，fwrite，fseek，fscanf

表头文件：#include <stdio.h>

定义函数：size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

函数说明：fread()用来从文件流中读取数据。参数stream为已打开的文件指针，参数ptr指向欲存放读取进来的数据空间，读取的字符数以参数size*nmemb来决定。Fread()会返回实际读取到的nmemb数目，如果此值比参数nmemb来得小，则代表可能读到了文件尾或有错误发生，这时必须用feof()或ferror()来决定发生什么情况。

返回值：返回实际读取到的nmemb数目。

附加说明：

范例：

#include <stdio.h>
#define nmemb 3
struct test
{
    char name[20];
    int size;
}
s[nmemb];
main()
{
    FILE *stream;
    int i;
    stream = fopen("/tmp/fwrite", "r");
    fread(s, sizeof(struct test), nmemb, stream);
    fclose(stream);
    for (i = 0; i < nmemb; i++) printf("name[%d]=%-20s:size[%d]=%d\n", i, s[i].name, i, s[i].size);
}

执行： name[0]=Linux! size[0]=6

name[1]=FreeBSD! size[1]=8

name[2]=Windows2000 size[2]=11

freopen

freopen（打开文件）

fseek

fseek（移动文件流的读写位置）

相关函数：rewind，ftell，fgetpos，fsetpos，lseek

表头文件：#include <stdio.h>

定义函数：int fseek(FILE *stream, long offset, int whence);

函数说明：fseek()用来移动文件流的读写位置。参数stream为已打开的文件指针，参数offset为根据参数whence来移动读写位置的位移数。参数 whence为下列其中一种: SEEK_SET从距文件开头offset位移量为新的读写位置。SEEK_CUR以目前的读写位置往后增加offset个位移量。 SEEK_END将读写位置指向文件尾后再增加offset个位移量。当whence值为SEEK_CUR或SEEK_END时，参数offset允许负值的出现。下列是较特别的使用方式: 1. 欲将读写位置移动到文件开头时:fseek(FILE *stream,0,SEEK_SET); 2. 欲将读写位置移动到文件尾时:fseek(FILE *stream,0,SEEK_END);

返回值：当调用成功时则返回0，若有错误则返回-1，errno会存放错误代码。

附加说明：fseek()不像lseek()会返回读写位置，因此必须使用ftell()来取得目前读写的位置。

范例：

#include <stdio.h>
main()
{
    FILE *stream;
    long offset;
    fpos_t pos;
    stream = fopen("/etc/passwd", "r");
    fseek(stream, 5, SEEK_SET);
    printf("offset=%d\n", ftell(stream));
    rewind(stream);
    fgetpos(stream, &pos);
    printf("offset=%d\n", pos);
    pos = 10;
    fsetpos(stream, &pos);
    printf("offset=%d\n", ftell(stream));
    fclose(stream);
}

执行： offset=5 offset=0 offset=10

ftell

ftell（取得文件流的读取位置）

相关函数：fseek，rewind，fgetpos，fsetpos

表头文件：#include <stdio.h>

定义函数：long ftell(FILE *stream);

函数说明：ftell()用来取得文件流目前的读写位置。参数stream为已打开的文件指针。

返回值：当调用成功时则返回目前的读写位置，若有错误则返回-1，errno会存放错误代码。

错误代码：EBADF 参数stream无效或可移动读写位置的文件流。

范例：参考fseek()。

fwrite

fwrite（将数据写至文件流）

相关函数：fopen，fread，fseek，fscanf

表头文件：#include <stdio.h>

定义函数：size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

函数说明：fwrite()用来将数据写入文件流中。参数stream为已打开的文件指针，参数ptr指向欲写入的数据地址，总共写入的字符数以参数size*nmemb来决定。Fwrite()会返回实际写入的nmemb数目。

返回值：返回实际写入的nmemb数目。

范例：

#include <stdio.h>
#define set_s(x, y)
{
    strcpy(s[x].name, y);
    s[x].size = strlen(y);
}
#define nmemb 3
struct test
{
    char name[20];
    int size;
}
s[nmemb];
main()
{
    FILE *stream;
    set_s(0, "Linux!");
    set_s(1, "FreeBSD!");
    set_s(2, "Windows2000.");
    stream = fopen("/tmp/fwrite", "w");
    fwrite(s, sizeof(struct test), nmemb, stream);
    fclose(stream);
}

执行：参考fread()。

getc

getc（由文件中读取一个字符）

相关函数：read，fopen，fread，fgetc

表头文件：#include <stdio.h>

定义函数：int getc(FILE *stream);

函数说明：getc()用来从参数stream所指的文件中读取一个字符。若读到文件尾而无数据时便返回EOF。虽然getc()与fgetc()作用相同，但getc()为宏定义，非真正的函数调用。

返回值：getc()会返回读取到的字符，若返回EOF则表示到了文件尾。

范例：参考fgetc()。

getchar

getchar（由标准输入设备内读进一字符）

相关函数：fopen，fread，fscanf，getc

表头文件：#include <stdio.h>

定义函数：int getchar(void);

函数说明：getchar()用来从标准输入设备中读取一个字符。然后将该字符从unsigned char转换成int后返回。

返回值：getchar()会返回读取到的字符，若返回EOF则表示有错误发生。

附加说明：getchar()非真正函数，而是getc(stdin)宏定义。

范例：

#include <stdio.h>
main()
{
    FILE *fp;
    int c, i;
    for (i = 0; i < 5; i++)
    {
        c = getchar();
        putchar(c);
    }
}

执行： 1234 /输入/ 1234 /输出/

gets

gets（由标准输入设备内读进一字符串）

相关函数：fopen，fread，fscanf，fgets

表头文件：#include <stdio.h>

定义函数：char *gets(char *s);

函数说明：gets()用来从标准设备读入字符并存到参数s所指的内存空间，直到出现换行字符或读到文件尾为止，最后加上NULL作为字符串结束。

返回值：gets()若成功则返回s指针，返回NULL则表示有错误发生。

附加说明：由于gets()无法知道字符串s的大小，必须遇到换行字符或文件尾才会结束输入，因此容易造成缓冲溢出的安全性问题。建议使用fgets()取代。

范例：参考fgets()

mktemp

mktemp（产生唯一的临时文件名）

putc

putc（将一指定字符写入文件中）

相关函数：fopen，fwrite，fscanf，fputc

表头文件：#include <stdio.h>

定义函数：int putc(int c, FILE *stream);

函数说明：putc()会将参数c转为unsigned char后写入参数stream指定的文件中。虽然putc()与fputc()作用相同，但putc()为宏定义，非真正的函数调用。

返回值：putc()会返回写入成功的字符，即参数c。若返回EOF则代表写入失败。

范例：参考fputc()

putchar

putchar（将指定的字符写到标准输出设备）

相关函数：fopen，fwrite，fscanf，fputc

表头文件：#include <stdio.h>

定义函数：int putchar(int c);

函数说明：putchar()用来将参数c字符写到标准输出设备。

返回值：putchar()会返回输出成功的字符，即参数c。若返回EOF则代表输出失败。

附加说明：putchar()非真正函数，而是putc(c, stdout)宏定义。

范例：参考getchar()。

rewind

rewind（重设文件流的读写位置为文件开头）

相关函数：fseek，ftell，fgetpos，fsetpos

表头文件：#include <stdio.h>

定义函数：void rewind(FILE *stream);

函数说明：rewind()用来把文件流的读写位置移至文件开头。参数stream为已打开的文件指针。此函数相当于调用fseek(stream, 0, SEEK_SET)。

返回值：

范例：参考fseek()

setbuf

setbuf（设置文件流的缓冲区）

相关函数：setbuffer，setlinebuf，setvbuf

表头文件：#include <stdio.h>

定义函数：void setbuf(FILE *stream, char *buf);

函数说明：在打开文件流后，读取内容之前，调用setbuf()可以用来设置文件流的缓冲区。参数stream为指定的文件流，参数buf指向自定的缓冲区起始地址。如果参数buf为NULL指针，则为无缓冲IO。Setbuf()相当于调用:setvbuf(stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ)

返回值：

setbuffer

setbuffer（设置文件流的缓冲区）

相关函数：setlinebuf，setbuf，setvbuf

表头文件：#include <stdio.h>

定义函数：void setbuffer(FILE *stream, char *buf, size_t size);

函数说明：在打开文件流后，读取内容之前，调用setbuffer()可用来设置文件流的缓冲区。参数stream为指定的文件流，参数buf指向自定的缓冲区起始地址，参数size为缓冲区大小。

返回值：

setlinebuf

setlinebuf（设置文件流为线性缓冲区）

相关函数：setbuffer，setbuf，setvbuf

表头文件：#include <stdio.h>

定义函数：void setlinebuf(FILE *stream);

函数说明：setlinebuf()用来设置文件流以换行为依据的无缓冲IO。相当于调用:setvbuf(stream, (char *)NULL, _IOLBF, 0);请参考setvbuf()。

返回值：

setvbuf

setvbuf（设置文件流的缓冲区）

相关函数：setbuffer，setlinebuf，setbuf

表头文件：#include <stdio.h>

定义函数：int setvbuf(FILE *stream, char *buf, int mode, size_t size);

函数说明：在打开文件流后，读取内容之前，调用setvbuf()可以用来设置文件流的缓冲区。参数stream为指定的文件流，参数buf指向自定的缓冲区起始地址，参数size为缓冲区大小，参数mode有下列几种: _IONBF 无缓冲IO _IOLBF 以换行为依据的无缓冲IO _IOFBF 完全无缓冲IO。如果参数buf为NULL指针，则为无缓冲IO。

返回值：

ungetc

ungetc（将指定字符写回文件流中）

进程操作篇 11

TODO

atexit

atexit（设置程序正常结束前调用的函数）

execl

execl（执行文件）

相关函数：fork，execle，execlp，execv，execve，execvp

表头文件：#include <unistd.h>

定义函数：int execl(const char *path, const char *arg, ...);

函数说明：execl()用来执行参数path字符串所代表的文件路径，接下来的参数代表执行该文件时传递过去的argv(0)、argv[1]...，最后一个参数必须用空指针(NULL)作结束。

返回值：如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。

范例：

#include <unistd.h>
main()
{
    execl("/bin/ls", "ls", "-al", "/etc/passwd", (char *)0);
}

执行： /*

执行/bin/ls

-al

/etc/passwd

-rw-r--r--

root

705

Sep

13:52

/etc/passwd

execlp

execlp（从PATH环境变量中查找文件并执行）

相关函数：fork，execl，execle，execv，execve，execvp

表头文件：#include <unistd.h>

定义函数：int execlp(const char *file, const char *arg, ...);

函数说明：execlp()会从PATH环境变量所指的目录中查找符合参数file的文件名，找到后便执行该文件，然后将第二个以后的参数当做该文件的argv[0]、argv[1]...，最后一个参数必须用空指针(NULL)作结束。

返回值：如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。

错误代码：参考execve()。

范例：

/* 执行ls -al /etc/passwd execlp()会依PATH变量中的/bin找到/bin/ls */
#include <unistd.h>
main()
{
    execlp("ls", "ls", "-al", "/etc/passwd", (char *)0);
}

执行： -rw-r--r-- 1 root root 705 Sep 3 13:52 /etc/passwd

execv

execv（执行文件）

相关函数：fork，execl，execle，execlp，execve，execvp

表头文件：#include <unistd.h>

定义函数：int execv(const char *path, char *const argv[]);

函数说明：execv()用来执行参数path字符串所代表的文件路径，与execl()不同的地方在于execve()只需两个参数，第二个参数利用数组指针来传递给执行文件。

返回值：如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。

错误代码：请参考execve()。

范例：

/* 执行/bin/ls -al /etc/passwd */
#include <unistd.h>
main()
{
    char *argv[] =
    {
        "ls", "-al", "/etc/passwd", (char *)0
} ; execv("/bin/ls", argv);
}

执行： -rw-r--r-- 1 root root 705 Sep 3 13:52 /etc/passwd

execve

execve（执行文件）

相关函数：fork，execl，execle，execlp，execv，execvp

表头文件：#include <unistd.h>

定义函数：int execve(const char *filename, char *const argv[], char *const envp[]);

函数说明：execve()用来执行参数filename字符串所代表的文件路径，第二个参数系利用数组指针来传递给执行文件，最后一个参数则为传递给执行文件的新环境变量数组。

返回值：如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。

错误代码：EACCES: 欲执行的文件不具有用户可执行的权限。

范例：

#include <unistd.h>
main()
{
    char *argv[] =
    {
        "ls", "-al", "/etc/passwd", (char *)0
    };
    char *envp[] =
    {
        "PATH=/bin", 0
    };
    execve("/bin/ls", argv, envp);
}

执行： -rw-r--r-- 1 root root 705 Sep 3 13:52 /etc/passwd

execvp

execvp（执行文件）

相关函数：fork，execl，execle，execlp，execv，execve

表头文件：#include <unistd.h>

定义函数：int execvp(const char *file, char *const argv[]);

函数说明：execvp()会从PATH环境变量所指的目录中查找符合参数file的文件名，找到后便执行该文件，然后将第二个参数argv传给该欲执行的文件。

返回值：如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。

错误代码：请参考execve()。

范例：

/* 请与execlp()范例对照 */
#include <unistd.h>
main()
{
    char *argv[] =
    {
        "ls", "-al", "/etc/passwd", 0
    };
    execvp("ls", argv);
}

执行： -rw-r--r-- 1 root root 705 Sep 3 13:52 /etc/passwd

exit

exit（正常结束进程）

_exit

_exit（结束进程执行）

vfork

vfork（建立一个新的进程）

getpgid

getpgid（取得进程组识别码）

相关函数：setpgid，setpgrp，getpgrp

表头文件：#include <unistd.h>

定义函数：pid_t getpgid(pid_t pid);

函数说明：getpgid()用来取得参数pid指定进程所属的组识别码。如果参数pid为0，则会取得目前进程的组识别码。

返回值：执行成功则返回组识别码，如果有错误则返回-1，错误原因存于errno中。

错误代码：ESRCH 找不到符合参数pid指定的进程。

范例：

/* 取得init进程(pid=1)的组识别码 */
#include <unistd.h>
main()
{
    printf("init gid = %d\n", getpgid(1));
}

执行： init gid = 0

getpgrp

getpgrp（取得进程组识别码）

相关函数：setpgid，getpgid，getpgrp

表头文件：#include <unistd.h>

定义函数：pid_t getpgrp(void);

函数说明：getpgrp()用来取得目前进程所属的组识别码。此函数相当于调用getpgid(0)。

返回值：返回目前进程所属的组识别码。

范例：

#include <unistd.h>
main()
{
    printf("my gid =%d\n", getpgrp());
}

执行： my gid =29546

getpid

getpid（取得进程识别码）

getppid

getppid（取得父进程的进程识别码）

getpriority

getpriority（取得程序进程执行优先权）

nice

nice（改变进程优先顺序）

相关函数：setpriority，getpriority

表头文件：#include <unistd.h>

定义函数：int nice(int inc);

函数说明：nice()用来改变进程的进程执行优先顺序。参数inc数值越大则优先顺序排在越后面，即表示进程执行会越慢。只有超级用户才能使用负的inc值，代表优先顺序排在前面，进程执行会较快。

返回值：如果执行成功则返回0，否则返回-1，失败原因存于errno中。

错误代码：EPERM 一般用户企图转用负的参数inc值改变进程优先顺序。

on_exit

on_exit（设置程序正常结束前调用的函数）

setpgid

setpgid（设置进程组识别码）

相关函数：getpgid，setpgrp，getpgrp

表头文件：#include <unistd.h>

定义函数：int setpgid(pid_t pid, pid_t pgid);

函数说明：setpgid()将参数pid指定进程所属的组识别码设为参数pgid指定的组识别码。如果参数pid为0，则会用来设置目前进程的组识别码，如果参数pgid为0，则会以目前进程的进程识别码来取代。

返回值：执行成功则返回组识别码，如果有错误则返回-1，错误原因存于errno中。

错误代码：EINVAL 参数pgid小于0。 EPERM 进程权限不足，无法完成调用。 ESRCH 找不到符合参数pid指定的进程

setpgrp

setpgrp（设置进程组识别码）

相关函数：getpgid，setpgid，getpgrp

表头文件：#include <unistd.h>

定义函数：int setpgrp(void);

函数说明：setpgrp()将目前进程所属的组识别码设为目前进程的进程识别码。此函数相当于调用setpgid(0,0)。

返回值：执行成功则返回组识别码，如果有错误则返回-1，错误原因存于errno中。

setpriority

setpriority（设置程序进程执行优先权）

system

system（执行shell命令）

相关函数：fork，execve，waitpid，popen

表头文件：#include <stdlib.h>

定义函数：int system(const char *string);

函数说明：system()会调用fork()产生子进程，由子进程来调用/bin/sh -c string来执行参数string字符串所代表的命令，此命令执行完后随即返回原调用的进程。在调用system()期间SIGCHLD信号会被暂时搁置，SIGINT和SIGQUIT信号则会被忽略。

返回值：如果system()在调用/bin/sh时失败则返回127，其他失败原因返回-1。若参数string为空指针(NULL)，则返回非零值。如果system()调用成功则最后会返回执行shell命令后的返回值，但是此返回值也有可能为system()调用/bin/sh失败所返回的127，因此最好能再检查errno来确认执行成功。

附加说明：在编写具有SUID/SGID权限的程序时请勿使用system()，system()会继承环境变量，通过环境变量可能会造成系统安全的问题。

范例：

#include <stdlib.h>
main()
{
    system("ls -al /etc/passwd /etc/shadow");
}

执行： -rw-r--r-- 1 root root 705 Sep 3 13:52 /etc/passwd

-r--------- 1 root root 572 Sep 2 15:34 /etc/shadow

wait

wait（等待子进程中端或结束）

waitpid

waitpid（等待子进程中端或结束）

fprintf

fprintf（格式化输出数据至文件）

相关函数：printf，fscanf，vfprintf

表头文件：#include <stdio.h>

定义函数：int fprintf(FILE *stream, const char *format, ...);

函数说明：fprintf()会根据参数format字符串来转换并格式化数据，然后将结果输出到参数stream指定的文件中，直到出现字符串结束('\0')为止。关于参数format字符串的格式请参考printf()。

返回值：成功则返回实际输出的字符数，失败则返回-1，错误原因存于errno中。

范例：

#include <stdio.h>
main()
{
    int i = 150;
    int j = -100;
    double k = 3.14159;
    fprintf(stdout, "%d %f %x\n", j, k, i);
    fprintf(stdout, "%2d %*d\n", i, 2, i);
}

执行： -100 3.141590 96 150 150

fscanf

fscanf（格式化字符串输入）

printf

printf（格式化输出数据）

sacnf

sacnf（格式化字符串输入）

sprintf

sprintf（格式化字符串复制）

sscanf

TODO

vfprintf

TODO

vfscanf

vfscanf（格式化字符串输入）

vprintf

vprintf（格式化输出数据）

相关函数：printf，vfprintf，vsprintf

表头文件：#include <stdio.h> #include <stdarg.h>

定义函数：int vprintf(const char *format, va_list ap);

函数说明：vprintf()作用和printf()相同，参数format格式也相同。va_list为不定个数的参数列，用法及范例请参考附录C。

返回值：成功则返回实际输出的字符数，失败则返回-1，错误原因存于errno中。

范例：

#include <stdio.h>
#include <stdarg.h>
int my_printf(const char *format, ...)
{
    va_list ap;
    int retval;
    va_start(ap, format);
    printf("my_printf():");
    retval = vprintf(format, ap);
    va_end(ap);
    return retval;
}
main()
{
    int i = 150, j = -100;
    double k = 3.14159;
    my_printf("%d %f %x\n", j, k, i);
    my_printf("%2d %*d\n", i, 2, i);
}

执行： my_printf(): -100 3.14159

96my_printf(): 150 150

vscanf

vprintf（格式化输出数据）

相关函数：printf，vfprintf，vsprintf

表头文件：#include <stdio.h> #include <stdarg.h>

定义函数：int vprintf(const char *format, va_list ap);

函数说明：vprintf()作用和printf()相同，参数format格式也相同。va_list为不定个数的参数列，用法及范例请参考附录C。

返回值：成功则返回实际输出的字符数，失败则返回-1，错误原因存于errno中。

范例：

#include <stdio.h>
#include <stdarg.h>
int my_printf(const char *format, ...)
{
    va_list ap;
    int retval;
    va_start(ap, format);
    printf("my_printf():");
    retval = vprintf(format, ap);
    va_end(ap);
    return retval;
}
main()
{
    int i = 150, j = -100;
    double k = 3.14159;
    my_printf("%d %f %x\n", j, k, i);
    my_printf("%2d %*d\n", i, 2, i);
}

执行： my_printf(): -100 3.14159

96my_printf(): 150 150

vsprintf

vsprintf（格式化字符串复制）

相关函数：vnsprintf，vprintf，snprintf

表头文件：#include <stdio.h>

定义函数：int vsprintf(char *str, const char *format, va_list ap);

函数说明：vsprintf()会根据参数format字符串来转换并格式化数据，然后将结果复制到参数str所指的字符串数组，直到出现字符串结束('\0')为止。关于参数format字符串的格式请参考printf()。va_list用法请参考附录C或vprintf()范例。

返回值：成功则返回参数str字符串长度，失败则返回-1，错误原因存于errno中。

范例：请参考vprintf()及vsprintf()。

vsscanf

vsscanf（格式化字符串输入）

文件权限控制篇 12

TODO

access

access（判断是否具有存取文件的权限）

相关函数：stat，open，chmod，chown，setuid，setgid

表头文件：#include <unistd.h>

定义函数：int access(const char *pathname, int mode);

函数说明：access()会检查是否可以读/写某一已存在的文件。参数mode有几种情况组合，R_OK，W_OK，X_OK和F_OK。R_OK，W_OK与X_OK用来检查文件是否具有读取、写入和执行的权限。F_OK则是用来判断该文件是否存在。由于access()只作权限的核查，并不理会文件形态或文件内容，因此，如果一目r录表示为"可写入"，表示可以在该目录中建立新文件等操作，而非意味此目录可以被当做文件处理。例如，你会发现DOS的文件都具有"可执行"权限，但用execve()执行时则会失败。

返回值：若所有欲查核的权限都通过了检查则返回0值，表示成功，只要有一权限被禁止则返回-1。

错误代码：EACCESS 参数pathname 所指定的文件不符合所要求测试的权限。 EROFS 欲测试写入权限的文件存在于只读文件系统内。 EFAULT 参数pathname指针超出可存取内存空间。 EINVAL 参数mode 不正确。 ENAMETOOLONG 参数pathname太长。 ENOTDIR 参数pathname为一日录。 ENOMEM 核心内存不足 ELOOP 参数pathname有过多符号连接问题。 EIO I/O 存取错误。

附加说明：使用access()作用户认证方面的判断要特别小心，例如在access()后再做open()的空文件可能会造成系统安全上的问题。

范例：

/* 判断是否允许读取/etc/passwd */
#include <unistd.h>
int main()
{
    if (access("/etc/passwd", R_OK)
        == 0) printf("/etc/passwd can be read\n");
}

执行： /etc/passwd can be read

alphasort

alphasort（依字母顺序排序目录结构）

chdir

chdir（改变当前的工作目录）

chmod

chmod（改变文件的权限）

相关函数：fchmod，stat，open，chown

表头文件：#include <sys/types.h> #include <sys/stat.h>

定义函数：int chmod(const char *path, mode_t mode);

函数说明：chmod()会依参数mode权限来更改参数path指定文件的权限。参数 mode有下列数种组合 S_ISUID 04000 文件的（set user-id on execution）位 S_ISGID 02000 文件的（set group-id on execution）位 S_ISVTX 01000 文件的sticky位 S_IRUSR（S_IREAD） 00400 文件所有者具可读取权限 S_IWUSR（S_IWRITE）00200 文件所有者具可写入权限 S_IXUSR（S_IEXEC） 00100 文件所有者具可执行权限 S_IRGRP 00040 用户组具可读取权限 S_IWGRP 00020 用户组具可写入权限 S_IXGRP 00010 用户组具可执行权限 S_IROTH 00004 其他用户具可读取权限 S_IWOTH 00002 其他用户具可写入权限 S_IXOTH 00001 其他用户具可执行权限只有该文件的所有者或有效用户识别码为0，才可以修改该文件权限。基于系统安全，如果欲将数据写入一执行文件，而该执行文件具有S_ISUID或S_ISGID权限，则这两个位会被清除。如果一目r录具有S_ISUID位权限，表示在此目录下只有该文件的所有者或root可以删除该文件。

返回值：权限改变成功返回0，失败返回-1，错误原因存于errno。

错误代码：EPERM 进程的有效用户识别码与欲修改权限的文件拥有者不同，而且也不具root权限。 EACCESS 参数path所指定的文件无法存取。 EROFS 欲写入权限的文件存在于只读文件系统内。 EFAULT 参数path指针超出可存取内存空间。 EINVAL 参数mode不正确 ENAMETOOLONG 参数path太长 ENOENT 指定的文件不存在 ENOTDIR 参数path路径并非一目r录 ENOMEM 核心内存不足 ELOOP 参数path有过多符号连接问题。 EIO I/O 存取错误

范例：

/* 将/etc/passwd 文件权限设成S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH */
#include <sys/types.h>
#include <sys/stat.h>
main()
{
    chmod("/etc/passwd", S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
}

chown

chown（改变文件的所有者）

chroot

chroot（改变根目录）

closedir

closedir（关闭目录）

fchdir

fchdir（改变当前的工作目录）

fchmod

fchmod（改变文件的权限）

相关函数：chmod，stat，open，chown

表头文件：#include <sys/types.h> #include <sys/stat.h>

定义函数：int fchmod(int fildes, mode_t mode);

函数说明：fchmod()会依参数mode权限来更改参数fildes所指文件的权限。参数fildes为已打开文件的文件描述词。参数mode请参考chmod()。

返回值：权限改变成功则返回0，失败返回-1，错误原因存于errno。错误原因 EBADF 参数fildes为无效的文件描述词。 EPERM 进程的有效用户识别码与欲修改权限的文件所有者不同，而且也不具root权限。 EROFS 欲写入权限的文件存在于只读文件系统内。 EIO I/O 存取错误。

范例：

#include <sys/stat.h>
#include <fcntl.h>
main()
{
    int fd;
    fd = open("/etc/passwd", O_RDONLY);
    fchmod(fd, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
    close(fd);
}

fchown

fchown（改变文件的所有者）

fstat

fstat（由文件描述词取得文件状态）

相关函数：stat，lstat，chmod，chown，readlink，utime

表头文件：#include <sys/stat.h> #include <unistd.h>

定义函数：int fstat(int fildes, struct stat *buf);

函数说明：fstat()用来将参数fildes所指的文件状态，复制到参数buf所指的结构中(struct stat)。Fstat()与stat()作用完全相同，不同处在传入的参数为已打开的文件描述词。详细内容请参考stat()。

返回值：执行成功则返回0，失败返回-1，错误代码存于errno。

范例：

#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
main()
{
    struct stat buf;
    int fd;
    fd = open("/etc/passwd", O_RDONLY);
    fstat(fd, &buf);
    printf("/etc/passwd file size +%d\n ", buf.st_size);
}

执行： /etc/passwd file size = 705

ftruncate

ftruncate（改变文件大小）

getcwd

getcwd（取得当前的工作目录）

相关函数：get_current_dir_name，getwd，chdir

表头文件：#include <unistd.h>

定义函数：char *getcwd(char *buf, size_t size);

函数说明：getcwd()会将当前的工作目录绝对路径复制到参数buf所指的内存空间，参数size为buf的空间大小。在调用此函数时，buf所指的内存空间要足够大，若工作目录绝对路径的字符串长度超过参数size大小，则回值NULL，errno的值则为ERANGE。倘若参数buf为NULL，getcwd()会依参数size的大小自动配置内存(使用malloc())，如果参数size也为0，则getcwd()会依工作目录绝对路径的字符串程度来决定所配置的内存大小，进程可以在使用完此字符串后利用free()来释放此空间。

返回值：执行成功则将结果复制到参数buf所指的内存空间，或是返回自动配置的字符串指针。失败返回NULL，错误代码存于errno。

范例：

#include <unistd.h>
main()
{
    char buf[80];
    getcwd(buf, sizeof(buf));
    printf("current working directory : %s\n", buf);
}

执行： current working directory :/tmp

link

link（建立文件连接）

lstat

lstat（由文件描述词取得文件状态）

相关函数：stat，fstat，chmod，chown，readlink，utime

表头文件：#include <sys/stat.h> #include <unistd.h>

定义函数：int lstat(const char *file_name, struct stat *buf);

函数说明：lstat()与stat()作用完全相同，都是取得参数file_name所指的文件状态，其差别在于，当文件为符号连接时，lstat()会返回该link本身的状态。详细内容请参考stat()。

返回值：执行成功则返回0，失败返回-1，错误代码存于errno。

范例：参考stat()。

opendir

opendir（打开目录）

相关函数：open，readdir，closedir，rewinddir，seekdir，telldir，scandir

表头文件：#include <sys/types.h> #include <dirent.h>

定义函数：DIR *opendir(const char *name);

函数说明：opendir()用来打开参数name指定的目录，并返回DIR*形态的目录流，和open()类似，接下来对目录的读取和搜索都要使用此返回值。

返回值：成功则返回DIR*型态的目录流，打开失败则返回NULL。

错误代码：EACCESS 权限不足 EMFILE 已达到进程可同时打开的文件数上限。 ENFILE 已达到系统可同时打开的文件数上限。 ENOTDIR 参数name非真正的目录 ENOENT 参数name指定的目录不存在，或是参数name为一空字符串。 ENOMEM 核心内存不足。

readdir

readdir（读取目录）

相关函数：open，opendir，closedir，rewinddir，seekdir，telldir，scandir

表头文件：#include <sys/types.h> #include <dirent.h>

定义函数：struct dirent *readdir(DIR *dir);

函数说明：readdir()返回参数dir目录流的下个目录进入点。结构dirent定义如下 struct dirent { ino_t d_ino; ff_t d_off; signed short int d_reclen; unsigned char d_type; har d_name[256; }; d_ino 此目录进入点的inode d_off 目录文件开头至此目录进入点的位移 d_reclen _name的长度，不包含NULL字符 d_type d_name所指的文件类型 d_name 文件名

返回值：成功则返回下个目录进入点。有错误发生或读取到目录文件尾则返回NULL。

附加说明：EBADF参数dir为无效的目录流。

范例：

#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
main()
{
    DIR *dir;
    struct dirent *ptr;
    int i;
    dir = opendir("/etc/rc.d");
    while ((ptr = readdir(dir)) != NULL)
    {
        printf("d_name: %s\n", ptr->d_name);
    }
closedir(dir);
}

执行： d_name:.

d_name:..

d_name:init.d

d_name:rc0.d

d_name:rc1.d

d_name:rc2.d

d_name:rc3.d

d_name:rc4.d

d_name:rc5.d

d_name:rc6.d

d_name:rc

d_name:rc.local

d_name:rc.sysinit

readlink

readlink（取得符号连接所指的文件）

remove

remove（删除文件）

rename

rename（更改文件名称或位置）

rewinddir

rewinddir（重设读取目录的位置为开头位置）

相关函数：open，opendir，closedir，telldir，seekdir，readdir，scandir

表头文件：#include <sys/types.h> #include <dirent.h>

定义函数：void rewinddir(DIR *dir);

函数说明：rewinddir()用来设置参数dir目录流目前的读取位置为原来开头的读取位置。

返回值：

错误代码：EBADF dir为无效的目录流

范例：

#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
main()
{
    DIR *dir;
    struct dirent *ptr;
    dir = opendir("/etc/rc.d");
    while ((ptr = readdir(dir)) != NULL)
    {
        printf("d_name :%s\n", ptr->d_name);
    }
rewinddir(dir);
printf("readdir again!\n");
while ((ptr = readdir(dir)) != NULL)
{
    printf("d_name: %s\n", ptr->d_name);
}
closedir(dir);
}

执行： d_name:.

d_name:..

d_name:init.d

d_name:rc0.d

d_name:rc1.d

d_name:rc2.d

d_name:rc3.d

d_name:rc4.d

d_name:rc5.d

d_name:rc6.d

d_name:rc

d_name:rc.local

d_name:rc.sysinit readdir again!

d_name:.

d_name:..

d_name:init.d

d_name:rc0.d

d_name:rc1.d

d_name:rc2.d

d_name:rc3.d

d_name:rc4.d

d_name:rc5.d

d_name:rc6.d

d_name:rc

d_name:rc.local

d_name:rc.sysinit

seekdir

seekdir（设置下回读取目录的位置）

相关函数：open，opendir，closedir，rewinddir，telldir，readdir，scandir

表头文件：#include <dirent.h>

定义函数：void seekdir(DIR *dir, off_t offset);

函数说明：seekdir()用来设置参数dir目录流目前的读取位置，在调用readdir()时便从此新位置开始读取。参数offset代表距离目录文件开头的偏移量。

返回值：

错误代码：EBADF 参数dir为无效的目录流

范例：

#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
main()
{
    DIR *dir;
    struct dirent *ptr;
    int offset, offset_5, i = 0;
    dir = opendir("/etc/rc.d");
    while ((ptr = readdir(dir)) != NULL)
    {
        offset = telldir(dir);
        if (++i == 5)
            offset_5 = offset;
        printf("d_name :%s offset :%d\n", ptr->d_name, offset);
    }
seekdir(dir, offset_5);
printf("Readdir again!\n");
while ((ptr = readdir(dir)) != NULL)
{
    offset = telldir(dir);
    printf("d_name :%s offset :%d\n", ptr->d_name, offset);
}
closedir(dir);
}

执行： d_name : . offset :12 d_name : ..

t:24 d_name : init.d offset 40 d_name : rc0.d offset :56 d_name :rc1.d offset :72

d_name:rc2.d offset :88

d_name:rc3.d offset 104

d_name:rc4.d offset:120

d_name:rc5.d offset:136

d_name:rc6.d offset:152

d_name:rc offset 164

d_name:rc.local offset :180

d_name:rc.sysinit offset :4096 readdir again!

d_name:rc2.d offset :88

d_name:rc3.d offset 104

d_name:rc4.d offset:120

d_name:rc5.d offset:136

d_name:rc6.d offset:152

d_name:rc offset 164

d_name:rc.local offset :180

d_name:rc.sysinit offset :4096

stat

stat（取得文件状态）

相关函数：fstat，lstat，chmod，chown，readlink，utime

表头文件：#include <sys/stat.h> #include <unistd.h>

定义函数：int stat(const char *file_name, struct stat *buf);

函数说明：stat()用来将参数file_name所指的文件状态，复制到参数buf所指的结构中。下面是struct stat内各参数的说明 struct stat { dev_t st_dev; /* device / ino_t st_ino; / inode / mode_t st_mode; / protection / nlink_t st_nlink; / number of hard links / uid_t st_uid; / user ID of owner / gid_t st_gid; / group ID of owner / dev_t st_rdev; / device type / off_t st_size; / total size, in bytes / unsigned long st_blksize; / blocksize for filesystem I/O / unsigned long st_blocks; / number of blocks allocated / time_t st_atime; / time of last access / time_t st_mtime; / time of last modification / time_t st_ctime; / time of last change */ }; st_dev 文件的设备编号 st_ino 文件的i-node st_mode 文件的类型和存取的权限 st_nlink 连到该文件的硬连接数目，刚建立的文件值为1。 st_uid 文件所有者的用户识别码 st_gid 文件所有者的组识别码 st_rdev 若此文件为装置设备文件，则为其设备编号 st_size 文件大小，以字节计算 st_blksize 文件系统的I/O 缓冲区大小。 st_blcoks 占用文件区块的个数，每一区块大小为512个字节。 st_atime 文件最近一次被存取或被执行的时间，一般只有在用mknod、utime、read、write与tructate时改变。 st_mtime 文件最后一次被修改的时间，一般只有在用mknod、utime和write时才会改变 st_ctime i-node最近一次被更改的时间，此参数会在文件所有者、组、权限被更改时更新先前所描述的st_mode则定义了下列数种情况 S_IFMT 0170000 文件类型的位遮罩 S_IFSOCK 0140000 scoket S_IFLNK 0120000 符号连接 S_IFREG 0100000 一般文件 S_IFBLK 0060000 区块装置 S_IFDIR 0040000 目录 S_IFCHR 0020000 字符装置 S_IFIFO 0010000 先进先出 S_ISUID 04000 文件的（set user-id on execution）位 S_ISGID 02000 文件的（set group-id on execution）位 S_ISVTX 01000 文件的sticky位 S_IRUSR（S_IREAD） 00400 文件所有者具可读取权限 S_IWUSR（S_IWRITE）00200 文件所有者具可写入权限 S_IXUSR（S_IEXEC） 00100 文件所有者具可执行权限 S_IRGRP 00040 用户组具可读取权限 S_IWGRP 00020 用户组具可写入权限 S_IXGRP 00010 用户组具可执行权限 S_IROTH 00004 其他用户具可读取权限 S_IWOTH 00002 其他用户具可写入权限 S_IXOTH 00001 其他用户具可执行权限上述的文件类型在POSIX中定义了检查这些类型的宏定义 S_ISLNK(st_mode) 判断是否为符号连接 S_ISREG(st_mode) 是否为一般文件 S_ISDIR(st_mode) 是否为目录 S_ISCHR(st_mode) 是否为字符装置文件 S_ISBLK(st_mode) 是否为区块装置 S_ISFIFO(st_mode) 是否为先进先出 S_ISSOCK(st_mode) 是否为socket 若一目r录具有sticky位（S_ISVTX），则表示在此目录下的文件只能被该文件所有者、此目录所有者或root来删除或改名。

返回值：执行成功则返回0，失败返回-1，错误代码存于errno

错误代码：ENOENT 参数file_name指定的文件不存在 ENOTDIR 路径中的目录存在但却非真正的目录 ELOOP 欲打开的文件有过多符号连接问题，上限为16符号连接 EFAULT 参数buf为无效指针，指向无法存在的内存空间 EACCESS 存取文件时被拒绝 ENOMEM 核心内存不足 ENAMETOOLONG 参数file_name的路径名称太长

范例：

#include <sys/stat.h>
#include <unistd.h>
main()
{
    struct stat buf;
    stat("/etc/passwd", &buf);
    printf("/etc/passwd file size = %d\n", buf.st_size);
}

执行： /etc/passwd file size = 705

symlink

symlink（建立文件符号连接）

telldir

telldir（取得目录流的读取位置）

相关函数：open，opendir，closedir，rewinddir，seekdir，readdir，scandir

表头文件：#include <dirent.h>

定义函数：off_t telldir(DIR *dir);

函数说明：telldir()返回参数dir目录流目前的读取位置。此返回值代表距离目录文件开头的偏移量返回值返回下个读取位置，有错误发生时返回-1。

错误代码：EBADF参数dir为无效的目录流。

范例：

#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
main()
{
    DIR *dir;
    struct dirent *ptr;
    int offset;
    dir = opendir("/etc/rc.d");
    while ((ptr = readdir(dir)) != NULL)
    {
        offset = telldir(dir);
        printf("d_name : %s offset :%d\n", ptr->d_name, offset);
    }
closedir(dir);
}

执行： d_name : . offset :12 d_name : ..

t:24 d_name : init.d offset 40 d_name : rc0.d offset :56 d_name :rc1.d offset :72

d_name:rc2.d offset :88

d_name:rc3.d offset 104

d_name:rc4.d offset:120

d_name:rc5.d offset:136

d_name:rc6.d offset:152

d_name:rc offset 164

d_name:rc.local offset :180

d_name:rc.sysinit offset :4096

truncate

truncate（改变文件大小）

umask

umask（设置建立新文件时的权限遮罩）

unlink

unlink（删除文件）

utime

utime（修改文件的存取时间和更改时间）

utimes

utimes（修改文件的存取时间和更改时间）

信号处理篇 13

TODO

alarm

alarm（设置信号传送闹钟）

kill

kill（传送信号给指定的进程）

pause

pause（让进程暂停直到信号出现）

sigaction

sigaction（查询或设置信号处理方式）

相关函数：signal，sigprocmask，sigpending，sigsuspend

表头文件：#include <signal.h>

定义函数：int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

函数说明：sigaction()会依参数signum指定的信号编号来设置该信号的处理函数。参数signum可以指定SIGKILL和SIGSTOP以外的所有信号。如参数结构sigaction定义如下 struct sigaction { void (*sa_handler)(int); sigset_t sa_mask; int sa_flags; void (*sa_restorer)(void); } sa_handler此参数和signal()的参数handler相同，代表新的信号处理函数，其他意义请参考signal()。 sa_mask用来设置在处理该信号时暂时将sa_mask指定的信号搁置。 sa_restorer此参数没有使用。 sa_flags用来设置信号处理的其他相关操作，下列的数值可用。 OR运算（|）组合 A_NOCLDSTOP : 如果参数signum为SIGCHLD，则当子进程暂停时并不会通知父进程 SA_ONESHOT/SA_RESETHAND:当调用新的信号处理函数前，将此信号处理方式改为系统预设的方式。 SA_RESTART:被信号中断的系统调用会自行重启 SA_NOMASK/SA_NODEFER:在处理此信号未结束前不理会此信号的再次到来。如果参数oldact不是NULL指针，则原来的信号处理方式会由此结构sigaction返回。

返回值：执行成功则返回0，如果有错误则返回-1。

错误代码：EINVAL 参数signum不合法，或是企图拦截SIGKILL/SIGSTOPSIGKILL信号 EFAULT 参数act，oldact指针地址无法存取。 EINTR 此调用被中断

范例：

#include <unistd.h>
#include <signal.h>
void show_handler(struct sigaction *act)
{
    switch (act->sa_flags)
    {
        case SIG_DFL:
            printf("Default action\n");
            break;
        case SIG_IGN:
            printf("Ignore the signal\n");
            break;
        default:
            printf("0x%x\n", act->sa_handler);
    }
}
main()
{
    int i;
    struct sigaction act, oldact;
    act.sa_handler = show_handler;
    act.sa_flags = SA_ONESHOT|SA_NOMASK;
    sigaction(SIGUSR1, &act, &oldact);
    for (i = 5; i < 15; i++)
    {
        printf("sa_handler of signal %2d =", i);
        sigaction(i, NULL, &oldact);
    }
}

执行： sa_handler of signal 5 = Default action

sa_handler of signal 6 = Default action

sa_handler of signal 7 = Default action

sa_handler of signal 8 = Default action

sa_handler of signal 9 = Default action

sa_handler of signal 10 = 0x8048400

sa_handler of signal 11 = Default action

sa_handler of signal 12 = Default action

sa_handler of signal 13 = Default action

sa_handler of signal 14 = Default action

sigaddset

sigaddset（增加一个信号至信号集）

相关函数：sigemptyset，sigfillset，sigdelset，sigismember

表头文件：#include <signal.h>

定义函数：int sigaddset(sigset_t *set, int signum);

函数说明：sigaddset()用来将参数signum代表的信号加入至参数set信号集里。

返回值：执行成功则返回0，如果有错误则返回-1。

错误代码：EFAULT 参数set指针地址无法存取 EINVAL 参数signum非合法的信号编号

sigdelset

sigdelset（从信号集里删除一个信号）

相关函数：sigemptyset，sigfillset，sigaddset，sigismember

表头文件：#include <signal.h>

定义函数：int sigdelset(sigset_t *set, int signum);

函数说明：sigdelset()用来将参数signum代表的信号从参数set信号集里删除。

返回值：执行成功则返回0，如果有错误则返回-1。

错误代码：EFAULT 参数set指针地址无法存取 EINVAL 参数signum非合法的信号编号

sigemptyset

sigemptyset（初始化信号集）

相关函数：sigaddset，sigfillset，sigdelset，sigismember

表头文件：#include <signal.h>

定义函数：int sigemptyset(sigset_t *set);

函数说明：sigemptyset()用来将参数set信号集初始化并清空。

返回值：执行成功则返回0，如果有错误则返回-1。

错误代码：EFAULT 参数set指针地址无法存取

sigfillset

sigfillset（将所有信号加入至信号集）

相关函数：sigempty，sigaddset，sigdelset，sigismember

表头文件：#include <signal.h>

定义函数：int sigfillset(sigset_t *set);

函数说明：sigfillset()用来将参数set信号集初始化，然后把所有的信号加入到此信号集里。

返回值：执行成功则返回0，如果有错误则返回-1。

附加说明：EFAULT 参数set指针地址无法存取

sigismember

sigismember（测试某个信号是否已加入至信号集里）

相关函数：sigemptyset，sigfillset，sigaddset，sigdelset

表头文件：#include <signal.h>

定义函数：int sigismember(const sigset_t *set, int signum);

函数说明：sigismember()用来测试参数signum代表的信号是否已加入至参数set信号集里。如果信号集里已有该信号则返回1，否则返回0。

返回值：信号集已有该信号则返回1，没有则返回0。如果有错误则返回-1。

错误代码：EFAULT 参数set指针地址无法存取 EINVAL 参数signum非合法的信号编号

signal

signal（设置信号处理方式）

sigpending

sigpending（查询被搁置的信号）

相关函数：signal，sigaction，sigprocmask，sigsuspend

表头文件：#include <signal.h>

定义函数：int sigpending(sigset_t *set);

函数说明：sigpending()会将被搁置的信号集合由参数set指针返回。

返回值：执行成功则返回0，如果有错误则返回-1。

错误代码：EFAULT 参数set指针地址无法存取 EINTR 此调用被中断。

sigprocmask

sigprocmask（查询或设置信号遮罩）

相关函数：signal，sigaction，sigpending，sigsuspend

表头文件：#include <signal.h>

定义函数：int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

函数说明：sigprocmask()可以用来改变目前的信号遮罩，其操作依参数how来决定 SIG_BLOCK 新的信号遮罩由目前的信号遮罩和参数set指定的信号遮罩作联集 SIG_UNBLOCK 将目前的信号遮罩删除掉参数set指定的信号遮罩 SIG_SETMASK 将目前的信号遮罩设成参数set指定的信号遮罩。如果参数oldset不是NULL指针，那么目前的信号遮罩会由此指针返回。

返回值：执行成功则返回0，如果有错误则返回-1。

错误代码：EFAULT 参数set，oldset指针地址无法存取。 EINTR 此调用被中断

sleep

sleep（让进程暂停执行一段时间）

ferror

ferror（检查文件流是否有错误发生）

perror

perror（打印出错误原因信息字符串）

strerror

strerror（返回错误原因的描述字符串）

mkfifo

mkfifo（建立具名管道）

相关函数：pipe，popen，open，umask

表头文件：#include <sys/types.h> #include <sys/stat.h>

定义函数：int mkfifo(const char *pathname, mode_t mode);

函数说明：mkfifo()会依参数pathname建立特殊的FIFO文件，该文件必须不存在，而参数mode为该文件的权限（mode%~umask），因此umask值也会影响到FIFO文件的权限。Mkfifo()建立的FIFO文件其他进程都可以用读写一般文件的方式存取。当使用open()来打开FIFO文件时，O_NONBLOCK旗标会有影响 1、当使用O_NONBLOCK旗标时，打开FIFO文件来读取的操作会立刻返回，但是若还没有其他进程打开FIFO文件来读取，则写入的操作会返回ENXIO错误代码。 2、没有使用O_NONBLOCK旗标时，打开FIFO来读取的操作会等到其他进程打开FIFO文件来写入才正常返回。同样地，打开FIFO文件来写入的操作会等到其他进程打开FIFO文件来读取后才正常返回。

返回值：若成功则返回0，否则返回-1，错误原因存于errno中。

错误代码：EACCESS 参数pathname所指定的目录路径无可执行的权限 EEXIST 参数pathname所指定的文件已存在。 ENAMETOOLONG 参数pathname的路径名称太长。 ENOENT 参数pathname包含的目录不存在 ENOSPC 文件系统的剩余空间不足 ENOTDIR 参数pathname路径中的目录存在但却非真正的目录。 EROFS 参数pathname指定的文件存在于只读文件系统内。

范例：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
    char buffer[80];
    int fd;
    unlink(FIFO);
    mkfifo(FIFO, 0666);
    if (fork() > 0)
    {
        char s[] = "hello!\n";
        fd = open(FIFO, O_WRONLY);
        write(fd, s, sizeof(s));
        close(fd);
    }
else
{
    fd = open(FIFO, O_RDONLY);
    read(fd, buffer, 80);
    printf("%s", buffer);
    close(fd);
}
}

执行： hello!

pclose

pclose（关闭管道I/O）

pipe

pipe（建立管道）

相关函数：mkfifo，popen，read，write，fork

表头文件：#include <unistd.h>

定义函数：int pipe(int filedes[2]);

函数说明：pipe()会建立管道，并将文件描述词由参数filedes数组返回。filedes[0]为管道里的读取端，filedes[1]则为管道的写入端。

返回值：若成功则返回零，否则返回-1，错误原因存于errno中。

错误代码：EMFILE 进程已用完文件描述词最大量。 ENFILE 系统已无文件描述词可用。 EFAULT 参数filedes数组地址不合法。

范例：

/* 父进程借管道将字符串"hello!\n"传给子进程并显示 */
#include <unistd.h>
main()
{
    int filedes[2];
    char buffer[80];
    pipe(filedes);
    if (fork() > 0)
    {
        /* 父进程 */
        char s[] = "hello!\n";
        write(filedes[1], s, sizeof(s));
    }
else
{
    /* 子进程 */
    read(filedes[0], buffer, 80);
    printf("%s", buffer);
}
}

执行： hello!

popen

popen（建立管道I/O）

相关函数：pipe，mkfifo，pclose，fork，system，fopen

表头文件：#include <stdio.h>

定义函数：FILE *popen(const char *command, const char *type);

函数说明：popen()会调用fork()产生子进程，然后从子进程中调用/bin/sh -c来执行参数command的指令。参数type可使用"r"代表读取，"w"代表写入。依照此type值，popen()会建立管道连到子进程的标准输出设备或标准输入设备，然后返回一个文件指针。随后进程便可利用此文件指针来读取子进程的输出设备或是写入到子进程的标准输入设备中。此外，所有使用文件指针(FILE *)操作的函数也都可以使用，除了fclose()以外。

返回值：若成功则返回文件指针，否则返回NULL，错误原因存于errno中。

错误代码：EINVAL参数type不合法。注意事项在编写具SUID/SGID权限的程序时请尽量避免使用popen()，popen()会继承环境变量，通过环境变量可能会造成系统安全的问题。

范例：

#include <stdio.h>
main()
{
    FILE *fp;
    char buffer[80];
    fp = popen("cat /etc/passwd", "r");
    fgets(buffer, sizeof(buffer), fp);
    printf("%s", buffer);
    pclose(fp);
}

执行： root :

x:0 0: root: /root: /bin/bash

接口处理篇 14

TODO

accept

accept（接受socket连线）

相关函数：socket，bind，listen，connect

表头文件：#include <sys/types.h> #include <sys/socket.h>

定义函数：int accept(int s, struct sockaddr *addr, int *addrlen);

函数说明：accept()用来接受参数s的socket连线。参数s的socket必需先经bind()、listen()函数处理过，当有连线进来时accept()会返回一个新的socket处理代码，往后的数据传送与读取就是经由新的socket处理，而原来参数s的socket能继续使用accept()来接受新的连线要求。连线成功时，参数addr所指的结构会被系统填入远程主机的地址数据，参数addrlen为scokaddr的结构长度。关于结构sockaddr的定义请参考bind()。

返回值：成功则返回新的socket处理代码，失败返回-1，错误原因存于errno中。

错误代码：EBADF 参数s非合法socket处理代码。 EFAULT 参数addr指针指向无法存取的内存空间。 ENOTSOCK 参数s为一文件描述词，非socket。 EOPNOTSUPP 指定的socket并非SOCK_STREAM。 EPERM 防火墙拒绝此连线。 ENOBUFS 系统的缓冲内存不足。 ENOMEM 核心内存不足。

范例：参考listen()。

bind

bind（对socket定位）

相关函数：socket，accept，connect，listen

表头文件：#include <sys/types.h> #include <sys/socket.h>

定义函数：int bind(int sockfd, struct sockaddr *my_addr, int addrlen);

函数说明：bind()用来设置给参数sockfd的socket一个名称。此名称由参数my_addr指向一sockaddr结构，对于不同的socket domain定义了一个通用的数据结构 struct sockaddr { unsigned short int sa_family; char sa_data[14]; }; sa_family为调用socket()时的domain参数，即AF_xxxx值。 sa_data最多使用14个字符长度。此sockaddr结构会因使用不同的socket domain而有不同结构定义，例如使用AF_INET domain，其socketaddr结构定义便为 struct socketaddr_in { unsigned short int sin_family; uint16_t sin_port; struct in_addr sin_addr; unsigned char sin_zero[8]; }; struct in_addr { uint32_t s_addr; }; sin_family即为sa_family sin_port为使用的port编号 sin_addr.s_addr为IP地址 sin_zero未使用。参数 addrlen为sockaddr的结构长度。

返回值：成功则返回0，失败返回-1，错误原因存于errno中。

错误代码：EBADF 参数sockfd非合法socket处理代码。 EACCESS 权限不足 ENOTSOCK 参数sockfd为一文件描述词，非socket。

范例：参考listen()

connect

connect（建立socket连线）

endprotoent

endprotoent（结束网络协议数据的读取）

相关函数：getprotoent，getprotobyname，getprotobynumber，setprotoent

表头文件：#include <netdb.h>

定义函数：void endprotoent(void);

函数说明：endprotoent()用来关闭由getprotoent()打开的文件。

返回值：

范例：参考getprotoent()

endservent

endservent（结束网络服务数据的读取）

相关函数：getservent，getservbyname，getservbyport，setservent

表头文件：#include <netdb.h>

定义函数：void endservent(void);

函数说明：endservent()用来关闭由getservent()所打开的文件。

返回值：

范例：参考getservent()。

getsockopt

getsockopt（取得socket状态）

htonl

htonl（将32位主机字符顺序转换成网络字符顺序）

htons

htons（将16位主机字符顺序转换成网络字符顺序）

inet_addr

inet_addr（将网络地址转成二进制的数字）

inet_aton

inet_aton（将网络地址转成网络二进制的数字）

inet_ntoa

inet_ntoa（将网络二进制的数字转换成网络地址）

listen

listen（等待连接）

相关函数：socket，bind，accept，connect

表头文件：#include <sys/socket.h>

定义函数：int listen(int s, int backlog);

函数说明：listen()用来等待参数s的socket连线。参数backlog指定同时能处理的最大连接要求，如果连接数目达此上限则client端将收到ECONNREFUSED的错误。Listen()并未开始接收连线，只是设置socket为listen模式，真正接收client端连线的是accept()。通常listen()会在socket()，bind()之后调用，接着才调用accept()。

返回值：成功则返回0，失败返回-1，错误原因存于errno

附加说明：listen()只适用SOCK_STREAM或SOCK_SEQPACKET的socket类型。如果socket为AF_INET则参数backlog最大值可设至128。

错误代码：EBADF 参数sockfd非合法socket处理代码 EACCESS 权限不足 EOPNOTSUPP 指定的socket并未支援listen模式。

范例：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define PORT 1234 #define MAXSOCKFD 10
main()
{
    int sockfd, newsockfd, is_connected[MAXSOCKFD], fd;
    struct sockaddr_in addr;
    int addr_len = sizeof(
    struct sockaddr_in); fd_set readfds; char buffer[256]; char msg[] = "Welcome to server!"; if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket");
        exit(1);
    }
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sockfd, &addr, sizeof(addr)) < 0)
{
    perror("connect");
    exit(1);
}
if (listen(sockfd, 3) < 0)
{
    perror("listen");
    exit(1);
}
for (fd = 0; fd < MAXSOCKFD; fd++) is_connected[fd] = 0; while (1)
{
    FD_ZERO(&readfds);
    FD_SET(sockfd, &readfds);
    for (fd = 0; fd < MAXSOCKFD; fd++) if (is_connected[fd]) FD_SET(fd, &readfds); if (!select(MAXSOCKFD, &readfds, NULL, NULL, NULL)) continue; for (fd = 0; fd < MAXSOCKFD; fd++) if (FD_ISSET(fd, &readfds))
    {
        if (sockfd == fd)
        {
            if ((newsockfd = accept(sockfd, &addr, &addr_len)) < 0) perror("accept");
            write(newsockfd, msg, sizeof(msg));
            is_connected[newsockfd] = 1;
            printf("cnnect from %s\n", inet_ntoa(addr.sin_addr));
        }
    else
    {
        bzero(buffer, sizeof(buffer));
        if (read(fd, buffer, sizeof(buffer)) <= 0)
        {
            printf("connect closed.\n");
            is_connected[fd] = 0;
            close(fd);
        }
    else printf("%s", buffer);
}
}
}
}

执行： $

./listen

connect

from

127.0.0.1

client

connected

closed.

ntohl

ntohl（将32位网络字符顺序转换为主机字符顺序）

ntohs

ntohs（将16位网络字符顺序转换为主机字符顺序）

recv

recv（经socket接收数据）

相关函数：recvfrom，recvmsg，send，sendto，socket

表头文件：#include <sys/types.h> #include <sys/socket.h>

定义函数：int recv(int s, void *buf, int len, unsigned int flags);

函数说明：recv()用来接收远程主机经指定的socket传来的数据，并把数据存到由参数buf指向的内存空间，参数len为可接收数据的最大长度。参数 flags一般设0。其他数值定义如下: MSG_OOB 接收以out-of-band送出的数据。 MSG_PEEK 返回来的数据并不会在系统内删除，如果再调用recv()会返回相同的数据内容。 MSG_WAITALL 强迫接收到len大小的数据后才能返回，除非有错误或信号产生。 MSG_NOSIGNAL 此操作不愿被SIGPIPE信号中断返回值成功则返回接收到的字符数，失败返回-1，错误原因存于errno中。

错误代码：EBADF 参数s非合法的socket处理代码 EFAULT 参数中有一指针指向无法存取的内存空间 ENOTSOCK 参数s为一文件描述词，非socket。 EINTR 被信号所中断 EAGAIN 此动作会令进程阻断，但参数s的socket为不可阻断 ENOBUFS 系统的缓冲内存不足。 ENOMEM 核心内存不足 EINVAL 传给系统调用的参数不正确。

范例：参考listen()。

recvfrom

recvfrom（经socket接收数据）

相关函数：recv，recvmsg，send，sendto，socket

表头文件：#include <sys/types.h> #include <sys/socket.h>

定义函数：int recvfrom(int s, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen);

函数说明：recv()用来接收远程主机经指定的socket传来的数据，并把数据存到由参数buf指向的内存空间，参数len为可接收数据的最大长度。参数flags一般设0，其他数值定义请参考recv()。参数from用来指定欲传送的网络地址，结构sockaddr请参考bind()。参数fromlen为sockaddr的结构长度。

返回值：成功则返回接收到的字符数，失败则返回-1，错误原因存于errno中。

错误代码：EBADF 参数s非合法的socket处理代码 EFAULT 参数中有一指针指向无法存取的内存空间。 ENOTSOCK 参数s为一文件描述词，非socket。 EINTR 被信号所中断。 EAGAIN 此动作会令进程阻断，但参数s的socket为不可阻断。 ENOBUFS 系统的缓冲内存不足 ENOMEM 核心内存不足 EINVAL 传给系统调用的参数不正确。

范例：

/* 利用socket的UDP client 此程序会连线UDP server，并将键盘输入的字符串传给server。 UDP server范例请参考sendto()。 */
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/typs.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define PORT 2345 #define SERVER_IP "127.0.0.1"
main()
{
    int s, len;
    struct sockaddr_in addr;
    int addr_len = sizeof(
    struct sockaddr_in); char buffer[256];
    /* 建立socket */
    if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    {
        perror("socket");
        exit(1);
    }
/* 填写sockaddr_in */
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = inet_addr(SERVER_IP);
while (1)
{
    bzero(buffer, sizeof(buffer));
    /* 从标准输入设备取得字符串 */
    len = read(STDIN_FILENO, buffer, sizeof(buffer));
    /* 将字符串传送给server端 */
    sendto(s, buffer, len, 0, &addr, addr_len);
    /* 接收server端返回的字符串 */
    len = recvfrom(s, buffer, sizeof(buffer), 0, &addr, &addr_len);
    printf("receive: %s", buffer);
}
}

执行： (先执行udp server再执行udp client) hello /从键盘输入字符串/ receive: hello /server端返回来的字符串/

recvmsg

recvmsg（经socket接收数据）

相关函数：recv，recvfrom，send，sendto，sendmsg，socket

表头文件：#include <sys/types.h> #include <sys/socket.h>

定义函数：int recvmsg(int s, struct msghdr *msg, unsigned int flags);

函数说明：recvmsg()用来接收远程主机经指定的socket传来的数据。参数s为已建立好连线的socket，如果利用UDP协议则不需经过连线操作。参数msg指向欲连线的数据结构内容，参数flags一般设0，详细描述请参考send()。关于结构msghdr的定义请参考sendmsg()。

返回值：成功则返回接收到的字符数，失败则返回-1，错误原因存于errno中。

错误代码：EBADF 参数s非合法的socket处理代码。 EFAULT 参数中有一指针指向无法存取的内存空间 ENOTSOCK 参数s为一文件描述词，非socket。 EINTR 被信号所中断。 EAGAIN 此操作会令进程阻断，但参数s的socket为不可阻断。 ENOBUFS 系统的缓冲内存不足 ENOMEM 核心内存不足 EINVAL 传给系统调用的参数不正确。

范例：参考recvfrom()。

send

send（经socket传送数据）

相关函数：sendto，sendmsg，recv，recvfrom，socket

表头文件：#include <sys/types.h> #include <sys/socket.h>

定义函数：int send(int s, const void *msg, int len, unsigned int falgs);

函数说明：send()用来将数据由指定的socket传给对方主机。参数s为已建立好连接的socket。参数msg指向欲连线的数据内容，参数len则为数据长度。参数flags一般设0，其他数值定义如下 MSG_OOB 传送的数据以out-of-band送出。 MSG_DONTROUTE 取消路由表查询 MSG_DONTWAIT 设置为不可阻断运作 MSG_NOSIGNAL 此动作不愿被SIGPIPE信号中断。

返回值：成功则返回实际传送出去的字符数，失败返回-1。错误原因存于errno

范例：参考connect()

sendmsg

sendmsg（经socket传送数据）

相关函数：send，sendto，recv，recvfrom，recvmsg，socket

表头文件：#include <sys/types.h> #include <sys/socket.h>

定义函数：int sendmsg(int s, const struct msghdr *msg, unsigned int flags);

函数说明：sendmsg()用来将数据由指定的socket传给对方主机。参数s为已建立好连线的socket，如果利用UDP协议则不需经过连线操作。参数msg指向欲连线的数据结构内容，参数flags一般默认为0，详细描述请参考send()。结构msghdr定义如下 struct msghdr { void msg_name; / Address to send to / receive from. / socklen_t msg_namelen; / Length of addres data */ struct iovec msg_iov; / Vector of data to send/receive into / size_t msg_iovlen; / Number of elements in the vector */ void msg_control; / Ancillary dat / size_t msg_controllen; / Ancillary data buffer length / int msg_flags; / Flags on received message */ };

返回值：成功则返回实际传送出去的字符数，失败返回-1，错误原因存于errno

范例：参考sendto()。

sendto

sendto（经socket传送数据）

相关函数：send, sendmsg, recv, recvfrom, socket

表头文件：#include <sys/types.h> #include <sys/socket.h>

定义函数：int sendto(int s, const void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen);

函数说明：sendto()用来将数据由指定的socket传给对方主机。参数s为已建好连线的socket,如果利用UDP协议则不需经过连线操作。参数msg指向欲连线的数据内容，参数flags一般设0，详细描述请参考send()。参数to用来指定欲传送的网络地址，结构sockaddr请参考bind()。参数tolen为sockaddr的结果长度。

返回值：成功则返回实际传送出去的字符数，失败返回-1，错误原因存于errno中。

错误代码：EBADF 参数s非法的socket处理代码。 EFAULT 参数中有一指针指向无法存取的内存空间。 ENOTSOCK 参数s为一文件描述词，非socket。 EINTR 被信号所中断。 EAGAIN 此动作会令进程阻断，但参数s的socket为不可阻断。 ENOBUFS 系统的缓冲内存不足。 EINVAL 传给系统调用的参数不正确。

范例：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet.in.h>
#include <arpa.inet.h>
#define PORT 2345
/*使用的port*/
main()
{
    int sockfd, len;
    struct sockaddr_in addr;
    char buffer[256];
    /* 建立socket */
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    {
        perror("socket");
        exit(1);
    }
/* 填写sockaddr_in结构 */
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr = htonl(INADDR_ANY);
if (bind(sockfd, &addr, sizeof(addr)) < 0)
{
    perror("connect");
    exit(1);
}
while (1)
{
    bzero(buffer, sizeof(buffer));
    len = recvfrom(sockfd, buffer, sizeof(buffer), 0, &addr, &addr_len);
    /* 显示client端的网络地址 */
    printf("receive from %s\n", inet_ntoa(addr.sin_addr));
    /* 将字串返回给client端 */
    sendto(sockfd, buffer, len, 0, &addr, addr_len);
}
}

执行：请参考recvfrom()

setprotoent

setprotoent（打开网络协议的数据文件）

相关函数：getprotobyname, getprotobynumber, endprotoent

表头文件：#include <netdb.h>

定义函数：void setprotoent(int stayopen);

函数说明：setprotoent()用来打开/etc/protocols，如果参数stayopen值为1，则接下来的getprotobyname()或getprotobynumber()将不会自动关闭此文件。

setservent

setservent（打开主机网络服务的数据文件）

相关函数：getservent, getservbyname, getservbyport, endservent

表头文件：#include <netdb.h>

定义函数：void setservent(int stayopen);

函数说明：setservent()用来打开/etc/services，如果参数stayopen值为1，则接下来的getservbyname()或getservbyport()将不会自动关闭文件。

setsockopt

setsockopt（设置socket状态）

shutdown

shutdown（终止socket通信）

socket

socket（建立一个socket通信）

相关函数：accept，bind，connect，listen

表头文件：#include <sys/types.h> #include <sys/socket.h>

定义函数：int socket(int domain, int type, int protocol);

函数说明：socket()用来建立一个新的socket，也就是向系统注册，通知系统建立一通信端口。参数domain指定使用何种的地址类型，完整的定义在/usr/include/bits/socket.h内，底下是常见的协议: PF_UNIX/PF_LOCAL/AF_UNIX/AF_LOCAL UNIX进程通信协议 PF_INET/AF_INET Ipv4网络协议 PF_INET6/AF_INET6 Ipv6网络协议 PF_IPX/AF_IPX IPX-Novell协议 PF_NETLINK/AF_NETLINK 核心用户接口装置 PF_X25/AF_X25 ITU-T X.25/ISO-8208协议 PF_AX25/AF_AX25 业余无线AX.25协议 PF_ATMPVC/AF_ATMPVC 存取原始ATM PVCs PF_APPLETALK/AF_APPLETALK appletalk（DDP）协议 PF_PACKET/AF_PACKET 初级封包接口参数 type有下列几种数值: SOCK_STREAM 提供双向连续且可信赖的数据流，即TCP。支持 OOB机制，在所有数据传送前必须使用connect()来建立连线状态。 SOCK_DGRAM 使用不连续不可信赖的数据包连接 SOCK_SEQPACKET 提供连续可信赖的数据包连接 SOCK_RAW 提供原始网络协议存取 SOCK_RDM 提供可信赖的数据包连接 SOCK_PACKET 提供和网络驱动程序直接通信。 protocol用来指定socket所使用的传输协议编号，通常此参考不用管它，设为0即可。

返回值：成功则返回socket处理代码，失败返回-1。

错误代码：EPROTONOSUPPORT 参数domain指定的类型不支持参数type或protocol指定的协议 ENFILE 核心内存不足，无法建立新的socket结构 EMFILE 进程文件表溢出，无法再建立新的socket EACCESS 权限不足，无法建立type或protocol指定的协议 ENOBUFS/ENOMEM 内存不足 EINVAL 参数domain/type/protocol不合法

范例：参考connect()。

环境变量篇 15

TODO

getenv

getenv（取得环境变量内容）

相关函数：putenv，setenv，unsetenv

表头文件：#include <stdlib.h>

定义函数：char *getenv(const char *name);

函数说明：getenv()用来取得参数name环境变量的内容。参数name为环境变量的名称，如果该变量存在则会返回指向该内容的指针。环境变量的格式为name＝value。

返回值：执行成功则返回指向该内容的指针，找不到符合的环境变量名称则返回NULL。

范例：

#include <stdlib.h>
mian()
{
    char *p;
    if ((p = getenv("USER"))) printf("USER=%s\n", p);
}

执行： USER = root

putenv

putenv（改变或增加环境变量）

相关函数：getenv，setenv，unsetenv

表头文件：#include <stdlib.h>

定义函数：int putenv(const char *string);

函数说明：putenv()用来改变或增加环境变量的内容。参数string的格式为name＝value，如果该环境变量原先存在，则变量内容会依参数string改变，否则此参数内容会成为新的环境变量。

返回值：执行成功则返回0，有错误发生则返回-1。

错误代码：ENOMEM 内存不足，无法配置新的环境变量空间。

范例：

#include <stdlib.h>
main()
{
    char *p;
    if ((p = getenv("USER"))) printf("USER =%s\n", p);
    putenv("USER=test");
    printf("USER=%s\n", getenv("USER"));
}

执行： USER=root USER=root

setenv

setenv（改变或增加环境变量）

相关函数：getenv，putenv，unsetenv

表头文件：#include <stdlib.h>

定义函数：int setenv(const char *name, const char *value, int overwrite);

函数说明：setenv()用来改变或增加环境变量的内容。参数name为环境变量名称字符串。参数 value则为变量内容，参数overwrite用来决定是否要改变已存在的环境变量。如果overwrite不为0，而该环境变量原已有内容，则原内容会被改为参数value所指的变量内容。如果overwrite为0，且该环境变量已有内容，则参数value会被忽略。

返回值：执行成功则返回0，有错误发生时返回-1。

错误代码：ENOMEM 内存不足，无法配置新的环境变量空间

范例：

#include <stdlib.h>
main()
{
    char *p;
    if ((p = getenv("USER"))) printf("USER =%s\n", p);
    setenv("USER", "test", 1);
    printf("USER=%s\n", getenv("USEr"));
    unsetenv("USER");
    printf("USER=%s\n", getenv("USER"));
}

执行： USER = root USER = test USER = (null)

终端控制篇 16

TODO

getopt

getopt（分析命令行参数）

isatty

isatty（判断文件描述词是否是伪终端机）

select

select（I/O多工机制）

表头文件：#include <sys/time.h> #include <sys/types.h> #include <unistd.h>

定义函数：int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

函数说明：select()用来等待文件描述词状态的改变。参数n代表最大的文件描述词加1，参数readfds、writefds和exceptfds称为描述词组，是用来回传该描述词的读，写或例外的状况。底下的宏提供了处理这三种描述词组的方式: FD_CLR(inr fd, fd_set* set)；用来清除描述词组set中相关fd的位 FD_ISSET(int fd, fd_set set)；用来测试描述词组set中相关fd的位是否为真 FD_SET(int fd, fd_setset)；用来设置描述词组set中相关fd的位 FD_ZERO(fd_set *set)；用来清除描述词组set的全部位参数 timeout为结构timeval，用来设置select()的等待时间，其结构定义如下 struct timeval { time_t tv_sec; time_t tv_usec; };

返回值：如果参数timeout设为NULL则表示select()没有timeout。

错误代码：执行成功则返回文件描述词状态已改变的个数，如果返回0代表在描述词状态改变前已超过timeout时间，当有错误发生时则返回-1，错误原因存于errno，此时参数readfds，writefds，exceptfds和timeout的值变成不可预测。 EBADF 文件描述词为无效的或该文件已关闭 EINTR 此调用被信号所中断 EINVAL 参数n为负值。 ENOMEM 核心内存不足

范例：常见的程序片段:fs_set readset; FD_ZERO(&readset); FD_SET(fd, &readset); select(fd+1, &readset, NULL, NULL, NULL); if (FD_ISSET(fd, readset)) { ... }

ttyname

ttyname（返回一终端机名称）