linux C語言庫函數（部分）

 

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 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 :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”);
}