isalnum（测试字符是否为英文或数字）
相关函数 isalpha，isdigit，islower，isupper

表头文件 #include

定义函数 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 （测试字符是否为英文字母）
相关函数 isalnum，islower，isupper

表头文件 #include

定义函数 int isalpha (int c)

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

返回值 若参数c为英文字母，则返回true，否则返回null(0)。

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

范例 /* 找出str 字符串中为英文字母的字符*/
#include
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（测试字符是否为ascii 码字符）
相关函数 iscntrl

表头文件 #include

定义函数 int isascii(int c);

函数说明 检查参数c是否为ascii码字符，也就是判断c的范围是否在0到127之间。

返回值 若参数c为ascii码字符，则返回true，否则返回null(0)。

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

范例 /* 判断int i是否具有对映的ascii码字符*/
#include
main()
{
int i;
for(i=125;i<130;i++)
if(isascii(i))
printf(”%d is an ascii character:%c/n”,i,i);
else
printf(”%d is not an ascii character/n”,i);
}

执行 125 is an ascii character:}
126 is an ascii character:~
127 is an ascii character:
128 is not an ascii character
129 is not an ascii character

　

iscntrl（测试字符是否为ascii 码的控制字符）
相关函数 isascii

表头文件 #include

定义函数 int iscntrl(int c)；

函数说明 检查参数c是否为ascii控制码，也就是判断c的范围是否在0到30之间。

返回值 若参数c为ascii控制码，则返回true，否则返回null(0)。

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

　

isdigit（测试字符是否为阿拉伯数字）
相关函数 isxdigit

表头文件 #include

定义函数 int isdigit(int c)

函数说明 检查参数c是否为阿拉伯数字0到9。

返回值 若参数c为阿拉伯数字，则返回true，否则返回null(0)。

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

范例 /* 找出str字符串中为阿拉伯数字的字符*/
#include
main()
{
char str[]=”123@#fdsp[e?”;
int i;
for(i=0;str[i]!=0;i++)
if(isdigit(str[i])) printf(”%c is an digit character/n”,str[i]);
}

执行 1 is an digit character
2 is an digit character
3 is an digit character

　

isgraphis（测试字符是否为可打印字符）
相关函数 isprint

表头文件 #include

定义函数 int isgraph (int c)

函数说明 检查参数c是否为可打印字符，若c所对映的ascii码可打印，且非空格字符则返回true。

返回值 若参数c为可打印字符，则返回true，否则返回null(0)。

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

范例 /* 判断str字符串中哪些为可打印字符*/
#include
main()
{
char str[]=”a5 @;”;
int i;
for(i=0;str[i]!=0;i++)
if(isgraph(str[i])) printf(”str[%d] is printable character:%d/n”,i,str[i]);
}

执行 str[0] is printable character:a
str[1] is printable character:5
str[3] is printable character:@
str[4] is printable character:;

　

islower（测试字符是否为小写字母）
相关函数 isalpha，isupper

表头文件 #include

定义函数 int islower(int c)

函数说明 检查参数c是否为小写英文字母。

返回值 若参数c为小写英文字母，则返回true，否则返回null(0)。

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

范例 #include
main()
{
char str[]=”123@#fdsp[e?”;
int i;
for(i=0;str[i]!=0;i++)
if(islower(str[i])) printf(”%c is a lower-case character/n”,str[i]);
}

执行 c is a lower-case character
s is a lower-case character
e is a lower-case character

　

isprint（测试字符是（否为可打印字符）
相关函数 isgraph

表头文件 #include

定义函数 int isprint(int c);

函数说明 检查参数c是否为可打印字符，若c所对映的ascii码可打印，其中包含空格字符，则返回true。

返回值 若参数c为可打印字符，则返回true，否则返回null(0)。

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

范例 /* 判断str字符串中哪些为可打印字符包含空格字符*/
#include
main()
{
char str[]=”a5 @;”;
int i;
for(i=0;str[i]!=0;i++)
if(isprint(str[i])) printf(”str[%d] is printable character:%d/n”,i,str[i]);
}

执行 str[0] is printable character:a
str[1] is printable character:5
str[2] is printable character:
str[3] is printable character:@
str[4] is printable character:;

　

isspace（测试字符是否为空格字符）
相关函数 isgraph

表头文件 #include

定义函数 int isspace(int c)

函数说明 检查参数c是否为空格字符，也就是判断是否为空格('’)、定位字符(’/t’)、cr(’/r’)、换行(’/n’)、垂直定位字符(’/v’)或翻页(’/f’)的情况。

返回值 若参数c为空格字符，则返回true，否则返回null(0)。

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

范例 /*将字符串str[]中内含的空格字符找出，并显示空格字符的ascii码*/
#include
main()
{
char str=”123c @# fd/tsp[e?/n”;
int i;
for(i=0;str[i]!=0;i++)
if(isspace(str[i]))
printf(”str[%d] is a white-space character:%d/n”,i,str[i]);
}

执行 str[4] is a white-space character:32
str[7] is a white-space character:32
str[10] is a white-space character:9 /* /t */
str[16] is a white-space character:10 /* /t */

　

ispunct（测试字符是否为标点符号或特殊符号）
相关函数 isspace，isdigit，isalpha

表头文件 #inlude

定义函数 int ispunct(int c)

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

返回值 v若参数c为标点符号或特殊符号，则返回true，否则返回null(0)。

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

范例 /*列出字符串str中的标点符号或特殊符号*/
#include
main()
{
char str[]=”123c@ #fdsp[e?”;
int i;
for(i=0;str[i]!=0;i++)
if(ispunct(str[i])) printf(”%c/n”,str[i]);
}

执行 v
@#[?

　

isupper（测试字符是否为大写英文字母）
相关函数 isalpha，islower

表头文件 #include

定义函数 int isupper(int c)

函数说明 检查参数c是否为大写英文字母。

返回值 若参数c为大写英文字母，则返回true，否则返回null(0)。

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

范例 /*找出字符串str中为大写英文字母的字符*/
#include
main()
{
char str[]=”123c@#fdsp[e?”;
int i;
for(i=0;str[i]!=0;i++)
if(isupper(str[i])) printf(”%c is an uppercase character/n”,str[i]);
}

执行 f is an uppercase character
d is an uppercase character
p is an uppercase character

　

isxdigit（测试字符是否为16进制数字）
相关函数 isalnum，isdigit

表头文件 #include

定义函数 int isxdigit (int c)

函数说明 检查参数c是否为16进制数字，只要c为下列其中一个情况则返回true。16进制数字:0123456789abcdef。

返回值 若参数c为16进制数字，则返回true，否则返回null(0)。

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

范例 /*找出字符串str中为十六进制数字的字符*/
#include
main()
{
char str[]=”123c@#fdsp[e?”;
int i;
for(i=0;str[i]!=0;i++)
if(isxdigit(str[i])) printf(”%c is a hexadecimal digits/n”,str[i]);
}

执行 1 is a hexadecimal digits
2 is a hexadecimal digits
3 is a hexadecimal digits
c is a hexadecimal digits
f is a hexadecimal digits
d is a hexadecimal digits
e is a hexadecimal digits

　

　

atof（将字符串转换成浮点型数）
相关函数 atoi，atol，strtod，strtol，strtoul

表头文件 #include

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

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

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

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

范例 /* 将字符串a 与字符串b转换成数字后相加*/
#include
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（将字符串转换成整型数）
相关函数 atof，atol，atrtod，strtol，strtoul

表头文件 #include

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

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

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

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

范例 /* 将字符串a 与字符串b转换成数字后相加*/
#include
mian()
{
char a[]=”-100”;
char b[]=”456”;
int c;
c=atoi(a)+atoi(b);
printf(c=%d/n”,c);
}

执行 c=356

　

atol（将字符串转换成长整型数）
相关函数 atof，atoi，strtod，strtol，strtoul

表头文件 #include

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

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

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

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

范例 /*将字符串a与字符串b转换成数字后相加*/
#include
main()
{
char a[]=”1000000000”;
char b[]=” 234567890”;
long c;
c=atol(a)+atol(b);
printf(“c=%d/n”,c);
}

执行 c=1234567890

　

gcvt（将浮点型数转换为字符串，取四舍五入）
相关函数 ecvt，fcvt，sprintf

表头文件 #include

定义函数 char *gcvt(double number，size_t ndigits，char *buf);

函数说明 gcvt()用来将参数number转换成ascii码字符串，参数ndigits表示显示的位数。gcvt()与ecvt()和fcvt()不同的地方在于，gcvt()所转换后的字符串包含小数点或正负符号。若转换成功，转换后的字符串会放在参数buf指针所指的空间。

返回值 返回一字符串指针，此地址即为buf指针。

附加说明

范例 #include
main()
{
double a=123.45;
double b=-1234.56;
char *ptr;
int decpt,sign;
gcvt(a,5,ptr);
printf(“a value=%s/n”,ptr);
ptr=gcvt(b,6,ptr);
printf(“b value=%s/n”,ptr);
}

执行 a value=123.45
b value=-1234.56

　

strtod（将字符串转换成浮点数）
相关函数 atoi，atol，strtod，strtol，strtoul

表头文件 #include

定义函数 double strtod(const char *nptr,char **endptr);

函数说明 strtod()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，到出现非数字或字符串结束时(’/0′)才结束转换，并将结果返回。若endptr不为null，则会将遇到不合条件而终止的nptr中的字符指针由endptr传回。参数nptr字符串可包含正负号、小数点或e(e)来表示指数部分。如123.456或123e-2。

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

附加说明 参考atof()。

范例 /*将字符串a，b，c 分别采用10，2，16 进制转换成数字*/
#include
mian()
{
char a[]=”1000000000”;
char b[]=”1000000000”;
char c[]=”ffff”;
printf(“a=%d/n”,strtod(a,null,10));
printf(“b=%d/n”,strtod(b,null,2));
printf(“c=%d/n”,strtod(c,null,16));
}

执行 a=1000000000
b=512
c=65535

　

strtol（将字符串转换成长整型数）
相关函数 atof，atoi，atol，strtod，strtoul

表头文件 #include

定义函数 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
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（将字符串转换成无符号长整型数）
相关函数 atof，atoi，atol，strtod，strtol

表头文件 #include

定义函数 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（将整型数转换成合法的ascii 码字符）
相关函数 isascii，toupper，tolower

表头文件 #include

定义函数 int toascii(int c)

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

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

范例 #include
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);
}

执行 before toascii() : a value =217()
after toascii() : a value =89(y)

　

tolower（将大写字母转换成小写字母）
相关函数 isalpha，toupper

表头文件 #include

定义函数 int tolower(int c);

函数说明 若参数c为大写字母则将该对应的小写字母返回。

返回值 返回转换后的小写字母，若不须转换则将参数c值返回。

附加说明

范例 /* 将s字符串内的大写字母转换成小写字母*/
#include
main()
{
char s[]=”abcdefgh12345;!#$”;
int i;
printf(“before tolower() : %s/n”,s);
for(i=0;i s[i]=tolower(s[i]);
printf(“after tolower() : %s/n”,s);
}

执行 before tolower() : abcdefgh12345;!#$
after tolower() : abcdefgh12345;!#$

　

toupper（将小写字母转换成大写字母）
相关函数 isalpha，tolower

表头文件 #include

定义函数 int toupper(int c);

函数说明 若参数c为小写字母则将该对映的大写字母返回。

返回值 返回转换后的大写字母，若不须转换则将参数c值返回。

附加说明

范例 /* 将s字符串内的小写字母转换成大写字母*/
#include
main()
{
char s[]=”abcdefgh12345;!#$”;
int i;
printf(“before toupper() : %s/n”,s);
for(i=0;i s[i]=toupper(s[i]);
printf(“after toupper() : %s/n”,s);
}

执行 before toupper() : abcdefgh12345;!#$
after toupper() : abcdefgh12345;!#$

　

　

calloc（配置内存空间）
相关函数 malloc，free，realloc，brk

表头文件 #include

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

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

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

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

　

free（释放原先配置的内存）
相关函数 malloc，calloc，realloc，brk

表头文件 #include

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

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

　

getpagesize（取得内存分页大小）
相关函数 sbrk

表头文件 #include

定义函数 size_t getpagesize(void);

函数说明 返回一分页的大小，单位为字节（byte）。此为系统的分页大小，不一定会和硬件分页大小相同。

返回值 内存分页大小。附加说明在intel x86 上其返回值应为4096bytes。

范例 #include
main()
{
printf(“page size = %d/n”,getpagesize( ) );
}

　

malloc（配置内存空间）
相关函数 calloc，free，realloc，brk

表头文件 #include

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

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

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

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

　

mmap（建立内存映射）
相关函数 munmap，open

表头文件 #include
#include

定义函数 void *mmap(void *start,size_t length,int prot,int flags,int fd,off_t offsize);

函数说明 mmap()用来将某个文件内容映射到内存中，对该内存区域的存取即是直接对该文件内容的读写。参数start指向欲对应的内存起始地址，通常设为null，代表让系统自动选定地址，对应成功后该地址会返回。参数length代表将文件中多大的部分对应到内存。

参数 prot代表映射区域的保护方式有下列组合
prot_exec 映射区域可被执行
prot_read 映射区域可被读取
prot_write 映射区域可被写入
prot_none 映射区域不能存取

参数 flags会影响映射区域的各种特性
map_fixed 如果参数start所指的地址无法成功建立映射时，则放弃映射，不对地址做修正。通常不鼓励用此旗标。
map_shared对映射区域的写入数据会复制回文件内，而且允许其他映射该文件的进程共享。
map_private 对映射区域的写入操作会产生一个映射文件的复制，即私人的“写入时复制”（copy on write）对此区域作的任何修改都不会写回原来的文件内容。
map_anonymous建立匿名映射。此时会忽略参数fd，不涉及文件，而且映射区域无法和其他进程共享。
map_denywrite只允许对映射区域的写入操作，其他对文件直接写入的操作将会被拒绝。
map_locked 将映射区域锁定住，这表示该区域不会被置换（swap）。
在调用mmap()时必须要指定map_shared 或map_private。参数fd为open()返回的文件描述词，代表欲映射到内存的文件。参数offset为文件映射的偏移量，通常设置为0，代表从文件最前方开始对应，offset必须是分页大小的整数倍。

返回值 若映射成功则返回映射区的内存起始地址，否则返回map_failed(－1)，错误原因存于errno 中。

错误代码 ebadf 参数fd 不是有效的文件描述词
eacces 存取权限有误。如果是map_private 情况下文件必须可读，使用map_shared则要有prot_write以及该文件要能写入。
einval 参数start、length 或offset有一个不合法。
eagain 文件被锁住，或是有太多内存被锁住。
enomem 内存不足。

范例 /* 利用mmap()来读取/etc/passwd 文件内容*/
#include
#include
#include
#include
#include
main()
{
int fd;
void *start;
struct stat sb;
fd=open(“/etc/passwd”,o_rdonly); /*打开/etc/passwd*/
fstat(fd,&sb); /*取得文件大小*/
start=mmap(null,sb.st_size,prot_read,map_private,fd,0);
if(start= = map_failed) /*判断是否映射成功*/
return;
printf(“%s”,start);
munma(start,sb.st_size); /*解除映射*/
closed(fd);
}

执行 root : x : 0 : root : /root : /bin/bash
bin : x : 1 : 1 : bin : /bin :
daemon : x : 2 : 2 :daemon : /sbin
adm : x : 3 : 4 : adm : /var/adm :
lp : x :4 :7 : lp : /var/spool/lpd :
sync : x : 5 : 0 : sync : /sbin : bin/sync :
shutdown : x : 6 : 0 : shutdown : /sbin : /sbin/shutdown
halt : x : 7 : 0 : halt : /sbin : /sbin/halt
mail : x : 8 : 12 : mail : /var/spool/mail :
news : x :9 :13 : news : /var/spool/news :
uucp : x :10 :14 : uucp : /var/spool/uucp :
operator : x : 11 : 0 :o perator : /root:
games : x : 12 :100 : games :/usr/games:
gopher : x : 13 : 30 : gopher : /usr/lib/gopher-data:
ftp : x : 14 : 50 : ftp user : /home/ftp:
nobody : x :99: 99: nobody : /:
xfs :x :100 :101 : x font server : /etc/xll/fs : /bin/false
gdm : x : 42 :42 : : /home/gdm: /bin/bash
kids : x : 500 :500 :/home/kids : /bin/bash

　

munmap（解除内存映射）
相关函数 mmap

表头文件 #include
#include

定义函数 int munmap(void *start,size_t length);

函数说明 munmap()用来取消参数start所指的映射内存起始地址，参数length则是欲取消的内存大小。当进程结束或利用exec相关函数来执行其他程序时，映射内存会自动解除，但关闭对应的文件描述词时不会解除映射。

返回值 如果解除映射成功则返回0，否则返回－1，错误原因存于errno中错误代码einval

参数 start或length 不合法。

范例 参考mmap（）

　

　

asctime（将时间和日期以字符串格式表示）
相关函数 time，ctime，gmtime，localtime

表头文件 #include

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

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

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

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

范例 #include
main()
{
time_t timep;
time (&timep);
printf(“%s”,asctime(gmtime(&timep)));
}

执行 sat oct 28 02:10:06 2000

　

ctime（将时间和日期以字符串格式表示）
相关函数 time，asctime，gmtime，localtime

表头文件 #include

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

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

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

范例 #include
main()
{
time_t timep;
time (&timep);
printf(“%s”,ctime(&timep));
}

执行 sat oct 28 10 : 12 : 05 2000

　

gettimeofday（取得目前的时间）
相关函数 time，ctime，ftime，settimeofday

表头文件 #include
#include

定义函数 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
#include
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（取得目前时间和日期）
相关函数 time,asctime,ctime,localtime

表头文件 #include

定义函数 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
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（取得当地目前时间和日期）
相关函数 time, asctime, ctime, gmtime

表头文件 #include

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

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

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

范例 #include
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),( l+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（将时间结构数据转换成经过的秒数）
相关函数 time，asctime，gmtime，localtime

表头文件 #include

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

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

返回值 返回经过的秒数。

范例 /* 用time()取得时间（秒数），利用localtime()
转换成struct tm 再利用mktine（）将struct tm转换成原来的秒数*/
#include
main()
{
time_t timep;
strcut 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（设置目前时间）
相关函数 time，ctime，ftime，gettimeofday

表头文件 #include
#include

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

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

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

错误代码 eperm 并非由root权限调用settimeofday（），权限不够。
einval 时区或某个数据是不正确的，无法正确设置时间。

　

time（取得目前的时间）
相关函数 ctime，ftime，gettimeofday

表头文件 #include

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

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

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

范例 #include
mian()
{
int seconds= time((time_t*)null);
printf(“%d/n”,seconds);
}

执行 9.73e+08

　

　

bcmp（比较内存内容）
相关函数 bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp

表头文件 #include

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

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

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

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

范例 参考memcmp()。

　

bcopy（拷贝内存内容）
相关函数 memccpy，memcpy，memmove，strcpy，ctrncpy

表头文件 #include

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

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

返回值

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

范例 #include
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 sring

　

bzero（将一段内存内容全清为零）
相关函数 memset，swab

表头文件 #include

定义函数 void bzero(void *s,int n)；

函数说明 bzero()会将参数s所指的内存区域前n个字节，全部设为零值。相当于调用memset((void*)s,0,size_tn);

返回值

附加说明 建议使用memset取代

范例 参考memset()。

　

index（查找字符串中第一个出现的指定字符）
相关函数 rindex，srechr，strrchr

表头文件 #include

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

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

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

范例 #include
main()
{
char *s =”0123456789012345678901234567890”;
char *p;
p =index(s,’5’);
printf(%s/n”,p);
}

执行 5.68e+25

　

memccpy（拷贝内存内容）
相关函数 bcopy，memcpy，memmove，strcpy，strncpy

表头文件 #include

定义函数 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
main()
{
char a[]=”string[a]”;
char b[]=”string(b)”;
memccpy(a,b,’b',sizeof(b));
printf(”memccpy():%s/n”,a);
}

执行 memccpy():string(b)

　

memchr（在某一内存范围中查找一特定字符）
相关函数 index，rindex，strchr，strpbrk，strrchr，strsep，strspn，strstr

表头文件 #include

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

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

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

范例 #include
main()
{
char *s=”0123456789012345678901234567890″;
char *p;
p=memchr(s,’5′,10);
printf(”%s/n”,p);
}

执行 5.68e+25

　

memcmp（比较内存内容）
相关函数 bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp

表头文件 #include

定义函数 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
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（拷贝内存内容）
相关函数 bcopy，memccpy，memcpy，memmove，strcpy，strncpy

表头文件 #include

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

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

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

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

范例 #include
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（拷贝内存内容）
相关函数 bcopy，memccpy，memcpy，strcpy，strncpy

表头文件 #include

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

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

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

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

范例 参考memcpy()。

　

memset（将一段内存空间填入某值）
相关函数 bzero，swab

表头文件 #include

定义函数 void * memset (void *s ,int c, size_t n);

函数说明 memset()会将参数s所指的内存区域前n个字节以参数c填入，然后返回指向s的指针。在编写程序时，若需要将某一数组作初始化，memset()会相当方便。

返回值 返回指向s的指针。

附加说明 参数c虽声明为int， 但必须是unsigned char ，所以范围在0到255之间。

范例 #include
main()
{
char s[30];
memset (s,’a',sizeof(s));
s[30]=’/0′;
printf(”%s/n”,s);
}

执行 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

　

rindex（查找字符串中最后一个出现的指定字符）
相关函数 index，memchr，strchr，strrchr

表头文件 #include

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

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

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

范例 #include
mian()
{
char *s =”0123456789012345678901234567890″;
char *p;
p=rindex(s,’5′);
printf(”%s/n”,p);
}

执行 567890

　

strcasecmp（忽略大小写比较字符串）
相关函数 bcmp，memcmp，strcmp，strcoll，strncmp

表头文件 #include

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

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

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

范例 #include
main()
{
char *a=”abcdef”;
char *b=”abcdef”;
if(!strcasecmp(a,b))
printf(”%s=%s/n”,a,b);
}

执行 abcdef=abcdef

　

strcat（连接两字符串）
相关函数 bcopy，memccpy，memcpy，strcpy，strncpy

表头文件 #include

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

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

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

范例 #include
main()
{
char a[30]=”string(1)”;
char b[]=”string(2)”;
printf(”before strcat() : %s/n”,a);
printf(”after strcat() : %s/n”,strcat(a,b));
}

执行 before strcat () : string(1)
after strcat () : string(1)string(2)

　

strchr（查找字符串中第一个出现的指定字符）
相关函数 index，memchr，rinex，strbrk，strsep，strspn，strstr，strtok

表头文件 #include

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

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

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

范例 #include
main()
{
char *s=0123456789012345678901234567890”;
char *p;
p=strchr(s,’5′);
printf(”%s/n”,p);
}

执行 5.68e+25

　

strcmp（比较字符串）
相关函数 bcmp，memcmp，strcasecmp，strncasecmp，strcoll

表头文件 #include

定义函数 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
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（采用目前区域的字符排列次序来比较字符串）
相关函数 strcmp，bcmp，memcmp，strcasecmp，strncasecmp

表头文件 #include

定义函数 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（拷贝字符串）
相关函数 bcopy，memcpy，memccpy，memmove

表头文件 #include

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

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

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

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

范例 #include
main()
{
char a[30]=”string(1)”;
char b[]=”string(2)”;
printf(”before strcpy() :%s/n”,a);
printf(”after strcpy() :%s/n”,strcpy(a,b));
}

执行 before strcpy() :string(1)
after strcpy() :string(2)

　

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

表头文件 #inclued

定义函数 size_t strcspn ( const char *s,const char * reject);

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

返回值 返回字符串s开头连续不含字符串reject内的字符数目。

范例 #include
main()
{
char *str=”linux was first developed for 386/486-based pcs.”;
printf(”%d/n”,strcspn(str,” “));
printf(”%d/n”,strcspn(str,”/-”));
printf(”%d/n”,strcspn(str,”1234567890″));
}

执行 5 /*只计算到“ ”的出现，所以返回“linux”的长度*/
33 /*计算到出现“/”或“－”，所以返回到“6”的长度*/
30 /* 计算到出现数字字符为止，所以返回“3”出现前的长度*/

　

strdup（复制字符串）
相关函数 calloc，malloc，realloc，free

表头文件 #include

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

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

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

范例 #include
main()
{
char a[]=”strdup”;
char *b;
b=strdup(a);
printf(”b[ ]=/”%s/”/n”,b);
}

执行 b[ ]=”strdup”

　

strlen（返回字符串长度）
相关函数

表头文件 #include

定义函数 size_t strlen (const char *s);

函数说明 strlen()用来计算指定的字符串s的长度，不包括结束字符”/0″。

返回值 返回字符串s的字符数。

范例 /*取得字符串str的长度*/
#include
main()
{
char *str = “12345678″;
printf(”str length = %d/n”, strlen(str));
}

执行 str length = 8

　

strncasecmp（忽略大小写比较字符串）
相关函数 bcmp，memcmp，strcmp，strcoll，strncmp

表头文件 #include

定义函数 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
main()
{
char *a=”abcdef”;
char *b=”abcdef”;
if(!strncasecmp(a,b))
printf(”%s =%s/n”,a,b);
}

执行 abcdef=abcdef

　

strncat（连接两字符串）
相关函数 bcopy，memccpy，memecpy，strcpy，strncpy

表头文件 #inclue

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

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

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

范例 #include
main()
{
char a[30]=”string(1)”;
char b[]=”string(2)”;
printf(”before strnact() :%s/n”, a);
printf(”after strncat() :%s/n”, strncat(a,b,6));
}

执行 before strnact() : string(1)
after strncat() : string(1) string

　

strncpy（拷贝字符串）
相关函数 bcopy，memccpy，memcpy，memmove

表头文件 #include

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

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

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

范例 #inclue
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));
}

执行 before strncpy() : string(1)
after strncpy() : string(1)

　

strpbrk（查找字符串中第一个出现的指定字符）
相关函数 index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok

表头文件 #include

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

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

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

范例 #include
main()
{
char *s=”0123456789012345678901234567890″;
char *p;
p=strpbrk(s,”a1 839″); /*1会最先在s字符串中找到*/
printf(”%s/n”,p);
p=strprk(s,”4398″);/*3 会最先在s 字符串中找到*/
printf(”%s/n”,p);

执行 1.23e+29

　

strrchr（查找字符串中最后出现的指定字符）
相关函数 index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok

表头文件 #include

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

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

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

范例 #include
main()
{
char *s=”0123456789012345678901234567890″;
char *p;
p=strrchr(s,’5′);
printf(”%s/n”,p);
}

执行 567890

　

strspn（返回字符串中连续不含指定字符串内容的字符数）
相关函数 strcspn，strchr，strpbrk，strsep，strstr

表头文件 #include

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

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

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

范例 #include
main()
{
char *str=”linux was first developed for 386/486-based pcs.”;
char *t1=”abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz”;
printf(”%d/n”,strspn(str,t1));
}

执行 5 /*计算大小写字母。不包含“ ”，所以返回linux的长度。*/

　

strstr（在一字符串中查找指定的字符串）
相关函数 index，memchr，rindex，strchr，strpbrk，strsep，strspn，strtok

表头文件 #include

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

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

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

范例 #include
main()
{
char * s=”012345678901234567890123456789″;
char *p;
p= strstr(s,”901″);
printf(”%s/n”,p);
}

执行 9.01e+21

　

strtok（分割字符串）
相关函数 index，memchr，rindex，strpbrk，strsep，strspn，strstr

表头文件 #include

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

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

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

范例 #include
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 字符取代*/

　

　

abs（计算整型数的绝对值）
相关函数 labs, fabs

表头文件 #include

定义函数 int abs (int j)

函数说明 abs()用来计算参数j的绝对值，然后将结果返回。

返回值 返回参数j的绝对值结果。

范例 #ingclude
main(){
int ansert;
answer = abs(-12);
printf(”|-12| = %d/n”, answer);
}

执行 |-12| = 12

　

acos（取反余弦函数数值）
相关函数 asin , atan , atan2 , cos , sin , tan

表头文件 #include

定义函数 double acos (double x);

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

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

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

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

范例 #include main (){
double angle;
angle = acos(0.5);
printf(”angle = %f/n”, angle);
}

执行 angle = 1.047198

　

asin（取反正弦函数值）
相关函数 acos , atan , atan2 , cos , sin , tan

表头文件 #include

定义函数 double asin (double x)

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

返回值 返回－pi/2之pi/2之间的计算结果。

错误代码 edom参数x超出范围

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

范例 #include main()
{
double angle;
angle = asin (0.5);
printf(”angle = %f/n”,angle);
}

执行 angle = 0.523599

　

atan（取反正切函数值）
相关函数 acos，asin，atan2，cos，sin，tan

表头文件 #include

定义函数 double atan(double x);

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

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

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

范例 #include main()
{
double angle;
angle =atan(1);
printf(”angle = %f/n”,angle);
}

执行 angle = 1.570796

　

atan2（取得反正切函数值）
相关函数 acos，asin，atan，cos，sin，tan

表头文件 #include

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

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

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

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

范例 #include main()
{
double angle;
angle = atan2(1,2);
printf(”angle = %f/n”, angle);
}

执行 angle = 0.463648

　

ceil（取不小于参数的最小整型数）
相关函数 fabs

表头文件 #include

定义函数 double ceil (double x);

函数说明 ceil()会返回不小于参数x的最小整数值，结果以double形态返回。

返回值 返回不小于参数x的最小整数值。

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

范例 #include main()
{
double value[ ]={4.8,1.12,-2.2,0};
int i;
for (i=0;value[i]!=0;i++)
printf(”%f=>%f/n”,value[i],ceil(value[i]));
}

执行 4.800000=>5.000000
1.120000=>2.000000
-2.200000=>-2.000000

　

cos（取余玄函数值）
相关函数 acos，asin，atan，atan2，sin，tan

表头文件 #include

定义函数 double cos(double x);

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

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

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

范例 #include main()
{
double answer = cos(0.5);
printf(”cos (0.5) = %f/n”,answer);
}

执行 cos(0.5) = 0.877583

　

cosh（取双曲线余玄函数值）
相关函数 sinh，tanh

表头文件 #include

定义函数 double cosh(double x);

函数说明 cosh()用来计算参数x的双曲线余玄值，然后将结果返回。数学定义式为:(exp(x)+exp(-x))/2。

返回值 返回参数x的双曲线余玄值。

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

范例 #include main()
{
double answer = cosh(0.5);
printf(”cosh(0.5) = %f/n”,answer);
}

执行 cosh(0.5) = 1.127626

　

exp（计算指数）
相关函数 log，log10，pow

表头文件 #include

定义函数 double exp(double x);

函数说明 exp()用来计算以e为底的x次方值，即ex值，然后将结果返回。

返回值 返回e的x次方计算结果。

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

范例 #include main()
{
double answer;
answer = exp (10);
printf(”e^10 =%f/n”, answer);
}

执行 e^10 = 22026.465795

　

frexp（将浮点型数分为底数与指数）
相关函数 ldexp，modf

表头文件 #include

定义函数 double frexp( double x, int *exp);

函数说明 frexp()用来将参数x 的浮点型数切割成底数和指数。底数部分直接返回，指数部分则借参数exp 指针返回，将返回值乘以2 的exp次方即为x的值。

返回值 返回参数x的底数部分，指数部分则存于exp指针所指的地址。

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

范例 #include main()
{
int exp;
double fraction;
fraction = frexp (1024,&exp);
printf(”exp = %d/n”,exp);
printf(”fraction = %f/n”, fraction);
}

执行 exp = 11
fraction = 0.500000 /* 0.5*(2^11)=1024*/

　

ldexp（计算2的次方值）
相关函数 frexp

表头文件 #include

定义函数 double ldexp(double x,int exp);

函数说明 ldexp()用来将参数x乘上2的exp次方值，即x*2exp。

返回值 返回计算结果。

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

范例: /* 计算3*(2^2)＝12 */
#include main()
{
int exp;
double x,answer;
answer = ldexp(3,2);
printf(”3*2^(2) = %f/n”,answer);
}

执行 3*2^(2) = 12.000000

　

log（计算以e 为底的对数值）
相关函数 exp，log10，pow

表头文件 #include

定义函数 double log (double x);

函数说明 log（）用来计算以e为底的x 对数值，然后将结果返回。

返回值 返回参数x的自然对数值。

错误代码 edom 参数x为负数，erange 参数x为零值，零的对数值无定义。

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

范例 #include main()
{
double answer;
answer = log (100);
printf(”log(100) = %f/n”,answer);
}

执行 log(100) = 4.605170

　

log10（计算以10 为底的对数值）
相关函数 exp，log，pow

表头文件 #include

定义函数 double log10(double x);

函数说明 log10()用来计算以10为底的x对数值，然后将结果返回。

返回值 返回参数x以10为底的对数值。

错误代码 edom参数x为负数。range参数x为零值，零的对数值无定义。

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

范例 #include main()
{
double answer;
answer = log10(100);
printf(”log10(100) = %f/n”,answer);
}

执行 log10(100) = 2.000000

　

pow（计算次方值）
相关函数 exp，log，log10

表头文件 #include

定义函数 double pow(double x,double y);

函数说明 pow()用来计算以x为底的y次方值，即xy值，然后将结果返回。

返回值 返回x的y次方计算结果。

错误代码 edom 参数x为负数且参数y不是整数。

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

范例 #include main()
{
double answer;
answer =pow(2,10);
printf(”2^10 = %f/n”, answer);
}

执行 2^10 = 1024.000000

　

sin（取正玄函数值）
相关函数 acos，asin，atan，atan2，cos，tan

表头文件 #include

定义函数 double sin(double x);

函数说明 sin（）用来计算参数x的正玄值，然后将结果返回。

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

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

范例 #include main()
{
double answer = sin (0.5);
printf(”sin(0.5) = %f/n”,answer);
}

执行 sin(0.5) = 0.479426

　

sinh（取双曲线正玄函数值）
相关函数 cosh，tanh

表头文件 #include

定义函数 double sinh( double x);

函数说明 sinh()用来计算参数x的双曲线正玄值，然后将结果返回。数学定义式为:(exp(x)-exp(-x))/2。

返回值 返回参数x的双曲线正玄值。

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

范例 #include main()
{
double answer = sinh (0.5);
printf(”sinh(0.5) = %f/n”,answer);
}

执行 sinh(0.5) = 0.521095

　

sqrt（计算平方根值）
相关函数 hypotq

表头文件 #include

定义函数 double sqrt(double x);

函数说明 sqrt()用来计算参数x的平方根，然后将结果返回。参数x必须为正数。

返回值 返回参数x的平方根值。

错误代码 edom 参数x为负数。

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

范例 /* 计算200的平方根值*/
#include main()
{
double root;
root = sqrt (200);
printf(”answer is %f/n”,root);
}

执行 answer is 14.142136

　

tan（取正切函数值）
相关函数 atan，atan2，cos，sin

表头文件 #include

定义函数 double tan(double x);

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

返回值 返回参数x的正切值。

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

范例 #include main()
{
double answer = tan(0.5);
printf(”tan (0.5) = %f/n”,answer);
}

执行 tan(0.5) = 0.546302

　

tanh（取双曲线正切函数值）
相关函数 cosh，sinh

表头文件 #include

定义函数 double tanh(double x);

函数说明 tanh()用来计算参数x的双曲线正切值，然后将结果返回。数学定义式为:sinh(x)/cosh(x)。

返回值 返回参数x的双曲线正切值。

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

范例 #include main()
{
double answer = tanh(0.5);
printf(”tanh(0.5) = %f/n”,answer);
}

执行 tanh(0.5) = 0.462117

　

　

endgrent（关闭组文件）
相关函数 getgrent，setgrent

表头文件 #include
#include

定义函数 void endgrent(void);

函数说明 endgrent()用来关闭由getgrent()所打开的密码文件。

返回值

附加说明

范例 请参考getgrent()与setgrent()。

　

endpwent（关闭密码文件）
相关函数 getpwent，setpwent

表头文件 #include
#include

定义函数 void endpwent(void);

函数说明 endpwent()用来关闭由getpwent()所打开的密码文件。

返回值

附加说明

范例 请参考getpwent()与setpwent()。

　

endutent（关闭utmp 文件）
相关函数 getutent，setutent

表头文件 #include

定义函数 void endutent(void);

函数说明 endutent()用来关闭由getutent所打开的utmp文件。

返回值

附加说明

范例 请参考getutent()。

　

fgetgrent（从指定的文件来读取组格式）
相关函数 fgetpwent

表头文件 #include
#include
#include

定义函数 struct group * getgrent(file * stream);

函数说明 fgetgrent()会从参数stream指定的文件读取一行数据，然后以group结构将该数据返回。参数stream所指定的文件必须和、etc/group相同的格式。group结构定义请参考getgrent()。

返回值 返回group结构数据，如果返回null则表示已无数据，或有错误发生。

范例 #include
#include
#include
main()
{
struct group *data;
file *stream;
int i;
stream = fopen(”/etc/group”, “r”);
while((data = fgetgrent(stream))!=0){
i=0;
printf(”%s :%s:%d :”, data->gr_name,data->gr_passwd,data->gr_gid);
while (data->gr_mem[i])printf(”%s,”,data->gr_mem[i++]);
printf(”/n”);
}
fclose(stream);
}

执行 root:x:0:root,
bin:x:1:root,bin,daemon
daemon:x:2:root,bin,daemon
sys:x:3:root,bin,adm
adm:x:4:root,adm,daemon
tty:x:5
disk:x:6:root
lp:x:7:daemon,lp
mem:x:8
kmem:x:9
wheel:x:10:root
mail:x:12:mail
news:x:13:news
uucp:x:14:uucp
man:x:15
games:x:20
gopher:x:30
dip:x:40:
ftp:x:50
nobody:x:99:

　

fgetpwent（从指定的文件来读取密码格式）
相关函数 fgetgrent

表头文件 #include
#include
#include

定义函数 struct passwd * fgetpwent(file *stream);

函数说明 fgetpwent()会从参数stream指定的文件读取一行数据，然后以passwd结构将该数据返回。参数stream所指定的文件必须和/etc/passwd相同的格式。passwd结构定义请参考getpwent()。

返回值 返回passwd结构数据，如果返回null则表示已无数据，或有错误发生。

范例 #include
#include
main()
{
struct passwd *user;
file *stream;
stream = fopen(”/etc/passwd”, “r”);
while((user = fgetpwent(stream))!=0){
printf(”%s:%d:%d:%s:%s:%s/n”,user->pw_name,user->pw_uid,user->pw_gid,user->pw_gecos,user->pw_dir,user->pw_shell);
}
}

执行 root:0:0:root:/root:/bin/bash
bin:1:1:bin:/bin:
daemon:2:2:daemon:/sbin:
adm:3:4:adm:/var/adm:
lp:4:7:lp:/var/spool/lpd:
sync:5:0:sync:/sbin:/bin/sync
shutdown:6:0:shutdown:/sbin:/sbin/shutdown
halt:7:0:halt:/sbin:/sbin/halt
mail:8:12:mail:/var/spool/mail:
news:9:13:news:var/spool/news
uucp:10:14:uucp:/var/spool/uucp:
operator:11:0:operator :/root:
games:12:100:games:/usr/games:
gopher:13:30:gopher:/usr/lib/gopher-data:
ftp:14:50:ftp user:/home/ftp:
nobody:99:99:nobody:/:
xfs:100:101:x font server: /etc/xll/fs:/bin/false
gdm:42:42:/home/gdm:/bin/bash
kids:500:500: : /home/kids:/bin/bash

　

getegid（取得有效的组识别码）
相关函数 getgid，setgid，setregid

表头文件 #include
#include

定义函数 gid_t getegid(void);

函数说明 getegid()用来取得执行目前进程有效组识别码。有效的组识别码用来决定进程执行时组的权限。返回值返回有效的组识别码。

范例 main()
{
printf(”egid is %d/n”,getegid());
}

执行 egid is 0 /*当使用root身份执行范例程序时*/

　

geteuid（取得有效的用户识别码）
相关函数 getuid，setreuid，setuid

表头文件 #include
#include

定义函数 uid_t geteuid(void)

函数说明 geteuid()用来取得执行目前进程有效的用户识别码。有效的用户识别码用来决定进程执行的权限，借由此改变此值，进程可以获得额外的权限。倘若执行文件的setid位已被设置，该文件执行时，其进程的euid值便会设成该文件所有者的uid。例如，执行文件/usr/bin/passwd的权限为-r-s–x–x，其s 位即为setid(suid)位，而当任何用户在执行passwd 时其有效的用户识别码会被设成passwd 所有者的uid 值，即root的uid 值(0)。

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

范例 main()
{
printf (”euid is %d /n”,geteuid());
}

执行 euid is 0 /*当使用root身份执行范例程序时*/

　

getgid（取得真实的组识别码）
相关函数 getegid，setregid，setgid

表头文件 #include
#include

定义函数 gid_t getgid(void);

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

返回值 返回组识别码

范例 main()
{
printf(“gid is %d/n”,getgid());
}

执行 gid is 0 /*当使用root身份执行范例程序时*/

　

getgrent（从组文件中取得账号的数据）
相关函数 setgrent，endgrent

表头文件 #include
#include

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

函数说明 getgrent()用来从组文件(/etc/group)中读取一项组数据，该数据以group 结构返回。第一次调用时会取得第一项组数据，之后每调用一次就会返回下一项数据，直到已无任何数据时返回null。
struct group{
char *gr_name; /*组名称*/
char *gr_passwd; /* 组密码*/
gid_t gr_gid; /*组识别码*/
char **gr_mem; /*组成员账号*/
}

返回值 返回group结构数据，如果返回null则表示已无数据，或有错误发生。

附加说明 getgrent()在第一次调用时会打开组文件，读取数据完毕后可使用endgrent()来关闭该组文件。

错误代码 enomem 内存不足，无法配置group结构。

范例 #include
#include
main()
{
struct group *data;
int i;
while((data= getgrent())!=0){
i=0;
printf(“%s:%s:%d:”,data->gr_name,data->gr_passwd,data->gr_gid);
while(data->gr_mem[i])printf(“%s,”,data->gr_mem[i++]);
printf(“/n”);
}
endgrent();
}

执行 root:x:0:root,
bin:x:1:root,bin,daemon,
daemon:x:2:root,bin,daemon,
sys:x:3:root,bin,adm,
adm:x:4:root,adm,daemon
tty:x:5
disk:x:6:root
lp:x:7:daemon,lp
mem:x:8
kmem:x:9:
wheel:x:10:root
mail:x:12:mail
news:x:13:news
uucp:x:14:uucp
man:x:15:
games:x:20
gopher:x:30
dip:x:40
ftp:x:50
nobody:x:99

　

getgrgid（从组文件中取得指定gid 的数据）
相关函数 fgetgrent，getgrent，getgrnam

表头文件 #include
#include

定义函数 strcut group * getgrgid(gid_t gid);

函数说明 getgrgid（）用来依参数gid指定的组识别码逐一搜索组文件，找到时便将该组的数据以group结构返回。group结构请参考getgrent（）。

返回值 返回group结构数据，如果返回null则表示已无数据，或有错误发生。

范例 /* 取得gid＝3的组数据*/
#include
#include
main()
{
strcut group *data;
int i=0;
data = getgrgid(3);
printf(“%s:%s:%d:”,data->gr_name,data->gr_passwd,data->gr_gid);
while(data->gr_mem[i])printf(“%s ,”,data->mem[i++]);
printf(“/n”);
}

执行 sys:x:3:root,bin,adm

　

getgrnam（从组文件中取得指定组的数据）
相关函数 fgetgrent，getrent，getgruid

表头文件 #include
#include

定义函数 strcut group * getgrnam(const char * name);

函数说明 getgrnam（）用来逐一搜索参数那么指定的组名称，找到时便将该组的数据以group结构返回。group 结构请参考getgrent（）。

返回值 返回group结构数据，如果返回null则表示已无数据，或有错误发生。

范例 /* 取得adm的组数据*/
#include
#include
main()
{
strcut group * data;
int i=0;
data = getgrnam(“adm”);
printf(“%s:%s:%d:”,data->gr_name,data->gr_passwd,data->gr_gid);
while(data->gr_mem[i])printf(“%s,”,data->gr_mem[i++]);
printf(“/n”);
}

执行 adm:x:4:root,adm,daemon

　

getgroups（取得组代码）
相关函数 initgroups，setgroup，getgid，setgid

表头文件 #include
#include

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

函数说明 getgroup（）用来取得目前用户所属的组代码。参数size为list〔〕所能容纳的gid_t 数目。如果参数size 值为零，此函数仅会返回用户所属的组数。

返回值 返回组识别码，如有错误则返回-1。

错误代码 efault 参数list数组地址不合法。einval 参数size值不足以容纳所有的组。

范例 #include
#include
main()
{
gid_t list[500];
int x,i;
x = getgroups(0.list);
getgroups(x,list);
for(i=0;i printf(“%d:%d/n”,i,list[i]);
}

执行 0:00
1:01
2:02
3:03
4:04
5:06
6:10

　

getpw（取得指定用户的密码文件数据）
相关函数 getpwent

表头文件 #include
#include

定义函数 int getpw(uid_t uid,char *buf);

函数说明 getpw()会从/etc/passwd中查找符合参数uid所指定的用户账号数据，找不到相关数据就返回-1。所返回的buf字符串格式如下:账号:密码:用户识别码(uid):组识别码(gid):全名:根目录:shell

返回值 返回0表示成功，有错误发生时返回-1。

附加说明 1. getpw()会有潜在的安全性问题，请尽量使用别的函数取代。
2. 使用shadow的系统已把用户密码抽出/etc/passwd，因此使用getpw()取得的密码将为“x”。

范例 #include
#include
main()
{
char buffer[80];
getpw(0,buffer);
printf(“%s/n”,buffer);
}

执行 root:x:0:0:root:/root:/bin/bash

　

getpwent（从密码文件中取得账号的数据）
相关函数 getpw，fgetpwent，getpwnam，getpwuid，setpwent，endpwent

表头文件 #include
#include

定义函数 strcut passwd * getpwent(void);

函数说明 getpwent（）用来从密码文件（/etc/passwd）中读取一项用户数据，该用户的数据以passwd 结构返回。第一次调用时会取得第一位用户数据，之后每调用一次就会返回下一项数据，直到已无任何数据时返回null。
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路径*/
};

返回值 返回passwd 结构数据，如果返回null 则表示已无数据，或有错误发生。

附加说明 getpwent()在第一次调用时会打开密码文件，读取数据完毕后可使用endpwent()来关闭该密码文件。错误代码enomem 内存不足，无法配置passwd结构。

范例 #include
#include
main()
{
struct passwd *user;
while((user = getpwent())!=0){
printf(“%s:%d:%d:%s:%s:%s/n”,user->pw_name,user->pw_uid,user->pw_gid,
user->pw_gecos,user->pw_dir,user->pw_shell);
}
endpwent();
}

执行 root:0:0:root:/root:/bin/bash
bin:1:1:bin:/bin:
daemon:2:2:daemon:/sbin:
adm:3:4:adm:/var/adm:
lp:4:7:lp:/var/spool/lpd:
sync:5:0:sync:/sbin:/bin/sync
shutdown:6:0:shutdown:/sbin:/sbin/shutdown
halt:7:0:halt:/sbin:/sbin/halt
mail:8:12:mail:/var/spool/mail:
news:9:13:news:var/spool/news
uucp:10:14:uucp:/var/spool/uucp:
operator:11:0:operator :/root:
games:12:100:games:/usr/games:
gopher:13:30:gopher:/usr/lib/gopher-data:
ftp:14:50:ftp user:/home/ftp:
nobody:99:99:nobody:/:
xfs:100:101:x font server: /etc/xll/fs:/bin/false
gdm:42:42:/home/gdm:/bin/bash
kids:500:500: : /home/kids:/bin/bash

　

getpwnam（从密码文件中取得指定账号的数据）
相关函数 getpw，fgetpwent，getpwent，getpwuid

表头文件 #include
#include

定义函数 struct passwd * getpwnam(const char * name);

函数说明 getpwnam()用来逐一搜索参数name 指定的账号名称，找到时便将该用户的数据以passwd结构返回。passwd结构请参考getpwent()。

返回值 返回passwd 结构数据，如果返回null 则表示已无数据，或有错误发生。

范例 /*取得root账号的识别码和根目录*/
#include
#include
main()
{
struct passwd *user;
user = getpwnam(“root”);
printf(“name:%s/n”,user->pw_name);
printf(“uid:%d/n”,user->pw_uid);
printf(“home:%s/n”,user->pw_dir);
}

执行 name:root
uid:0
home:/root

　

getpwuid（从密码文件中取得指定uid 的数据）
相关函数 getpw，fgetpwent，getpwent，getpwnam

表头文件 #include
#include

定义函数 struct passwd * getpwuid(uid_t uid);

函数说明 getpwuid()用来逐一搜索参数uid 指定的用户识别码，找到时便将该用户的数据以结构返回结构请参考将该用户的数据以passwd 结构返回。passwd 结构请参考getpwent()。

返回值 返回passwd 结构数据，如果返回null 则表示已无数据，或者有错误发生。

范例 #include
#include
main()
{
struct passwd *user;
user= getpwuid(6);
printf(“name:%s/n”,user->pw_name);
printf(“uid:%d/n”,user->pw_uid);
printf(“home:%s/n”,user->pw_dir);
}

执行 name:shutdown
uid:6
home:/sbin

　

getuid（取得真实的用户识别码）
相关函数 geteuid，setreuid，setuid

表头文件 #include
#include

定义函数 uid_t getuid(void);

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

返回值 用户识别码

范例 main()
{
printf(“uid is %d/n”,getuid());
}

执行 uid is 0 /*当使用root身份执行范例程序时*/

　

getutent（从utmp 文件中取得账号登录数据）
相关函数 getutent，getutid，getutline，setutent，endutent，pututline，utmpname

表头文件 #include

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

函数说明 getutent()用来从utmp 文件(/var/run/utmp)中读取一项登录数据，该数据以utmp 结构返回。第一次调用时会取得第一位用户数据，之后每调用一次就会返回下一项数据，直到已无任何数据时返回null。
utmp结构定义如下
struct utmp
{
short int ut_type; /*登录类型*/
pid_t ut_pid; /*login进程的pid*/
char ut_line[ut_linesize];/*登录装置名，省略了“/dev/”*/
char ut_id[4]; /* inittab id*/
char ut_user[ut_namesize];/*登录账号*/
char ut_host[ut_hostsize];/*登录账号的远程主机名称*/
struxt exit_status ut_exit;/* 当类型为dead_process时进程的结
束状态*/
long int ut_session; /*sessioc id*/
struct timeval ut_tv; /*时间记录*/
int32_t ut_addr_v6[4]; /*远程主机的网络地址*/
char __unused[20]; /* 保留未使用*/
};
ut_type有以下几种类型:
empty 此为空的记录。
run_lvl 记录系统run－level的改变
boot_time 记录系统开机时间
new_time 记录系统时间改变后的时间
old_tine 记录当改变系统时间时的时间。
init_process 记录一个由init衍生出来的进程。
login_process 记录login进程。
user_process 记录一般进程。
dead_process 记录一结束的进程。
accounting 目前尚未使用。
exit_status结构定义
struct exit_status
{
short int e_termination; /*进程结束状态*/
short int e_exit; /*进程退出状态*/
};
timeval的结构定义请参考gettimeofday（）。
相关常数定义如下:
ut_linesize 32
ut_namesize 32
ut_hostsize 256

返回值 返回utmp 结构数据，如果返回null 则表示已无数据，或有错误发生。

附加说明 getutent()在第一次调用时会打开utmp 文件，读取数据完毕后可使用endutent()来关闭该utmp文件。

范例 #include
main()
{
struct utmp *u;
while((u=getutent())){
if(u->ut_type = = user_process)
printf(“%d %s %s %s /n”,u->ut_type,u->ut_user,u->ut_line,u->ut_host);
}
endutent();
}

执行 /* 表示有三个root账号分别登录/dev/pts/0，/dev/pts/1，/dev/pts/2 */
7 root pts/0
7 root pts/1
7 root pts/2

　

getutid（从utmp 文件中查找特定的记录）
相关函数 getutent，getutline

表头文件 #include

定义函数 strcut utmp *getutid(strcut utmp *ut);

函数说明 getutid()用来从目前utmp 文件的读写位置逐一往后搜索参数ut指定的记录，如果ut->ut_type 为run_lvl，boot_time，new_time，old_time 其中之一则查找与ut->ut_type 相符的记录；若ut->ut_type 为init_process，login_process，user_process或dead_process其中之一，则查找与ut->ut_id相符的记录。找到相符的记录便将该数据以utmp 结构返回。utmp结构请参考getutent()。

返回值 返回utmp 结构数据，如果返回null 则表示已无数据，或有错误发生。

范例 #include
main()
{
struct utmp ut,*u;
ut.ut_type=run_lvl;
while((u= getutid(&ut))){
printf(“%d %s %s %s/n”,u->ut_type,u->ut_user,u->ut_line,u->ut_host);
}
}

执行 1 runlevel -

　

getutline（从utmp 文件中查找特定的记录）
相关函数 getutent，getutid，pututline

表头文件 #include

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

函数说明 getutline()用来从目前utmp文件的读写位置逐一往后搜索ut_type为user_process 或login_process 的记录，而且ut_line 和ut->ut_line 相符。找到相符的记录便将该数据以utmp 结构返回，utmp结构请参考getutent()。

返回值 返回utmp 结构数据，如果返回null 则表示已无数据，或有错误发生。

范例 #include
main()
{
struct utmp ut,*u;
strcpy (ut.ut_line,”pts/1”);
while ((u=getutline(&ut))){
printf(“%d %s %s %s /n”,u->ut_type,u->ut_user,u->ut_line,u->ut_host);
}
}

执行 7 root pts/1

　

initgroups（初始化组清单）
相关函数 setgrent，endgrent

表头文件 #include
#include

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

函数说明 initgroups（）用来从组文件（/etc/group）中读取一项组数据，若该组数据的成员中有参数user时，便将参数group组识别码加入到此数据中。

返回值 执行成功则返回0，失败则返回-1，错误码存于errno。

　

pututline（将utmp 记录写入文件）
相关函数 getutent，getutid，getutline

表头文件 #include

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

函数说明 pututline()用来将参数ut的utmp结构记录到utmp文件中。此函数会先用getutid()来取得正确的写入位置，如果没有找到相符的记录则会加入到utmp文件尾，utmp结构请参考getutent()。

返回值

附加说明 需要有写入/var/run/utmp 的权限

范例 #include
main()
{
struct utmp ut;
ut.ut_type =user_process;
ut.ut_pid=getpid();
strcpy(ut.ut_user,”kids”);
strcpy(ut.ut_line,”pts/1”);
strcpy(ut.ut_host,”www.gnu.org”);
pututline(&ut);
}

执行 /*执行范例后用指令who -l 观察*/
root pts/0 dec9 19:20
kids pts/1 dec12 10:31(www.gnu.org)
root pts/2 dec12 13:33

　

seteuid（设置有效的用户识别码）
相关函数 setuid，setreuid，setfsuid

表头文件 #include

定义函数 int seteuid(uid_t euid);

函数说明 seteuid()用来重新设置执行目前进程的有效用户识别码。在linux下，seteuid(euid)相当于setreuid(-1,euid)。

返回值 执行成功则返回0，失败则返回-1，错误代码存于errno

附加说明 请参考setuid

　

setfsgid（设置文件系统的组识别码）
相关函数 setuid，setreuid，seteuid，setfsuid

表头文件 #include

定义函数 int setfsgid(uid_t fsgid);

函数说明 setfsgid()用来重新设置目前进程的文件系统的组识别码。一般情况下，文件系统的组识别码(fsgid)与有效的组识别码(egid)是相同的。如果是超级用户调用此函数，参数fsgid 可以为任何值，否则参数fsgid必须为real/effective/saved的组识别码之一。

返回值 执行成功则返回0，失败则返回-1，错误代码存于errno。

附加说明 此函数为linux特有。

错误代码 eperm 权限不够，无法完成设置。

　

setfsuid（设置文件系统的用户识别码）
相关函数 setuid，setreuid，seteuid，setfsgid

表头文件 #include

定义函数 int setfsuid(uid_t fsuid);

函数说明 setfsuid()用来重新设置目前进程的文件系统的用户识别码。一般情况下，文件系统的用户识别码(fsuid)与有效的用户识别码(euid)是相同的。如果是超级用户调用此函数，参数fsuid可以为任何值，否则参数fsuid必须为real/effective/saved的用户识别码之一。

返回值 执行成功则返回0，失败则返回-1，错误代码存于errno

附加说明 此函数为linux特有

错误代码 eperm 权限不够，无法完成设置。

　

setgid（设置真实的组识别码）
相关函数 getgid，setregid，getegid，setegid

表头文件 #include

定义函数 int setgid(gid_t gid);

函数说明 setgid()用来将目前进程的真实组识别码(real gid)设成参数gid值。如果是以超级用户身份执行此调用，则real、effective与savedgid都会设成参数gid。

返回值 设置成功则返回0，失败则返回-1，错误代码存于errno中。

错误代码 eperm 并非以超级用户身份调用，而且参数gid 并非进程的effective gid或saved gid值之一。

　

setgrent（从头读取组文件中的组数据）
相关函数 getgrent，endgrent

表头文件 #include
#include

定义函数 void setgrent(void);

函数说明 setgrent()用来将getgrent()的读写地址指回组文件开头。

返回值

附加说明 请参考setpwent()。

　

setgroups（设置组代码）
相关函数 initgroups，getgroup，getgid，setgid

表头文件 #include

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

函数说明 setgroups()用来将list 数组中所标明的组加入到目前进程的组设置中。参数size为list()的gid_t数目，最大值为ngroup(32)。

返回值 设置成功则返回0，如有错误则返回-1。

错误代码 efault 参数list数组地址不合法。
eperm 权限不足，必须是root权限
einval 参数size值大于ngroup(32)。

　

setpwent（从头读取密码文件中的账号数据）
相关函数 getpwent，endpwent

表头文件 #include
#include

定义函数 void setpwent(void);

函数说明 setpwent()用来将getpwent()的读写地址指回密码文件开头。

返回值

范例 #include
#include
main()
{
struct passwd *user;
int i;
for(i=0;i<4;i++){
user=getpwent();
printf(“%s :%d :%d :%s:%s:%s/n”,user->pw_name,user->pw_uid,user->pw_gid,
user->pw_gecos,user->pw_dir,user->pw_shell);
}
setpwent();
user=getpwent();
printf(“%s :%d :%d :%s:%s:%s/n”,user->pw_name,user->pw_uid,user->pw_gid,
user->pw_gecos,user->pw_dir,user->pw_shell);
endpwent();
}

执行 root:0:0:root:/root:/bin/bash
bin:1:1:bin:/bin
daemon:2:2:daemon:/sbin
adm:3:4:adm:/var/adm
root:0:0:root:/root:/bin/bash

　

setregid（设置真实及有效的组识别码）
相关函数 setgid，setegid，setfsgid

表头文件 #include

定义函数 int setregid(gid_t rgid,gid_t egid);

函数说明 setregid()用来将参数rgid设为目前进程的真实组识别码，将参数egid设置为目前进程的有效组识别码。如果参数rgid或egid值为-1，则对应的识别码不会改变。

返回值 执行成功则返回0，失败则返回-1，错误代码存于errno。

　

setreuid（设置真实及有效的用户识别码）
相关函数 setuid，seteuid，setfsuid

表头文件 #include

定义函数 int setreuid(uid_t ruid,uid_t euid);

函数说明 setreuid()用来将参数ruid 设为目前进程的真实用户识别码，将参数euid 设置为目前进程的有效用户识别码。如果参数ruid 或euid值为-1，则对应的识别码不会改变。

返回值 执行成功则返回0，失败则返回-1，错误代码存于errno。

附加说明 请参考setuid（）。

　

setuid（设置真实的用户识别码）
相关函数 getuid，setreuid，seteuid，setfsuid

表头文件 #include

定义函数 int setuid(uid_t uid)

函数说明 setuid()用来重新设置执行目前进程的用户识别码。不过，要让此函数有作用，其有效的用户识别码必须为0(root)。在linux下，当root使用setuid()来变换成其他用户识别码时，root权限会被抛弃，完全转换成该用户身份，也就是说，该进程往后将不再具有可setuid()的权利，如果只是向暂时抛弃root 权限，稍后想重新取回权限，则必须使用seteuid()。

返回值 执行成功则返回0，失败则返回-1，错误代码存于errno。

附加说明 一般在编写具setuid root的程序时，为减少此类程序带来的系统安全风险，在使用完root权限后建议马上执行setuid(getuid());来抛弃root权限。此外，进程uid和euid不一致时linux系统将不会产生core dump。

　

setutent（从头读取utmp 文件中的登录数据）
相关函数 getutent，endutent

表头文件 #include

定义函数 void setutent(void);

函数说明 setutent()用来将getutent()的读写地址指回utmp文件开头。

附加说明 请参考setpwent()或setgrent()。

　

utmpname（设置utmp 文件路径）
相关函数 getutent，getutid，getutline，setutent，endutent，pututline

表头文件 #include

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

函数说明 utmpname()用来设置utmp文件的路径，以提供utmp相关函数的存取路径。如果没有使用utmpname()则默认utmp文件路径为/var/run/utmp。

返回值

　

　

crypt（将密码或数据编码）
相关函数 getpass

表头文件 #define _xopen_source
#include

定义函数 char * crypt (const char *key,const char * salt);

函数说明 crypt()将使用data encryption standard(des)演算法将参数key所指的字符串加以编码，key字符串长度仅取前8个字符，超过此长度的字符没有意义。参数salt为两个字符组成的字符串，由a-z、a-z、0-9，“.”和“/”所组成，用来决定使用4096 种不同内建表格的哪一个。函数执行成功后会返回指向编码过的字符串指针，参数key 所指的字符串不会有所更动。编码过的字符串长度为13 个字符，前两个字符为参数salt代表的字符串。

返回值 返回一个指向以null结尾的密码字符串。

附加说明 使用gcc编译时需加-lcrypt。

范例 #include
main()
{
char passwd[13];
char *key;
char slat[2];
key= getpass(“input first password:”);
slat[0]=key[0];
slat[1]=key[1];
strcpy(passwd,crypt(key slat));
key=getpass(“input second password:”);
slat[0]=passwd[0];
slat[1]=passwd[1];
printf(“after crypt(),1st passwd :%s/n”,passwd);
printf(“after crypt(),2nd passwd:%s /n”,crypt(key slat));
}

执行 input first password: /* 输入test，编码后存于passwd[ ] */
input second password /*输入test，密码相同编码后也会相同*/
after crypt () 1st passwd : teh0wlipw0gyq
after crypt () 2nd passwd : teh0wlipw0gyq

　

bsearch（二元搜索）
相关函数 qsort

表头文件 #include

定义函数 void *bsearch(const void *key,const void *base,size_t nmemb,size_tsize,int (*compar) (const void*,const void*));

函数说明 bsearch()利用二元搜索从排序好的数组中查找数据。参数key指向欲查找的关键数据，参数base指向要被搜索的数组开头地址，参数nmemb 代表数组中的元素数量，每一元素的大小则由参数size决定，最后一项参数compar 为一函数指针，这个函数用来判断两个元素之间的大小关系，若传给compar 的第一个参数所指的元素数据大于第二个参数所指的元素数据则必须回传大于0 的值，两个元素数据相等则回传0。

附加说明 找到关键数据则返回找到的地址，如果在数组中找不到关键数据则返回null。

范例 #include
#include
#define nmemb 5
#define size 10
int compar(const void *a,const void *b)
{
return (strcmp((char *)a,(char *)b));
}
main()
{
char data[50][size]={“linux”,”freebsd”,”solaris”,”sunos”,”windows”};
char key[80],*base ,*offset;
int i, nmemb=nmemb,size=size;
while(1){
printf(“>”);
fgets(key,sizeof(key),stdin);
key[strlen(key)-1]=’/0’;
if(!strcmp(key,”exit”))break;
if(!strcmp(key,”list”)){
for(i=0;i printf(“%s/n”,data[i]);
continue;
}
base = data[0];
qsort(base,nmemb,size,compar);
offset = (char *) bsearch(key,base,nmemb,size,compar);
if( offset = =null){
printf(“%s not found!/n”,key);
strcpy(data[nmemb++],key);
printf(“add %s to data array/n”,key);
}else{
printf(“found: %s /n”,offset);
}
}
}

执行 >hello /*输入hello字符串*/
hello not found! /*找不到hello 字符串*/
add hello to data array /*将hello字符串加入*/
>.list /*列出所有数据*/
freebsd
linux
solaris
sunos
windows
hello
>hello
found: hello

　

lfind（线性搜索）
相关函数 lsearch

表头文件 #include

定义函数 void *lfind (const void *key,const void *base,size_t *nmemb,size_t
size,int(* compar) (const void * ,const void *));

函数说明 lfind()利用线性搜索在数组中从头至尾一项项查找数据。参数key指向欲查找的关键数据，参数base指向要被搜索的数组开头地址，参数nmemb代表数组中的元素数量，每一元素的大小则由参数size决定，最后一项参数compar为一函数指针，这个函数用来判断两个元素是否相同，若传给compar 的异地个参数所指的元素数据和第二个参数所指的元素数据相同时则返回0，两个元素数据不相同则返回非0值。lfind()与lsearch()不同点在于，当找不到关键数据时lfind()仅会返回null，而不会主动把该笔数据加入数组尾端。

返回值 找到关键数据则返回找到的该笔元素的地址，如果在数组中找不到关键数据则返回空指针(null)。

范例 参考lsearch()。

　

lsearch（线性搜索）
相关函数 lfind

表头文件 #include

定义函数 void *lsearch(const void * key ,const void * base ,size_t * nmemb,size_t size, int ( * compar) (const void * ,const void *));

函数说明 lsearch()利用线性搜索在数组中从头至尾一项项查找数据。参数key指向欲查找的关键数据，参数base指向要被搜索的数组开头地址，参数nmemb 代表数组中的元素数量，每一元素的大小则由参数size 决定，最后一项参数compar 为一函数指针，这个函数用来判断两个元素是否相同，若传给compar 的第一个参数所指的元素数据和第二个参数所指的元素数据相同时则返回0，两个元素数据不相同则返回非0 值。如果lsearch（）找不到关键数据时会主动把该项数据加入数组里。

返回值 找到关键数据则返回找到的该笔元素的四肢，如果在数组中找不到关键数据则将此关键数据加入数组，再把加入数组后的地址返回。

范例 #include
#include
#define nmemb 50
#define size 10
int compar (comst void *a,const void *b)
{
return (strcmp((char *) a, (char *) b));
}
main()
{
char data[nmemb][size]={“linux”,”freebsd”,”solzris”,”sunos”,”windows”};
char key[80],*base,*offset;
int i, nmemb=nmemb,size=size;
for(i=1;i<5;i++){
fgets(key,sizeof9key),stdin);
key[strlen(key)-1]=’/0’;
base = data[0];
offset = (char *)lfind(key,base,&nmemb,size,compar);
if(offset ==null){
printf(“%s not found!/n”,key);
offset=(char *) lsearch(key,base,&nmemb,size,compar);
printf(“add %s to data array/n”,offset);
}else{
printf(“found : %s /n”,offset);
}
}
}

执行 linux
found:linux
os/2
os/2 not found!
add os/2 to data array
os/2
found:os/2

　

qsort（利用快速排序法排列数组）
相关函数 bsearch

表头文件 #include

定义函数 void qsort(void * base,size_t nmemb,size_t size,int ( * compar)(const void *, const void *));

函数说明 参数base指向欲排序的数组开头地址，参数nmemb代表数组中的元素数量，每一元素的大小则由参数size决定，最后一项参数compar为一函数指针，这个函数用来判断两个元素间的大小关系，若传给compar的第一个参数所指的元素数据大于第二个参数所指的元素数据则必须回传大于零的值，两个元素数据相等则回传0。

返回值

附加说明

范例 #define nmemb 7
#include
int compar (const void *a ,const void *b)
{
int *aa=(int * ) a,*bb = (int * )b;
if( * aa >* bb)return 1;
if( * aa == * bb) return 0;
if( * aa < *bb) return -1;
}
main( )
{
int base[nmemb]={ 3,102,5,-2,98,52,18};
int i;
for ( i=0; i printf(“%d “,base[i]);
printf(“/n”);
qsort(base,nmemb,sizeof(int),compar);
for(i=0;i printf(“%d”base[i]);
printf(“/n”);
}

执行 3 102 5 -2 98 52 18
-2 3 5 18 52 98 102

　

rand（产生随机数）
相关函数 srand，random，srandom

表头文件 #include

定义函数 int rand(void)

函数说明 rand()会返回一随机数值，范围在0至rand_max 间。在调用此函数产生随机数前，必须先利用srand()设好随机数种子，如果未设随机数种子，rand()在调用时会自动设随机数种子为1。关于随机数种子请参考srand()。

返回值 返回0至rand_max之间的随机数值，rand_max定义在stdlib.h，其值为2147483647。

范例 /* 产生介于1 到10 间的随机数值，此范例未设随机数种子，完整的随机数产生请参考
srand（）*/
#include
main()
{
int i,j;
for(i=0;i<10;i++)
{
j=1+(int)(10.0*rand()/(rand_max+1.0));
printf(“%d “,j);
}
}

执行 9 4 8 8 10 2 4 8 3 6
9 4 8 8 10 2 4 8 3 6

　

srand（设置随机数种子）
相关函数 rand，random srandom

表头文件 #include

定义函数 void srand (unsigned int seed);

函数说明 srand()用来设置rand()产生随机数时的随机数种子。参数seed必须是个整数，通常可以利用geypid()或time(0)的返回值来当做seed。如果每次seed都设相同值，rand()所产生的随机数值每次就会一样。

返回值

范例 /* 产生介于1 到10 间的随机数值，此范例与执行结果可与rand（）参照*/
#include
#include
main()
{
int i,j;
srand((int)time(0));
for(i=0;i<10;i++)
{
j=1+(int)(10.0*rand()/(rand_max+1.0));
printf(“ %d “,j);
}
}

执行 5 8 8 8 10 2 10 8 9 9
2 9 7 4 10 3 2 10 8 7

　

　

close（关闭文件）
相关函数 open，fcntl，shutdown，unlink，fclose

表头文件 #include

定义函数 int close(int fd);

函数说明 当使用完文件后若已不再需要则可使用close()关闭该文件，二close()会让数据写回磁盘，并释放该文件所占用的资源。参数fd为先前由open()或creat()所返回的文件描述词。

返回值 若文件顺利关闭则返回0，发生错误时返回-1。

错误代码 ebadf 参数fd 非有效的文件描述词或该文件已关闭。

附加说明 虽然在进程结束时，系统会自动关闭已打开的文件，但仍建议自行关闭文件，并确实检查返回值。

范例 参考open()

　

creat（建立文件）
相关函数 read，write，fcntl，close，link，stat，umask，unlink，fopen

表头文件 #include
#include
#include

定义函数 int creat(const char * pathname, mode_tmode);

函数说明 参数pathname指向欲建立的文件路径字符串。creat()相当于使用下列的调用方式调用open()
open(const char * pathname ,(o_creat|o_wronly|o_trunc));

错误代码 关于参数mode请参考open（）函数。

返回值 creat()会返回新的文件描述词，若有错误发生则会返回-1，并把错误代码设给errno。
eexist 参数pathname所指的文件已存在。
eaccess 参数pathname 所指定的文件不符合所要求测试的权限
erofs 欲打开写入权限的文件存在于只读文件系统内
efault 参数pathname 指针超出可存取的内存空间
einval 参数mode 不正确。
enametoolong 参数pathname太长。
enotdir 参数pathname为一目录
enomem 核心内存不足
eloop 参数pathname有过多符号连接问题。
emfile 已达到进程可同时打开的文件数上限
enfile 已达到系统可同时打开的文件数上限

附加说明 creat()无法建立特别的装置文件，如果需要请使用mknod()。

范例 请参考open()。

　

dup（复制文件描述词）
相关函数 open，close，fcntl，dup2

表头文件 #include

定义函数 int dup (int oldfd);

函数说明 dup()用来复制参数oldfd所指的文件描述词，并将它返回。此新的文件描述词和参数oldfd指的是同一个文件，共享所有的锁定、读写位置和各项权限或旗标。例如，当利用lseek()对某个文件描述词作用时，另一个文件描述词的读写位置也会随着改变。不过，文件描述词之间并不共享close-on-exec旗标。

返回值 当复制成功时，则返回最小及尚未使用的文件描述词。若有错误则返回-1，errno会存放错误代码。错误代码ebadf参数fd非有效的文件描述词，或该文件已关闭。

　

dup2（复制文件描述词）
相关函数 open，close，fcntl，dup

表头文件 #include

定义函数 int dup2(int odlfd,int newfd);

函数说明 dup2()用来复制参数oldfd所指的文件描述词，并将它拷贝至参数newfd后一块返回。若参数newfd为一已打开的文件描述词，则newfd所指的文件会先被关闭。dup2()所复制的文件描述词，与原来的文件描述词共享各种文件状态，详情可参考dup()。

返回值 当复制成功时，则返回最小及尚未使用的文件描述词。若有错误则返回-1，errno会存放错误代码。

附加说明 dup2()相当于调用fcntl(oldfd，f_dupfd，newfd)；请参考fcntl()。

错误代码 ebadf 参数fd 非有效的文件描述词，或该文件已关闭

　

fcntl（文件描述词操作）
相关函数 open，flock

表头文件 #include
#include

定义函数 int fcntl(int fd , int cmd);
int fcntl(int fd,int cmd,long arg);
int fcntl(int fd,int cmd,struct flock * lock);

函数说明 fcntl()用来操作文件描述词的一些特性。参数fd代表欲设置的文件描述词，参数cmd代表欲操作的指令。
有以下几种情况:
f_dupfd用来查找大于或等于参数arg的最小且仍未使用的文件描述词，并且复制参数fd的文件描述词。执行成功则返回新复制的文件描述词。请参考dup2()。f_getfd取得close-on-exec旗标。若此旗标的fd_cloexec位为0，代表在调用exec()相关函数时文件将不会关闭。
f_setfd 设置close-on-exec 旗标。该旗标以参数arg 的fd_cloexec位决定。
f_getfl 取得文件描述词状态旗标，此旗标为open（）的参数flags。
f_setfl 设置文件描述词状态旗标，参数arg为新旗标，但只允许o_append、o_nonblock和o_async位的改变，其他位的改变将不受影响。
f_getlk 取得文件锁定的状态。
f_setlk 设置文件锁定的状态。此时flcok 结构的l_type 值必须是f_rdlck、f_wrlck或f_unlck。如果无法建立锁定，则返回-1，错误代码为eacces 或eagain。
f_setlkw f_setlk 作用相同，但是无法建立锁定时，此调用会一直等到锁定动作成功为止。若在等待锁定的过程中被信号中断时，会立即返回-1，错误代码为eintr。参数lock指针为flock 结构指针，定义如下
struct flcok
{
short int l_type; /* 锁定的状态*/
short int l_whence;/*决定l_start位置*/
off_t l_start; /*锁定区域的开头位置*/
off_t l_len; /*锁定区域的大小*/
pid_t l_pid; /*锁定动作的进程*/
};
l_type 有三种状态:
f_rdlck 建立一个供读取用的锁定
f_wrlck 建立一个供写入用的锁定
f_unlck 删除之前建立的锁定
l_whence 也有三种方式:
seek_set 以文件开头为锁定的起始位置。
seek_cur 以目前文件读写位置为锁定的起始位置
seek_end 以文件结尾为锁定的起始位置。

返回值 成功则返回0，若有错误则返回-1，错误原因存于errno.

　

flock（锁定文件或解除锁定）
相关函数 open,fcntl

表头文件 #include

定义函数 int flock(int fd,int operation);

函数说明 flock()会依参数operation所指定的方式对参数fd所指的文件做各种锁定或解除锁定的动作。此函数只能锁定整个文件，无法锁定文件的某一区域。

参数 operation有下列四种情况:
lock_sh 建立共享锁定。多个进程可同时对同一个文件作共享锁定。
lock_ex 建立互斥锁定。一个文件同时只有一个互斥锁定。
lock_un 解除文件锁定状态。
lock_nb 无法建立锁定时，此操作可不被阻断，马上返回进程。通常与lock_sh或lock_ex 做or(|)组合。
单一文件无法同时建立共享锁定和互斥锁定，而当使用dup()或fork()时文件描述词不会继承此种锁定。

返回值 返回0表示成功，若有错误则返回-1，错误代码存于errno。

　

fsync（将缓冲区数据写回磁盘）
相关函数 sync

表头文件 #include

定义函数 int fsync(int fd);

函数说明 fsync()负责将参数fd所指的文件数据，由系统缓冲区写回磁盘，以确保数据同步。

返回值 成功则返回0，失败返回-1，errno为错误代码。

　

lseek（移动文件的读写位置）
相关函数 dup，open，fseek

表头文件 #include
#include

定义函数 off_t lseek(int fildes,off_t offset ,int whence);

函数说明 每一个已打开的文件都有一个读写位置，当打开文件时通常其读写位置是指向文件开头，若是以附加的方式打开文件(如o_append)，则读写位置会指向文件尾。当read()或write()时，读写位置会随之增加，lseek()便是用来控制该文件的读写位置。参数fildes 为已打开的文件描述词，参数offset 为根据参数whence来移动读写位置的位移数。

参数 whence为下列其中一种:
seek_set 参数offset即为新的读写位置。
seek_cur 以目前的读写位置往后增加offset个位移量。
seek_end 将读写位置指向文件尾后再增加offset个位移量。
当whence 值为seek_cur 或seek_end时，参数offet允许负值的出现。
下列是教特别的使用方式:
1) 欲将读写位置移到文件开头时:lseek（int fildes,0,seek_set）；
2) 欲将读写位置移到文件尾时:lseek（int fildes，0,seek_end）；
3) 想要取得目前文件位置时:lseek（int fildes，0,seek_cur）；

返回值 当调用成功时则返回目前的读写位置，也就是距离文件开头多少个字节。若有错误则返回-1，errno 会存放错误代码。

附加说明 linux系统不允许lseek（）对tty装置作用，此项动作会令lseek（）返回espipe。

范例 参考本函数说明

　

mkstemp（建立唯一的临时文件）
相关函数 mktemp

表头文件 #include

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

函数说明 mkstemp()用来建立唯一的临时文件。参数template 所指的文件名称字符串中最后六个字符必须是xxxxxx。mkstemp()会以可读写模式和0600 权限来打开该文件，如果该文件不存在则会建立该文件。打开该文件后其文件描述词会返回。文件顺利打开后返回可读写的文件描述词。若果文件打开失败则返回null，并把错误代码存在errno 中。

错误代码 einval 参数template 字符串最后六个字符非xxxxxx。eexist 无法建立临时文件。

附加说明 参数template所指的文件名称字符串必须声明为数组，如:
char template[ ] =”template-xxxxxx”;
千万不可以使用下列的表达方式
char *template = “template-xxxxxx”;

范例 #include
main( )
{
int fd;
char template[ ]=”template-xxxxxx”;
fd=mkstemp(template);
printf(“template = %s/n”,template);
close(fd);
}

执行 template = template-lgzcbo

　

open（打开文件）
相关函数 read，write，fcntl，close，link，stat，umask，unlink，fopen

表头文件 #include
#include
#include

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

函数说明 参数pathname 指向欲打开的文件路径字符串。下列是参数flags 所能使用的旗标:
o_rdonly 以只读方式打开文件
o_wronly 以只写方式打开文件
o_rdwr 以可读写方式打开文件。上述三种旗标是互斥的，也就是不可同时使用，但可与下列的旗标利用or(|)运算符组合。
o_creat 若欲打开的文件不存在则自动建立该文件。
o_excl 如果o_creat 也被设置，此指令会去检查文件是否存在。文件若不存在则建立该文件，否则将导致打开文件错误。此外，若o_creat与o_excl同时设置，并且欲打开的文件为符号连接，则会打开文件失败。
o_noctty 如果欲打开的文件为终端机设备时，则不会将该终端机当成进程控制终端机。
o_trunc 若文件存在并且以可写的方式打开时，此旗标会令文件长度清为0，而原来存于该文件的资料也会消失。
o_append 当读写文件时会从文件尾开始移动，也就是所写入的数据会以附加的方式加入到文件后面。
o_nonblock 以不可阻断的方式打开文件，也就是无论有无数据读取或等待，都会立即返回进程之中。
o_ndelay 同o_nonblock。
o_sync 以同步的方式打开文件。
o_nofollow 如果参数pathname 所指的文件为一符号连接，则会令打开文件失败。
o_directory 如果参数pathname 所指的文件并非为一目录，则会令打开文件失败。
此为linux2.2以后特有的旗标，以避免一些系统安全问题。参数mode 则有下列数种组合，只有在建立新文件时才会生效，此外真正建文件时的权限会受到umask值所影响，因此该文件权限应该为（mode-umaks）。
s_irwxu00700 权限，代表该文件所有者具有可读、可写及可执行的权限。
s_irusr 或s_iread，00400权限，代表该文件所有者具有可读取的权限。
s_iwusr 或s_iwrite，00200 权限，代表该文件所有者具有可写入的权限。
s_ixusr 或s_iexec，00100 权限，代表该文件所有者具有可执行的权限。
s_irwxg 00070权限，代表该文件用户组具有可读、可写及可执行的权限。
s_irgrp 00040 权限，代表该文件用户组具有可读的权限。
s_iwgrp 00020权限，代表该文件用户组具有可写入的权限。
s_ixgrp 00010 权限，代表该文件用户组具有可执行的权限。
s_irwxo 00007权限，代表其他用户具有可读、可写及可执行的权限。
s_iroth 00004 权限，代表其他用户具有可读的权限
s_iwoth 00002权限，代表其他用户具有可写入的权限。
s_ixoth 00001 权限，代表其他用户具有可执行的权限。

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

错误代码 eexist 参数pathname 所指的文件已存在，却使用了o_creat和o_excl旗标。
eaccess 参数pathname所指的文件不符合所要求测试的权限。
erofs 欲测试写入权限的文件存在于只读文件系统内。
efault 参数pathname指针超出可存取内存空间。
einval 参数mode 不正确。
enametoolong 参数pathname太长。
enotdir 参数pathname不是目录。
enomem 核心内存不足。
eloop 参数pathname有过多符号连接问题。
eio i/o 存取错误。

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

范例 #include
#include
#include
#include
main()
{
int fd,size;
char s [ ]=”linux programmer!/n”,buffer[80];
fd=open(“/tmp/temp”,o_wronly|o_creat);
write(fd,s,sizeof(s));
close(fd);
fd=open(“/tmp/temp”,o_rdonly);
size=read(fd,buffer,sizeof(buffer));
close(fd);
printf(“%s”,buffer);
}

执行 linux programmer!

　

read（由已打开的文件读取数据）
相关函数 readdir，write，fcntl，close，lseek，readlink，fread

表头文件 #include

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

函数说明 read()会把参数fd 所指的文件传送count个字节到buf指针所指的内存中。若参数count为0，则read()不会有作用并返回0。返回值为实际读取到的字节数，如果返回0，表示已到达文件尾或是无可读取的数据，此外文件读写位置会随读取到的字节移动。

附加说明 如果顺利read()会返回实际读到的字节数，最好能将返回值与参数count 作比较，若返回的字节数比要求读取的字节数少，则有可能读到了文件尾、从管道(pipe)或终端机读取，或者是read()被信号中断了读取动作。当有错误发生时则返回-1，错误代码存入errno中，而文件读写位置则无法预期。

错误代码 eintr 此调用被信号所中断。
eagain 当使用不可阻断i/o 时（o_nonblock），若无数据可读取则返回此值。
ebadf 参数fd 非有效的文件描述词，或该文件已关闭。

范例 参考open（）。

　

sync（将缓冲区数据写回磁盘）
相关函数 fsync

表头文件 #include

定义函数 int sync(void)

函数说明 sync()负责将系统缓冲区数据写回磁盘，以确保数据同步。

返回值 返回0。

　

write（将数据写入已打开的文件内）
相关函数 open，read，fcntl，close，lseek，sync，fsync，fwrite

表头文件 #include

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

函数说明 write()会把参数buf所指的内存写入count个字节到参数fd所指的文件内。当然，文件读写位置也会随之移动。

返回值 如果顺利write()会返回实际写入的字节数。当有错误发生时则返回-1，错误代码存入errno中。

错误代码 eintr 此调用被信号所中断。
eagain 当使用不可阻断i/o 时（o_nonblock），若无数据可读取则返回此值。
eadf 参数fd非有效的文件描述词，或该文件已关闭。

范例 请参考open（）。

　

　

clearerr（清除文件流的错误旗标）
相关函数 feof

表头文件 #include

定义函数 void clearerr(file * stream);

函数说明 clearerr（）清除参数stream指定的文件流所使用的错误旗标。

返回值

　

fclose（关闭文件）
相关函数 close，fflush，fopen，setbuf

表头文件 #include

定义函数 int fclose(file * stream);

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

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

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

范例 请参考fopen（）。

　

fdopen（将文件描述词转为文件指针）
相关函数 fopen，open，fclose

表头文件 #include

定义函数 file * fdopen(int fildes,const char * mode);

函数说明 fdopen()会将参数fildes 的文件描述词，转换为对应的文件指针后返回。参数mode 字符串则代表着文件指针的流形态，此形态必须和原先文件描述词读写模式相同。关于mode 字符串格式请参考fopen()。

返回值 转换成功时返回指向该流的文件指针。失败则返回null，并把错误代码存在errno中。

范例 #include
main()
{
file * fp =fdopen(0,”w+”);
fprintf(fp,”%s/n”,”hello!”);
fclose(fp);
}

执行 hello!

　

feof（检查文件流是否读到了文件尾）
相关函数 fopen，fgetc，fgets，fread

表头文件 #include

定义函数 int feof(file * stream);

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

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

　

fflush（更新缓冲区）
相关函数 write，fopen，fclose，setbuf

表头文件 #include

定义函数 int fflush(file* stream);

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

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

错误代码 ebadf 参数stream 指定的文件未被打开，或打开状态为只读。其它错误代码参考write（）。

　

fgetc（由文件中读取一个字符）
相关函数 open，fread，fscanf，getc

表头文件 include

定义函数 nt fgetc(file * stream);

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

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

范例 #include
main()
{
file *fp;
int c;
fp=fopen(“exist”,”r”);
while((c=fgetc(fp))!=eof)
printf(“%c”,c);
fclose(fp);
}

　

fgets（由文件中读取一字符串）
相关函数 open，fread，fscanf，getc

表头文件 include

定义函数 har * fgets(char * s,int size,file * stream);

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

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

范例 #include
main()
{
char s[80];
fputs(fgets(s,80,stdin),stdout);
}

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

　

fileno（返回文件流所使用的文件描述词）
相关函数 open，fopen

表头文件 #include

定义函数 int fileno(file * stream);

函数说明 fileno()用来取得参数stream指定的文件流所使用的文件描述词。

返回值 返回文件描述词。

范例 #include
main()
{
file * fp;
int fd;
fp=fopen(“/etc/passwd”,”r”);
fd=fileno(fp);
printf(“fd=%d/n”,fd);
fclose(fp);
}

执行 fd=3

　

fopen（打开文件）
相关函数 open，fclose

表头文件 #include

定义函数 file * fopen(const char * path,const char * mode);

函数说明 参数path字符串包含欲打开的文件路径及文件名，参数mode字符串则代表着流形态。
mode有下列几种形态字符串:
r 打开只读文件，该文件必须存在。
r+ 打开可读写的文件，该文件必须存在。
w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。
a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。
上述的形态字符串都可以再加一个b字符，如rb、w+b或ab＋等组合，加入b 字符用来告诉函数库打开的文件为二进制文件，而非纯文字文件。不过在posix系统，包含linux都会忽略该字符。由fopen()所建立的新文件会具有s_irusr|s_iwusr|s_irgrp|s_iwgrp|s_iroth|s_iwoth(0666)权限，此文件权限也会参考umask值。

返回值 文件顺利打开后，指向该流的文件指针就会被返回。若果文件打开失败则返回null，并把错误代码存在errno 中。

附加说明 一般而言，开文件后会作一些文件读取或写入的动作，若开文件失败，接下来的读写动作也无法顺利进行，所以在fopen()后请作错误判断及处理。

范例 #include
main()
{
file * fp;
fp=fopen(“noexist”,”a+”);
if(fp= =null) return;
fclose(fp);
}

　

fputc（将一指定字符写入文件流中）
相关函数 fopen，fwrite，fscanf，putc

表头文件 #include

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

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

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

范例 #include
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（将一指定的字符串写入文件内）
相关函数 fopen，fwrite，fscanf，fputc，putc

表头文件 #include

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

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

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

范例 请参考fgets（）。

　

fread（从文件流读取数据）
相关函数 fopen，fwrite，fseek，fscanf

表头文件 #include

定义函数 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
#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 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（打开文件）
相关函数 fopen，fclose

表头文件 #include

定义函数 file * freopen(const char * path,const char * mode,file * stream);

函数说明 参数path字符串包含欲打开的文件路径及文件名，参数mode请参考fopen()说明。参数stream为已打开的文件指针。freopen()会将原stream所打开的文件流关闭，然后打开参数path的文件。

返回值 文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回null，并把错误代码存在errno 中。

范例 #include
main()
{
file * fp;
fp=fopen(“/etc/passwd”,”r”);
fp=freopen(“/etc/group”,”r”,fp);
fclose(fp);
}

　

fseek（移动文件流的读写位置）
相关函数 rewind，ftell，fgetpos，fsetpos，lseek

表头文件 #include

定义函数 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,0seek_end);

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

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

范例 #include
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（取得文件流的读取位置）
相关函数 fseek，rewind，fgetpos，fsetpos

表头文件 #include

定义函数 long ftell(file * stream);

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

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

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

范例 参考fseek()。

　

fwrite（将数据写至文件流）
相关函数 fopen，fread，fseek，fscanf

表头文件 #include

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

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

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

范例 #include
#define set_s (x,y) {strcoy(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（由文件中读取一个字符）
相关函数 read，fopen，fread，fgetc

表头文件 #include

定义函数 int getc(file * stream);

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

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

范例 参考fgetc()。

　

getchar（由标准输入设备内读进一字符）
相关函数 fopen，fread，fscanf，getc

表头文件 #include

定义函数 int getchar(void);

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

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

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

范例 #include
main()
{
file * fp;
int c,i;
for(i=0li<5;i++)
{
c=getchar();
putchar(c);
}
}

执行 1234 /*输入*/
1234 /*输出*/

　

gets（由标准输入设备内读进一字符串）
相关函数 fopen，fread，fscanf，fgets

表头文件 #include

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

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

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

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

范例 参考fgets()

　

mktemp（产生唯一的临时文件名）
相关函数 tmpfile

表头文件 #include

定义函数 char * mktemp(char * template);

函数说明 mktemp()用来产生唯一的临时文件名。参数template所指的文件名称字符串中最后六个字符必须是xxxxxx。产生后的文件名会借字符串指针返回。

返回值 文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回null，并把错误代码存在errno中。

附加说明 参数template所指的文件名称字符串必须声明为数组，如:
char template[ ]=”template-xxxxxx”；
不可用char * template=”template-xxxxxx”；

范例 #include
main()
{
char template[ ]=”template-xxxxxx”;
mktemp(template);
printf(“template=%s/n”,template);
}

　

putc（将一指定字符写入文件中）
相关函数 fopen，fwrite，fscanf，fputc

表头文件 #include

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

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

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

范例 参考fputc（）。

　

putchar（将指定的字符写到标准输出设备）
相关函数 fopen，fwrite，fscanf，fputc

表头文件 #include

定义函数 int putchar (int c);

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

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

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

范例 参考getchar()。

　

rewind（重设文件流的读写位置为文件开头）
相关函数 fseek，ftell，fgetpos，fsetpos

表头文件 #include

定义函数 void rewind(file * stream);

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

返回值

范例 参考fseek()

　

setbuf（设置文件流的缓冲区）
相关函数 setbuffer，setlinebuf，setvbuf

表头文件 #include

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

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

返回值

　

setbuffer（设置文件流的缓冲区）
相关函数 setlinebuf，setbuf，setvbuf

表头文件 #include

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

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

返回值

　

setlinebuf（设置文件流为线性缓冲区）
相关函数 setbuffer，setbuf，setvbuf

表头文件 #include

定义函数 void setlinebuf(file * stream);

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

返回值

　

setvbuf（设置文件流的缓冲区）
相关函数 setbuffer，setlinebuf，setbuf

表头文件 #include

定义函数 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（将指定字符写回文件流中）
相关函数 fputc，getchar，getc

表头文件 #include

定义函数 int ungetc(int c,file * stream);

函数说明 ungetc()将参数c字符写回参数stream所指定的文件流。这个写回的字符会由下一个读取文件流的函数取得。

返回值 成功则返回c 字符，若有错误则返回eof。

　

　

atexit（设置程序正常结束前调用的函数）
相关函数 _exit,exit,on_exit

表头文件 #include

定义函数 int atexit (void (*function)(void));

函数说明 atexit()用来设置一个程序正常结束前调用的函数。当程序通过调用exit()或从main中返回时，参数function所指定的函数会先被调用，然后才真正由exit()结束程序。

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

范例 #include
void my_exit(void)
{
printf(“before exit () !/n”);
}
main()
{
atexit (my_exit);
exit(0);
}

执行 before exit()!

　

execl（执行文件）
相关函数 fork，execle，execlp，execv，execve，execvp

表头文件 #include

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

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

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

范例 #include
main()
{
execl(“/bin/ls”,”ls”,”-al”,”/etc/passwd”,(char * )0);
}

执行 /*执行/bin/ls -al /etc/passwd */
-rw-r–r– 1 root root 705 sep 3 13 :52 /etc/passwd

　

execlp（从path 环境变量中查找文件并执行）
相关函数 fork，execl，execle，execv，execve，execvp

表头文件 #include

定义函数 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
main()
{
execlp(“ls”,”ls”,”-al”,”/etc/passwd”,(char *)0);
}

执行 -rw-r–r– 1 root root 705 sep 3 13 :52 /etc/passwd

　

execv（执行文件）
相关函数 fork，execl，execle，execlp，execve，execvp

表头文件 #include

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

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

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

错误代码 请参考execve（）。

范例 /* 执行/bin/ls -al /etc/passwd */
#include
main()
{
char * argv[ ]={“ls”,”-al”,”/etc/passwd”,(char*) }};
execv(“/bin/ls”,argv);
}

执行 -rw-r–r– 1 root root 705 sep 3 13 :52 /etc/passwd

　

execve（执行文件）
相关函数 fork，execl，execle，execlp，execv，execvp

表头文件 #include

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

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

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

错误代码 eacces
1. 欲执行的文件不具有用户可执行的权限。
2. 欲执行的文件所属的文件系统是以noexec 方式挂上。
3.欲执行的文件或script翻译器非一般文件。
eperm
1.进程处于被追踪模式，执行者并不具有root权限，欲执行的文件具有suid 或sgid 位。
2.欲执行的文件所属的文件系统是以nosuid方式挂上，欲执行的文件具有suid 或sgid 位元，但执行者并不具有root权限。
e2big 参数数组过大
enoexec 无法判断欲执行文件的执行文件格式，有可能是格式错误或无法在此平台执行。
efault 参数filename所指的字符串地址超出可存取空间范围。
enametoolong 参数filename所指的字符串太长。
enoent 参数filename字符串所指定的文件不存在。
enomem 核心内存不足
enotdir 参数filename字符串所包含的目录路径并非有效目录
eacces 参数filename字符串所包含的目录路径无法存取，权限不足
eloop 过多的符号连接
etxtbusy 欲执行的文件已被其他进程打开而且正把数据写入该文件中
eio i/o 存取错误
enfile 已达到系统所允许的打开文件总数。
emfile 已达到系统所允许单一进程所能打开的文件总数。
einval 欲执行文件的elf执行格式不只一个pt_interp节区
eisdir elf翻译器为一目录
elibbad elf翻译器有问题。

范例 #include
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（执行文件）
相关函数 fork，execl，execle，execlp，execv，execve

表头文件 #include

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

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

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

错误代码 请参考execve（）。

范例 /*请与execlp（）范例对照*/
#include
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，atexit，on_exit

表头文件 #include

定义函数 void exit(int status);

函数说明 exit()用来正常终结目前进程的执行，并把参数status返回给父进程，而进程所有的缓冲区数据会自动写回并关闭未关闭的文件。

返回值

范例 参考wait（）

　

_
exit（结束进程执行）
相关函数 exit，wait，abort

表头文件 #include

定义函数 void _exit(int status);

函数说明 _exit()用来立刻结束目前进程的执行，并把参数status返回给父进程，并关闭未关闭的文件。此函数调用后不会返回，并且会传递sigchld信号给父进程，父进程可以由wait函数取得子进程结束状态。

返回值

附加说明 _exit（）不会处理标准i/o 缓冲区，如要更新缓冲区请使用exit（）。

　

vfork（建立一个新的进程）
相关函数 wait，execve

表头文件 #include

定义函数 pid_t vfork(void);

函数说明 vfork()会产生一个新的子进程，其子进程会复制父进程的数据与堆栈空间，并继承父进程的用户代码，组代码，环境变量、已打开的文件代码、工作目录和资源限制等。linux 使用copy-on-write(cow)技术，只有当其中一进程试图修改欲复制的空间时才会做真正的复制动作，由于这些继承的信息是复制而来，并非指相同的内存空间，因此子进程对这些变量的修改和父进程并不会同步。此外，子进程不会继承父进程的文件锁定和未处理的信号。注意，linux不保证子进程会比父进程先执行或晚执行，因此编写程序时要留意

死锁或竞争条件的发生。

返回值 如果vfork()成功则在父进程会返回新建立的子进程代码(pid)，而在新建立的子进程中则返回0。如果vfork 失败则直接返回-1，失败原因存于errno中。

错误代码 eagain 内存不足。enomem 内存不足，无法配置核心所需的数据结构空间。

范例 #include
main()
{
if(vfork() = =0)
{
printf(“this is the child process/n”);
}else{
printf(“this is the parent process/n”);
}
}

执行 this is the parent process
this is the child process

　

getpgid（取得进程组识别码）
相关函数 setpgid，setpgrp，getpgrp

表头文件 #include

定义函数 pid_t getpgid( pid_t pid);

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

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

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

范例 /*取得init 进程（pid＝1）的组识别码*/
#include
mian()
{
printf(“init gid = %d/n”,getpgid(1));
}

执行 init gid = 0

　

getpgrp（取得进程组识别码）
相关函数 setpgid，getpgid，getpgrp

表头文件 #include

定义函数 pid_t getpgrp(void);

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

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

范例 #include
main()
{
printf(“my gid =%d/n”,getpgrp());
}

执行 my gid =29546

　

getpid（取得进程识别码）
相关函数 fork，kill，getpid

表头文件 #include

定义函数 pid_t getpid(void);

函数说明 getpid（）用来取得目前进程的进程识别码，许多程序利用取到的此值来建立临时文件，以避免临时文件相同带来的问题。

返回值 目前进程的进程识别码

范例 #include
main()
{
printf(“pid=%d/n”,getpid());
}

执行 pid=1494 /*每次执行结果都不一定相同*/

　

getppid（取得父进程的进程识别码）
相关函数 fork，kill，getpid

表头文件 #include

定义函数 pid_t getppid(void);

函数说明 getppid()用来取得目前进程的父进程识别码。

返回值 目前进程的父进程识别码。

范例 #include
main()
{
printf(“my parent ‘pid =%d/n”,getppid());
}

执行 my parent pid =463

　

getpriority（取得程序进程执行优先权）
相关函数 setpriority，nice

表头文件 #include
#include

定义函数 int getpriority(int which,int who);

函数说明 getpriority()可用来取得进程、进程组和用户的进程执行优先权。

参数 which有三种数值，参数who 则依which值有不同定义
which who 代表的意义
prio_process who 为进程识别码
prio_pgrp who 为进程的组识别码
prio_user who 为用户识别码
此函数返回的数值介于-20 至20之间，代表进程执行优先权，数值越低代表有较高的优先次序，执行会较频繁。

返回值 返回进程执行优先权，如有错误发生返回值则为-1 且错误原因存于errno。

附加说明 由于返回值有可能是-1，因此要同时检查errno是否存有错误原因。最好在调用次函数前先清除errno变量。

错误代码 esrch 参数which或who 可能有错，而找不到符合的进程。einval 参数which 值错误。

　

nice（改变进程优先顺序）
相关函数 setpriority，getpriority

表头文件 #include

定义函数 int nice(int inc);

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

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

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

　

on_exit（设置程序正常结束前调用的函数）
相关函数 _exit，atexit，exit

表头文件 #include

定义函数 int on_exit(void (* function)(int, void*),void *arg);

函数说明 on_exit()用来设置一个程序正常结束前调用的函数。当程序通过调用exit()或从main中返回时，参数function所指定的函数会先被调用，然后才真正由exit()结束程序。参数arg指针会传给参数function函数，详细情况请见范例。

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

附加说明

范例 #include
void my_exit(int status,void *arg)
{
printf(“before exit()!/n”);
printf(“exit (%d)/n”,status);
printf(“arg = %s/n”,(char*)arg);
}
main()
{
char * str=”test”;
on_exit(my_exit,(void *)str);
exit(1234);
}

执行 before exit()!
exit (1234)
arg = test

　

setpgid（设置进程组识别码）
相关函数 getpgid，setpgrp，getpgrp

表头文件 #include

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

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

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

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

　

setpgrp（设置进程组识别码）
相关函数 getpgid，setpgid，getpgrp

表头文件 #include

定义函数 int setpgrp(void);

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

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

　

setpriority（设置程序进程执行优先权）
相关函数 getpriority，nice

表头文件 #include
#include

定义函数 int setpriority(int which,int who, int prio);

函数说明 setpriority()可用来设置进程、进程组和用户的进程执行优先权。参数which有三种数值，参数who 则依which值有不同定义
which who 代表的意义
prio_process who为进程识别码
prio_pgrp who 为进程的组识别码
prio_user who为用户识别码
参数prio介于-20 至20 之间。代表进程执行优先权，数值越低代表有较高的优先次序，执行会较频繁。此优先权默认是0，而只有超级用户（root）允许降低此值。

返回值 执行成功则返回0，如果有错误发生返回值则为-1，错误原因存于errno。
esrch 参数which或who 可能有错，而找不到符合的进程
einval 参数which值错误。
eperm 权限不够，无法完成设置
eacces 一般用户无法降低优先权

　

system（执行shell 命令）
相关函数 fork，execve，waitpid，popen

表头文件 #include

定义函数 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
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（等待子进程中断或结束）
相关函数 waitpid，fork

表头文件 #include
#include

定义函数 pid_t wait (int * status);

函数说明 wait()会暂时停止目前进程的执行，直到有信号来到或子进程结束。如果在调用wait()时子进程已经结束，则wait()会立即返回子进程结束状态值。子进程的结束状态值会由参数status 返回，而子进程的进程识别码也会一快返回。如果不在意结束状态值，则

参数 status可以设成null。子进程的结束状态值请参考waitpid()。

返回值 如果执行成功则返回子进程识别码(pid)，如果有错误发生则返回-1。失败原因存于errno中。

附加说明

范例 #include
#include
#include
#include
main()
{
pid_t pid;
int status,i;
if(fork()= =0){
printf(“this is the child process .pid =%d/n”,getpid());
exit(5);
}else{
sleep(1);
printf(“this is the parent process ,wait for child…/n”;
pid=wait(&status);
i=wexitstatus(status);
printf(“child’s pid =%d .exit status=^d/n”,pid,i);
}
}

执行 this is the child process.pid=1501
this is the parent process .wait for child…
child’s pid =1501,exit status =5

　

waitpid（等待子进程中断或结束）
相关函数 wait，fork

表头文件 #include
#include

定义函数 pid_t waitpid(pid_t pid,int * status,int options);

函数说明 waitpid()会暂时停止目前进程的执行，直到有信号来到或子进程结束。如果在调用wait()时子进程已经结束，则wait()会立即返回子进程结束状态值。子进程的结束状态值会由参数status返回，而子进程的进程识别码也会一快返回。如果不在意结束状态值，则参数status可以设成null。参数pid为欲等待的子进程识别码，其他数值意义如下:
pid< -1 等待进程组识别码为pid绝对值的任何子进程。
pid=-1 等待任何子进程，相当于wait()。
pid=0 等待进程组识别码与目前进程相同的任何子进程。
pid>0 等待任何子进程识别码为pid的子进程。
参数option可以为0 或下面的or 组合
wnohang 如果没有任何已经结束的子进程则马上返回，不予以等待。
wuntraced 如果子进程进入暂停执行情况则马上返回，但结束状态不予以理会。
子进程的结束状态返回后存于status，底下有几个宏可判别结束情况
wifexited(status)如果子进程正常结束则为非0值。
wexitstatus(status)取得子进程exit()返回的结束代码，一般会先用wifexited 来判断是否正常结束才能使用此宏。
wifsignaled(status)如果子进程是因为信号而结束则此宏值为真
wtermsig(status)取得子进程因信号而中止的信号代码，一般会先用wifsignaled 来判断后才使用此宏。
wifstopped(status)如果子进程处于暂停执行情况则此宏值为真。一般只有使用wuntraced 时才会有此情况。
wstopsig(status)取得引发子进程暂停的信号代码，一般会先用wifstopped 来判断后才使用此宏。

返回值 如果执行成功则返回子进程识别码(pid)，如果有错误发生则返回-1。失败原因存于errno中。

范例 参考wait()。

　

fprintf（格式化输出数据至文件）
相关函数 printf，fscanf，vfprintf

表头文件 #include

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

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

返回值 关于参数format字符串的格式请参考printf()。成功则返回实际输出的字符数，失败则返回-1，错误原因存于errno中。

范例 #include
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（格式化字符串输入）
相关函数 scanf，sscanf

表头文件 #include

定义函数 int fscanf(file * stream ,const char *format,….);

函数说明 fscanf()会自参数stream的文件流中读取字符串，再根据参数format字符串来转换并格式化数据。格式转换形式请参考scanf()。转换后的结构存于对应的参数内。

返回值 成功则返回参数数目，失败则返回-1，错误原因存于errno中。

附加说明

范例 #include
main()
{
int i;
unsigned int j;
char s[5];
fscanf(stdin,”%d %x %5[a-z] %*s %f”,&i,&j,s,s);
printf(“%d %d %s /n”,i,j,s);
}

执行 10 0×1b aaaaaaaaa bbbbbbbbbb /*从键盘输入*/
10 27 aaaaa

　

printf（格式化输出数据）
相关函数 scanf，snprintf

表头文件 #include

定义函数 int printf(const char * format,………….);

函数说明 printf()会根据参数format字符串来转换并格式化数据，然后将结果写出到标准输出设备，直到出现字符串结束(’/0′)为止。参数format字符串可包含下列三种字符类型
1.一般文本，伴随直接输出。
2.ascii控制字符，如/t、/n等。
3.格式转换字符。
格式转换为一个百分比符号(％)及其后的格式字符所组成。一般而言，每个％符号在其后都必需有一printf()的参数与之相呼应（只有当％％转换字符出现时会直接输出％字符），而欲输出的数据类型必须与其相对应的转换字符类型相同。
printf()格式转换的一般形式如下
％(flags)(width)(.prec)type
以中括号括起来的参数为选择性参数，而％与type则是必要的。底下先介绍type的几种形式
整数
％d 整数的参数会被转成一有符号的十进制数字
％u 整数的参数会被转成一无符号的十进制数字
％o 整数的参数会被转成一无符号的八进制数字
％x 整数的参数会被转成一无符号的十六进制数字，并以小写abcdef表示
％x 整数的参数会被转成一无符号的十六进制数字，并以大写abcdef表示浮点型数
％f double 型的参数会被转成十进制数字，并取到小数点以下六位，四舍五入。
％e double型的参数以指数形式打印，有一个数字会在小数点前，六位数字在小数点后，而在指数部分会以小写的e来表示。
％e 与％e作用相同，唯一区别是指数部分将以大写的e 来表示。
％g double 型的参数会自动选择以％f 或％e 的格式来打印，其标准是根据欲打印的数值及所设置的有效位数来决定。
％g 与％g 作用相同，唯一区别在以指数形态打印时会选择％e 格式。
字符及字符串
％c 整型数的参数会被转成unsigned char型打印出。
％s 指向字符串的参数会被逐字输出，直到出现null字符为止
％p 如果是参数是“void *”型指针则使用十六进制格式显示。
prec 有几种情况
1. 正整数的最小位数。
2.在浮点型数中代表小数位数
3.在％g 格式代表有效位数的最大值。
4.在％s格式代表字符串的最大长度。
5.若为×符号则代表下个参数值为最大长度。
width为参数的最小长度，若此栏并非数值，而是*符号，则表示以下一个参数当做参数长度。
flags 有下列几种情况
#name?
+ 一般在打印负数时，printf（）会加印一个负号，整数则不加任何负号。此旗标会使得在打印正数前多一个正号（+）。
# 此旗标会根据其后转换字符的不同而有不同含义。当在类型为o 之前（如％#o），则会在打印八进制数值前多印一个o。
而在类型为x 之前（％#x）则会在打印十六进制数前多印’0x’，在型态为e、e、f、g或g 之前则会强迫数值打印小数点。在类型为g 或g之前时则同时保留小数点及小数位数末尾的零。
0 当有指定参数时，无数字的参数将补上0。默认是关闭此旗标，所以一般会打印出空白字符。

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

范例 #include
main()
{
int i = 150;
int j = -100;
double k = 3.14159;
printf(“%d %f %x/n”,j,k,i);
printf(“%2d %*d/n”,i,2,i); /*参数2 会代入格式*中，而与%2d同意义*/
}

执行 -100 3.14159 96
150 150

　

sacnf（格式化字符串输入）
相关函数 fscanf，snprintf

表头文件 #include

定义函数 int scanf(const char * format,…….);

函数说明 scanf()会将输入的数据根据参数format字符串来转换并格式化数据。scanf()格式转换的一般形式如下
％
[size][l][h]type
以中括号括起来的参数为选择性参数，而％与type则是必要的。
* 代表该对应的参数数据忽略不保存。
size 为允许参数输入的数据长度。
l 输入的数据数值以long int 或double型保存。
h 输入的数据数值以short int 型保存。
底下介绍type的几种形式
％d 输入的数据会被转成一有符号的十进制数字（int）。
％i 输入的数据会被转成一有符号的十进制数字，若输入数据以“0x”或“0x”开头代表转换十六进制数字，若以“0”开头则转换八进制数字，其他情况代表十进制。
％0 输入的数据会被转换成一无符号的八进制数字。
％u 输入的数据会被转换成一无符号的正整数。
％x 输入的数据为无符号的十六进制数字，转换后存于unsigned int型变量。
％x 同％x
％f 输入的数据为有符号的浮点型数，转换后存于float型变量。
％e 同％f
％e 同％f
％g 同％f
％s 输入数据为以空格字符为终止的字符串。
％c 输入数据为单一字符。
[] 读取数据但只允许括号内的字符。如[a-z]。
[^] 读取数据但不允许中括号的^符号后的字符出现，如[^0-9].

返回值 成功则返回参数数目，失败则返回-1，错误原因存于errno中。

范例 #include
main()
{
int i;
unsigned int j;
char s[5];
scanf(“%d %x %5[a-z] %*s %f”,&i,&j,s,s);
printf(“%d %d %s/n”,i,j,s);
}

执行 10 0×1b aaaaaaaaaa bbbbbbbbbb
10 27 aaaaa

　

sprintf（格式化字符串复制）
相关函数 printf，sprintf

表头文件 #include

定义函数 int sprintf( char *str,const char * format,………);

函数说明 sprintf()会根据参数format字符串来转换并格式化数据，然后将结果复制到参数str所指的字符串数组，直到出现字符串结束(’/0’)为止。关于参数format字符串的格式请参考printf()。

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

附加说明 使用此函数得留意堆栈溢出，或改用snprintf（）。

范例 #include
main()
{
char * a=”this is string a!”;
char buf[80];
sprintf(buf,”>>> %s< <</n”,a);
printf(“%s”.buf);
}

执行 >>>this is string a!< <<

　

sscanf（格式化字符串输入）
相关函数 scanf，fscanf

表头文件 #include

定义函数 int sscanf (const char *str,const char * format,……..);

函数说明 sscanf()会将参数str的字符串根据参数format字符串来转换并格式化数据。格式转换形式请参考scanf()。转换后的结果存于对应的参数内。

返回值 成功则返回参数数目，失败则返回-1，错误原因存于errno中。

范例 #include
main()
{
int i;
unsigned int j;
char input[ ]=”10 0×1b aaaaaaaa bbbbbbbb”;
char s[5];
sscanf(input,”%d %x %5[a-z] %*s %f”,&i,&j,s,s);
printf(“%d %d %s/n”,i,j,s);
}

执行 10 27 aaaaa

　

vfprintf（格式化输出数据至文件）
相关函数 printf，fscanf，fprintf

表头文件 #include
#include

定义函数 int vfprintf(file *stream,const char * format,va_list ap);

函数说明 vfprintf()会根据参数format字符串来转换并格式化数据，然后将结果输出到参数stream指定的文件中，直到出现字符串结束(’/0’)为止。关于参数format字符串的格式请参考printf()。va_list用法请参考附录c或vprintf()范例。

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

范例 参考fprintf()及vprintf()。

　

vfscanf（格式化字符串输入）
相关函数 scanf，sscanf，fscanf

表头文件 #include

定义函数 int vfscanf(file * stream,const char * format ,va_list ap);

函数说明 vfscanf()会自参数stream 的文件流中读取字符串，再根据参数format字符串来转换并格式化数据。格式转换形式请参考scanf()。转换后的结果存于对应的参数内。va_list用法请参考附录c 或vprintf()。

返回值 成功则返回参数数目，失败则返回-1，错误原因存于errno中。

范例 参考fscanf()及vprintf()。

　

vprintf（格式化输出数据）
相关函数 printf，vfprintf，vsprintf

表头文件 #include
#include

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

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

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

范例 #include
#include
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 96
my_printf() : 150 150

　

vscanf（格式化字符串输入）
相关函数 vsscanf，vfscanf

表头文件 #include
#include

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

函数说明 vscanf()会将输入的数据根据参数format字符串来转换并格式化数据。格式转换形式请参考scanf()。转换后的结果存于对应的参数内。va_list用法请参考附录c或vprintf()范例。

返回值 成功则返回参数数目，失败则返回-1，错误原因存于errno中。

范例 请参考scanf()及vprintf()。

　

vsprintf（格式化字符串复制）
相关函数 vnsprintf，vprintf，snprintf

表头文件 #include

定义函数 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（格式化字符串输入）
相关函数 vscanf，vfscanf

表头文件 #include

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

函数说明 vsscanf()会将参数str的字符串根据参数format字符串来转换并格式化数据。格式转换形式请参考附录c 或vprintf()范例。

返回值 成功则返回参数数目，失败则返回-1，错误原因存于errno中。

范例 请参考sscanf()及vprintf()。

　

　

access（判断是否具有存取文件的权限）
相关函数 stat，open，chmod，chown，setuid，setgid

表头文件 #include

定义函数 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()只作权限的核查，并不理会文件形态或文件内容，因此，如果一目录表示为“可写入”，表示可以在该目录中建立新文件等操作，而非意味此目录可以被当做文件处理。例如，你会发现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
int main()
{
if (access(“/etc/passwd”,r_ok) = =0)
printf(“/etc/passwd can be read/n”);
}

执行 /etc/passwd can be read

　

alphasort（依字母顺序排序目录结构）
相关函数 scandir，qsort

表头文件 #include

定义函数 int alphasort(const struct dirent **a,const struct dirent **b);

函数说明 alphasort()为scandir()最后调用qsort()函数时传给qsort()作为判断的函数，详细说明请参考scandir()及qsort()。

返回值 参考qsort()。

范例 /* 读取/目录下所有的目录结构，并依字母顺序排列*/
main()
{
struct dirent **namelist;
int i,total;
total = scandir(“/”,&namelist ,0,alphasort);
if(total <0)
perror(“scandir”);
else{
for(i=0;i printf(“%s/n”,namelist[i]->d_name);
printf(“total = %d/n”,total);
}
}

执行 ..
.gnome
.gnome_private
errorlog
weblog
bin
boot
dev
dosc
dosd
etc
home
lib
lost+found
misc
mnt
opt
proc
root
sbin
tmp
usr
var
total = 24

　

chdir（改变当前的工作（目录）
相关函数 getcwd，chroot

表头文件 #include

定义函数 int chdir(const char * path);

函数说明 chdir()用来将当前的工作目录改变成以参数path所指的目录。

返回值 执行成功则返回0，失败返回-1，errno为错误代码。

范例 #include
main()
{
chdir(“/tmp”);
printf(“current working directory: %s/n”,getcwd(null,null));
}

执行 current working directory :/tmp

　

chmod（改变文件的权限）
相关函数 fchmod，stat，open，chown

表头文件 #include
#include

定义函数 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 权限，则这两个位会被清除。如果一目录具有s_isuid 位权限，表示在此目录下只有该文件的所有者或root可以删除该文件。

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

错误代码 eperm 进程的有效用户识别码与欲修改权限的文件拥有者不同，而且也不具root权限。
eaccess 参数path所指定的文件无法存取。
erofs 欲写入权限的文件存在于只读文件系统内。
efault 参数path指针超出可存取内存空间。
einval 参数mode不正确
enametoolong 参数path太长
enoent 指定的文件不存在
enotdir 参数path路径并非一目录
enomem 核心内存不足
eloop 参数path有过多符号连接问题。
eio i/o 存取错误

范例 /* 将/etc/passwd 文件权限设成s_irusr|s_iwusr|s_irgrp|s_iroth */
#include
#include
main()
{
chmod(“/etc/passwd”,s_irusr|s_iwusr|s_irgrp|s_iroth);
}

　

chown（改变文件的所有者）
相关函数 fchown，lchown，chmod

表头文件 #include
#include

定义函数 int chown(const char * path, uid_t owner,gid_t group);

函数说明 chown()会将参数path指定文件的所有者变更为参数owner代表的用户，而将该文件的组变更为参数group组。如果参数owner或group为-1，对应的所有者或组不会有所改变。root与文件所有者皆可改变文件组，但所有者必须是参数group组的成员。当root用chown()改变文件所有者或组时，该文件若具有s_isuid或s_isgid权限，则会清除此权限位，此外如果具有s_isgid权限但不具s_ixgrp位，则该文件会被强制锁定，文件模式会保留。

返回值 成功则返回0，失败返回-1，错误原因存于errno。

错误代码 参考chmod（）。

范例 /* 将/etc/passwd 的所有者和组都设为root */
#include
#include
main()
{
chown(“/etc/passwd”,0,0);
}

　

chroot（改变根目录）
相关函数 chdir

表头文件 #include

定义函数 int chroot(const char * path);

函数说明 chroot()用来改变根目录为参数path 所指定的目录。只有超级用户才允许改变根目录，子进程将继承新的根目录。

返回值 调用成功则返回0，失败则返-1，错误代码存于errno。

错误代码 eperm 权限不足，无法改变根目录。
efault 参数path指针超出可存取内存空间。
enametoolong 参数path太长。
enotdir 路径中的目录存在但却非真正的目录。
eaccess 存取目录时被拒绝
enomem 核心内存不足。
eloop 参数path有过多符号连接问题。
eio i/o 存取错误。

范例 /* 将根目录改为/tmp ,并将工作目录切换至/tmp */
#include
main()
{
chroot(“/tmp”);
chdir(“/”);
}

　

closedir（关闭目录）
相关函数 opendir

表头文件 #include
#include

定义函数 int closedir(dir *dir);

函数说明 closedir()关闭参数dir所指的目录流。

返回值 关闭成功则返回0，失败返回-1，错误原因存于errno 中。

错误代码 ebadf 参数dir为无效的目录流

范例 参考readir()。

　

fchdir（改变当前的工作目录）
相关函数 getcwd，chroot

表头文件 #include

定义函数 int fchdir(int fd);

函数说明 fchdir()用来将当前的工作目录改变成以参数fd 所指的文件描述词。

返回值执 行成功则返回0，失败返回-1，errno为错误代码。

附加说明

范例 #include
#include
#include
#include
main()
{
int fd;
fd = open(“/tmp”,o_rdonly);
fchdir(fd);
printf(“current working directory : %s /n”,getcwd(null,null));
close(fd);
}

执行 current working directory : /tmp

　

fchmod（改变文件的权限）
相关函数 chmod，stat，open，chown

表头文件 #include
#include

定义函数 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
#include
main()
{
int fd;
fd = open (“/etc/passwd”,o_rdonly);
fchmod(fd,s_irusr|s_iwusr|s_irgrp|s_iroth);
close(fd);
}

　

fchown（改变文件的所有者）
相关函数 chown，lchown，chmod

表头文件 #include
#include

定义函数 int fchown(int fd,uid_t owner,gid_t group);

函数说明 fchown()会将参数fd指定文件的所有者变更为参数owner代表的用户，而将该文件的组变更为参数group组。如果参数owner或group为-1，对映的所有者或组有所改变。参数fd 为已打开的文件描述词。当root用fchown()改变文件所有者或组时，该文件若具s_isuid或s_isgid权限，则会清除此权限位。

返回值 成功则返回0，失败则返回-1，错误原因存于errno。

错误代码 ebadf 参数fd文件描述词为无效的或该文件已关闭。
eperm 进程的有效用户识别码与欲修改权限的文件所有者不同，而且也不具root权限，或是参数owner、group不正确。
erofs 欲写入的文件存在于只读文件系统内。
enoent 指定的文件不存在
eio i/o存取错误

范例 #include
#include
#include
main()
{
int fd;
fd = open (“/etc/passwd”,o_rdonly);
chown(fd,0,0);
close(fd);
}

　

fstat（由文件描述词取得文件状态）
相关函数 stat，lstat，chmod，chown，readlink，utime

表头文件 #include
#include

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

函数说明 fstat()用来将参数fildes所指的文件状态，复制到参数buf所指的结构中(struct stat)。fstat()与stat()作用完全相同，不同处在于传入的参数为已打开的文件描述词。详细内容请参考stat()。

返回值 执行成功则返回0，失败返回-1，错误代码存于errno。

范例 #include
#include
#include
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（改变文件大小）
相关函数 open，truncate

表头文件 #include

定义函数 int ftruncate(int fd,off_t length);

函数说明 ftruncate()会将参数fd指定的文件大小改为参数length指定的大小。参数fd为已打开的文件描述词，而且必须是以写入模式打开的文件。如果原来的文件大小比参数length大，则超过的部分会被删去。

返回值 执行成功则返回0，失败返回-1，错误原因存于errno。

错误代码 ebadf 参数fd文件描述词为无效的或该文件已关闭。
einval 参数fd 为一socket 并非文件，或是该文件并非以写入模式打开。

　

getcwd（取得当前的工作目录）
相关函数 get_current_dir_name，getwd，chdir

表头文件 #include

定义函数 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
main()
{
char buf[80];
getcwd(buf,sizeof(buf));
printf(“current working directory : %s/n”,buf);
}

执行 current working directory :/tmp

　

link（建立文件连接）
相关函数 symlink，unlink

表头文件 #include

定义函数 int link (const char * oldpath,const char * newpath);

函数说明 link()以参数newpath指定的名称来建立一个新的连接(硬连接)到参数oldpath所指定的已存在文件。如果参数newpath指定的名称为一已存在的文件则不会建立连接。

返回值 成功则返回0，失败返回-1，错误原因存于errno。

附加说明 link()所建立的硬连接无法跨越不同文件系统，如果需要请改用symlink()。

错误代码 exdev 参数oldpath与newpath不是建立在同一文件系统。
eperm 参数oldpath与newpath所指的文件系统不支持硬连接
erofs 文件存在于只读文件系统内
efault 参数oldpath或newpath 指针超出可存取内存空间。
enametollong 参数oldpath或newpath太长
enomem 核心内存不足
eexist 参数newpath所指的文件名已存在。
emlink 参数oldpath所指的文件已达最大连接数目。
eloop 参数pathname有过多符号连接问题
enospc 文件系统的剩余空间不足。
eio i/o 存取错误。

范例 /* 建立/etc/passwd 的硬连接为pass */
#include
main()
{
link(“/etc/passwd”,”pass”);
}

　

lstat（由文件描述词取得文件状态）
相关函数 stat，fstat，chmod，chown，readlink，utime

表头文件 #include
#include

定义函数 int lstat (const char * file_name.struct stat * buf);

函数说明 lstat()与stat()作用完全相同，都是取得参数file_name所指的文件状态，其差别在于，当文件为符号连接时，lstat()会返回该link本身的状态。详细内容请参考stat()。

返回值 执行成功则返回0，失败返回-1，错误代码存于errno。

范例 参考stat()。

　

opendir（打开目录）
相关函数 open，readdir，closedir，rewinddir，seekdir，telldir，scandir

表头文件 #include
#include

定义函数 dir * opendir(const char * name);

函数说明 opendir()用来打开参数name指定的目录，并返回dir*形态的目录流，和open()类似，接下来对目录的读取和搜索都要使用此返回值。

返回值 成功则返回dir* 型态的目录流，打开失败则返回null。

错误代码 eaccess 权限不足
emfile 已达到进程可同时打开的文件数上限。
enfile 已达到系统可同时打开的文件数上限。
enotdir 参数name非真正的目录
enoent 参数name 指定的目录不存在，或是参数name 为一空字符串。
enomem 核心内存不足。

　

readdir（读取目录）
相关函数 open，opendir，closedir，rewinddir，seekdir，telldir，scandir

表头文件 #include
#include

定义函数 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
#include
#include
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（取得符号连接所指的文件）
相关函数 stat，lstat，symlink

表头文件 #include

定义函数 int readlink(const char * path ,char * buf,size_t bufsiz);

函数说明 readlink()会将参数path的符号连接内容存到参数buf所指的内存空间，返回的内容不是以null作字符串结尾，但会将字符串的字符数返回。若参数bufsiz小于符号连接的内容长度，过长的内容会被截断。

返回值 执行成功则传符号连接所指的文件路径字符串，失败则返回-1，错误代码存于errno。

错误代码 eaccess 取文件时被拒绝，权限不够
einval 参数bufsiz 为负数
eio i/o 存取错误。
eloop 欲打开的文件有过多符号连接问题。
enametoolong 参数path的路径名称太长
enoent 参数path所指定的文件不存在
enomem 核心内存不足
enotdir 参数path路径中的目录存在但却非真正的目录。

　

remove（删除文件）
相关函数 link，rename，unlink

表头文件 #include

定义函数 int remove(const char * pathname);

函数说明 remove()会删除参数pathname指定的文件。如果参数pathname为一文件，则调用unlink()处理，若参数pathname为一目录，则调用rmdir()来处理。请参考unlink()与rmdir()。

返回值 成功则返回0，失败则返回-1，错误原因存于errno。

错误代码 erofs 欲写入的文件存在于只读文件系统内
efault 参数pathname指针超出可存取内存空间
enametoolong 参数pathname太长
enomem 核心内存不足
eloop 参数pathname有过多符号连接问题
eio i/o 存取错误。

　

rename（更改文件名称或位置）
相关函数 link，unlink，symlink

表头文件 #include

定义函数 int rename(const char * oldpath,const char * newpath);

函数说明 rename()会将参数oldpath 所指定的文件名称改为参数newpath所指的文件名称。若newpath所指定的文件已存在，则会被删除。

返回值 执行成功则返回0，失败返回-1，错误原因存于errno

范例 /* 设计一个dos下的rename指令rename 旧文件名新文件名*/
#include
void main(int argc,char **argv)
{
if(argc<3){
printf(“usage: %s old_name new_name/n”,argv[0]);
return;
}
printf(“%s=>%s”,argc[1],argv[2]);
if(rename(argv[1],argv[2]<0)
printf(“error!/n”);
else
printf(“ok!/n”);
}

　

rewinddir（重设读取目录的位置为开头位置）
相关函数 open，opendir，closedir，telldir，seekdir，readdir，scandir

表头文件 #include
#include

定义函数 void rewinddir(dir *dir);

函数说明 rewinddir()用来设置参数dir 目录流目前的读取位置为原来开头的读取位置。

返回值

错误代码 ebadf dir为无效的目录流

范例 #include
#include
#include
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（设置下回读取目录的位置）
相关函数 open，opendir，closedir，rewinddir，telldir，readdir，scandir

表头文件 #include

定义函数 void seekdir(dir * dir,off_t offset);

函数说明 seekdir()用来设置参数dir目录流目前的读取位置，在调用readdir()时便从此新位置开始读取。参数offset 代表距离目录文件开头的偏移量。

返回值

错误代码 ebadf 参数dir为无效的目录流

范例 #include
#include
#include
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 : .. offset: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（取得文件状态）
相关函数 fstat，lstat，chmod，chown，readlink，utime

表头文件 #include
#include

定义函数 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 lastaccess*/
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 （s3e） 是否为先进先出
s_issock （st_mode） 是否为socket
若一目录具有sticky 位（s_isvtx），则表示在此目录下的文件只能被该文件所有者、此目录所有者或root来删除或改名。

返回值 执行成功则返回0，失败返回-1，错误代码存于errno

错误代码 enoent 参数file_name指定的文件不存在
enotdir 路径中的目录存在但却非真正的目录
eloop 欲打开的文件有过多符号连接问题，上限为16符号连接
efault 参数buf为无效指针，指向无法存在的内存空间
eaccess 存取文件时被拒绝
enomem 核心内存不足
enametoolong 参数file_name的路径名称太长

范例 #include
#include
mian()
{
struct stat buf;
stat (“/etc/passwd”,&buf);
printf(“/etc/passwd file size = %d /n”,buf.st_size);
}

执行 /etc/passwd file size = 705

　

symlink（建立文件符号连接）
相关函数 link，unlink

表头文件 #include

定义函数 int symlink( const char * oldpath,const char * newpath);

函数说明 symlink()以参数newpath指定的名称来建立一个新的连接(符号连接)到参数oldpath所指定的已存在文件。参数oldpath指定的文件不一定要存在，如果参数newpath指定的名称为一已存在的文件则不会建立连接。

返回值 成功则返回0，失败返回-1，错误原因存于errno。

错误代码 eperm 参数oldpath与newpath所指的文件系统不支持符号连接
erofs 欲测试写入权限的文件存在于只读文件系统内
efault 参数oldpath或newpath指针超出可存取内存空间。
enametoolong 参数oldpath或newpath太长
enomem 核心内存不足
eexist 参数newpath所指的文件名已存在。
emlink 参数oldpath所指的文件已达到最大连接数目
eloop 参数pathname有过多符号连接问题
enospc 文件系统的剩余空间不足
eio i/o 存取错误

范例 #include
main()
{
symlink(“/etc/passwd”,”pass”);
}

# linux
Logo
开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

操作系统大会&openEuler Summit 2024参会指南，请查收！

avatar 开放原子开发者工作坊

推动工业软件核心技术攻关，开源工业软件算法集成大赛正式启动！

推动工业软件核心技术攻关，开源工业软件算法集成大赛正式启动！

avatar 开放原子开发者工作坊

第二届openEuler生态大会（中国·湖南）成功举办

10月30日，第二届openEuler生态大会（中国·湖南）成功举办。

avatar 开放原子开发者工作坊