[b]字元測試篇[/b]
isalnum（測試字元是否為英文或數字）
相關函式
isalpha，isdigit，islower，isupper
表頭檔案
#include<ctype.h>
定義函式
int isalnum (int c)
函式說明
檢查引數c是否為英文字母或阿拉伯數字，在標準c中相當於使用“isalpha(c) || isdigit(c)”做測試。
返回值
若引數c為字母或數字，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/* 找出str 字串中為英文字母或數字的字元*/
#include < ctype.h>
main()
{
char str[]=”[email protected]#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<ctype.h>
定義函式
int isalpha (int c)
函式說明
檢查引數c是否為英文字母，在標準c中相當於使用“isupper(c)||islower(c)”做測試。
返回值
若引數c為英文字母，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/* 找出str 字串中為英文字母的字元*/
#include <ctype.h>
main()
{
char str[]=”

[email protected]#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 <ctype.h>
定義函式
int isascii(int c);
函式說明
檢查引數c是否為ASCII碼字元，也就是判斷c的範圍是否在0到127之間。
返回值
若引數c為ASCII碼字元，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/* 判斷int i是否具有對映的ASCII碼字元*/
#include<ctype.h>
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 <ctype.h>
定義函式
int iscntrl(int c)；
函式說明
檢查引數c是否為ASCII控制碼，也就是判斷c的範圍是否在0到30之間。
返回值
若引數c為ASCII控制碼，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
　



isdigit（測試字元是否為阿拉伯數字）
相關函式
isxdigit
表頭檔案
#include<ctype.h>
定義函式
int isdigit(int c)
函式說明
檢查引數c是否為阿拉伯數字0到9。
返回值
若引數c為阿拉伯數字，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/* 找出str字串中為阿拉伯數字的字元*/
#include<ctype.h>
main()
{
char str[]="

[email protected]#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 <ctype.h>
定義函式
int isgraph (int c)
函式說明
檢查引數c是否為可列印字元，若c所對映的ASCII碼可列印，且非空格字元則返回TRUE。
返回值
若引數c為可列印字元，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/* 判斷str字串中哪些為可列印字元*/
#include<ctype.h>
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<ctype.h>
定義函式
int islower(int c)
函式說明
檢查引數c是否為小寫英文字母。
返回值
若引數c為小寫英文字母，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
#include<ctype.h>
main()
{
char str[]="[email protected]#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<ctype.h>
定義函式
int isprint(int c);
函式說明
檢查引數c是否為可列印字元，若c所對映的ASCII碼可列印，其中包含空格字元，則返回TRUE。
返回值
若引數c為可列印字元，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/* 判斷str字串中哪些為可列印字元包含空格字元*/
#include<ctype.h>
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<ctype.h>
定義函式
int isspace(int c)
函式說明
檢查引數c是否為空格字元，也就是判斷是否為空格('')、定位字元('\t')、CR('\r')、換行('\n')、垂直定位字元('\v')或翻頁('\f')的情況。
返回值
若引數c為空格字元，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/*將字串str[]中內含的空格字元找出，並顯示空格字元的ASCII碼*/
#include <ctype.h>
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<ctype.h>
定義函式
int ispunct(int c)
函式說明
檢查引數c是否為標點符號或特殊符號。返回TRUE也就是代表引數c為非空格、非數字和非英文字母。
返回值
v若引數c為標點符號或特殊符號，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/*列出字串str中的標點符號或特殊符號*/
#include <ctype.h>
main()
{
char str[]="[email protected] #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<ctype.h>
定義函式
int isupper(int c)
函式說明
檢查引數c是否為大寫英文字母。
返回值
若引數c為大寫英文字母，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/*找出字串str中為大寫英文字母的字元*/
#include <ctype.h>
main()
{
char str[]="[email protected]#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<ctype.h>
定義函式
int isxdigit (int c)
函式說明
檢查引數c是否為16進位制數字，只要c為下列其中一個情況則返回TRUE。16進位制數字:0123456789ABCDEF。
返回值
若引數c為16進位制數字，則返回TRUE，否則返回NULL(0)。
附加說明
此為巨集定義，非真正函式。
範例
/*找出字串str中為十六進位制數字的字元*/
#include <ctype.h>
main()
{
char str[]="[email protected]#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

[b]字串轉換篇[/b]
　



atof（將字串轉換成浮點型數）
相關函式
atoi，atol，strtod，strtol，strtoul
表頭檔案
#include <stdlib.h>
定義函式
double atof(const char *nptr);
函式說明
atof()會掃描引數nptr字串，跳過前面的空格字元，直到遇上數字或正負符號才開始做轉換，而再遇到非數字或字串結束時('\0')才結束轉換，並將結果返回。引數nptr字串可包含正負號、小數點或E(e)來表示指數部分，如123.456或123e-2。
返回值
返回轉換後的浮點型數。
附加說明
atof()與使用strtod(nptr,(char**)NULL)結果相同。
範例
/* 將字串a 與字串b轉換成數字後相加*/
#include<stdlib.h>
main()
{
char *a=”-100.23”;
char *b=”200e-2”;
float c;
c=atof(a)+atof(b);
printf(“c=%.2f\n”,c);
}
執行
c=-98.23
　



atoi（將字串轉換成整型數）
相關函式
atof，atol，atrtod，strtol，strtoul
表頭檔案
#include<stdlib.h>
定義函式
int atoi(const char *nptr);
函式說明
atoi()會掃描引數nptr字串，跳過前面的空格字元，直到遇上數字或正負符號才開始做轉換，而再遇到非數字或字串結束時('\0')才結束轉換，並將結果返回。
返回值
返回轉換後的整型數。
附加說明
atoi()與使用strtol(nptr，(char**)NULL，10)；結果相同。
範例
/* 將字串a 與字串b轉換成數字後相加*/
#include<stdlib.h>
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<stdlib.h>
定義函式
long atol(const char *nptr);
函式說明
atol()會掃描引數nptr字串，跳過前面的空格字元，直到遇上數字或正負符號才開始做轉換，而再遇到非數字或字串結束時('\0')才結束轉換，並將結果返回。
返回值
返回轉換後的長整型數。
附加說明
atol()與使用strtol(nptr,(char**)NULL,10)；結果相同。
範例
/*將字串a與字串b轉換成數字後相加*/
#include<stdlib.h>
main()
{
char a[]=”1000000000”;
char b[]=” 234567890”;
long c;
c=atol(a)+atol(b);
printf(“c=%d\n”,c);
}
執行
c=1234567890
　



gcvt（將浮點型數轉換為字串，取四捨五入）
相關函式
ecvt，fcvt，sprintf
表頭檔案
#include<stdlib.h>
定義函式
char *gcvt(double number，size_t ndigits，char *buf);
函式說明
gcvt()用來將引數number轉換成ASCII碼字串，引數ndigits表示顯示的位數。gcvt()與ecvt()和fcvt()不同的地方在於，gcvt()所轉換後的字串包含小數點或正負符號。若轉換成功，轉換後的字串會放在引數buf指標所指的空間。
返回值
返回一字串指標，此地址即為buf指標。
附加說明

範例
#include<stdlib.h>
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<stdlib.h>
定義函式
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<stdlib.h>
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<stdlib.h>
定義函式
long int strtol(const char *nptr,char **endptr,int base);
函式說明
strtol()會將引數nptr字串根據引數base來轉換成長整型數。引數base範圍從2至36，或0。引數base代表採用的進位制方式，如base值為10則採用10進位制，若base值為16則採用16進位制等。當base值為0時則是採用10進製做轉換，但遇到如'0x'前置字元則會使用16進製做轉換。一開始strtol()會掃描引數nptr字串，跳過前面的空格字元，直到遇上數字或正負符號才開始做轉換，再遇到非數字或字串結束時('\0')結束轉換，並將結果返回。若引數endptr不為NULL，則會將遇到不合條件而終止的nptr中的字元指標由endptr返回。
返回值
返回轉換後的長整型數，否則返回ERANGE並將錯誤程式碼存入errno中。
附加說明
ERANGE指定的轉換字串超出合法範圍。
範例
/* 將字串a，b，c 分別採用10，2，16進位制轉換成數字*/
#include<stdlib.h>
main()
{
char a[]=”1000000000”;
char b[]=”1000000000”;
char c[]=”ffff”;
printf(“a=%d\n”,strtol(a,NULL,10));
printf(“b=%d\n”,strtol(b,NULL,2));
printf(“c=%d\n”,strtol(c,NULL,16));
}
執行
a=1000000000
b=512
c=65535
　



strtoul（將字串轉換成無符號長整型數）
相關函式
atof，atoi，atol，strtod，strtol
表頭檔案
#include<stdlib.h>
定義函式
unsigned long int strtoul(const char *nptr,char **endptr,int base);
函式說明
strtoul()會將引數nptr字串根據引數base來轉換成無符號的長整型數。引數base範圍從2至36，或0。引數base代表採用的進位制方式，如base值為10則採用10進位制，若base值為16則採用16進位制數等。當base值為0時則是採用10進製做轉換，但遇到如'0x'前置字元則會使用16進製做轉換。一開始strtoul()會掃描引數nptr字串，跳過前面的空格字串，直到遇上數字或正負符號才開始做轉換，再遇到非數字或字串結束時('\0')結束轉換，並將結果返回。若引數endptr不為NULL，則會將遇到不合條件而終止的nptr中的字元指標由endptr返回。
返回值
返回轉換後的長整型數，否則返回ERANGE並將錯誤程式碼存入errno中。
附加說明
ERANGE指定的轉換字串超出合法範圍。
範例
參考strtol()
　



toascii（將整型數轉換成合法的ASCII 碼字元）
相關函式
isascii，toupper，tolower
表頭檔案
#include<ctype.h>
定義函式
int toascii(int c)
函式說明
toascii()會將引數c轉換成7位的unsigned char值，第八位則會被清除，此字元即會被轉成ASCII碼字元。
返回值
將轉換成功的ASCII碼字元值返回。
範例
#include<stdlib.h>
main()
{
int a=217;
char b;
printf(“before toascii () : a value =%d(%c)\n”,a,a);
b=toascii(a);
printf(“after toascii() : a value =%d(%c)\n”,b,b);
}
執行
before toascii() : a value =217()
after toascii() : a value =89(Y)
　



tolower（將大寫字母轉換成小寫字母）
相關函式
isalpha，toupper
表頭檔案
#include<stdlib.h>
定義函式
int tolower(int c);
函式說明
若引數c為大寫字母則將該對應的小寫字母返回。
返回值
返回轉換後的小寫字母，若不須轉換則將引數c值返回。
附加說明

範例
/* 將s字串內的大寫字母轉換成小寫字母*/
#include<ctype.h>
main()
{
char s[]=”aBcDeFgH12345;!#$”;
int i;
printf(“before tolower() : %s\n”,s);
for(i=0;I<sizeof(s);i++)
s[i]=tolower(s[i]);
printf(“after tolower() : %s\n”,s);
}
執行
before tolower() : aBcDeFgH12345;!#$
after tolower() : abcdefgh12345;!#$
　



toupper（將小寫字母轉換成大寫字母）
相關函式
isalpha，tolower
表頭檔案
#include<ctype.h>
定義函式
int toupper(int c);
函式說明
若引數c為小寫字母則將該對映的大寫字母返回。
返回值
返回轉換後的大寫字母，若不須轉換則將引數c值返回。
附加說明

範例
/* 將s字串內的小寫字母轉換成大寫字母*/
#include<ctype.h>
main()
{
char s[]=”aBcDeFgH12345;!#$”;
int i;
printf(“before toupper() : %s\n”,s);
for(i=0;I<sizeof(s);i++)
s[i]=toupper(s[i]);
printf(“after toupper() : %s\n”,s);
}
執行
before toupper() : aBcDeFgH12345;!#$
after toupper() : ABCDEFGH12345;!#$
　
[b]記憶體控制篇[/b]
　



calloc（配置記憶體空間）
相關函式
malloc，free，realloc，brk
表頭檔案
#include <stdlib.h>
定義函式
void *calloc(size_t nmemb，size_t size);
函式說明
calloc()用來配置nmemb個相鄰的記憶體單位，每一單位的大小為size，並返回指向第一個元素的指標。這和使用下列的方式效果相同:malloc(nmemb*size);不過，在利用calloc()配置記憶體時會將記憶體內容初始化為0。
返回值
若配置成功則返回一指標，失敗則返回NULL。
範例
/* 動態配置10個struct test 空間*/
#include<stdlib.h>
struct test
{
int a[10];
char b[20];
}
main()
{
struct test *ptr=calloc(sizeof(struct test),10);
}
　



free（釋放原先配置的記憶體）
相關函式
malloc，calloc，realloc，brk
表頭檔案
#include<stdlib.h>
定義函式
void free(void *ptr);
函式說明
引數ptr為指向先前由malloc()、calloc()或realloc()所返回的記憶體指標。呼叫free()後ptr所指的記憶體空間便會被收回。假若引數ptr所指的記憶體空間已被收回或是未知的記憶體地址，則呼叫free()可能會有無法預期的情況發生。若引數ptr為NULL，則free()不會有任何作用。
　



getpagesize（取得記憶體分頁大小）
相關函式
sbrk
表頭檔案
#include<unistd.h>
定義函式
size_t getpagesize(void);
函式說明
返回一分頁的大小，單位為位元組（byte）。此為系統的分頁大小，不一定會和硬體分頁大小相同。
返回值
記憶體分頁大小。附加說明在Intel x86 上其返回值應為4096bytes。
範例
#include <unistd.h>
main()
{
printf(“page size = %d\n”,getpagesize( ) );
}
　



malloc（配置記憶體空間）
相關函式
calloc，free，realloc，brk
表頭檔案
#include<stdlib.h>
定義函式
void * malloc(size_t size);
函式說明
malloc()用來配置記憶體空間，其大小由指定的size決定。
返回值
若配置成功則返回一指標，失敗則返回NULL。
範例
void p = malloc(1024); /*配置1k的記憶體*/
　



mmap（建立記憶體對映）
相關函式
munmap，open
表頭檔案
#include <unistd.h>
#include <sys/mman.h>
定義函式
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<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<sys/mman.h>
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 :operator : /root:
games : x : 12 :100 : games :/usr/games:
gopher : x : 13 : 30 : gopher : /usr/lib/gopher-data:
ftp : x : 14 : 50 : FTP User : /home/ftp:
nobody : x :99: 99: Nobody : /:
xfs :x :100 :101 : X Font Server : /etc/xll/fs : /bin/false
gdm : x : 42 :42 : : /home/gdm: /bin/bash
kids : x : 500 :500 :/home/kids : /bin/bash
　



munmap（解除記憶體對映）
相關函式
mmap
表頭檔案
#include<unistd.h>
#include<sys/mman.h>
定義函式
int munmap(void *start,size_t length);
函式說明
munmap()用來取消引數start所指的對映記憶體起始地址，引數length則是欲取消的記憶體大小。當程序結束或利用exec相關函式來執行其他程式時，對映記憶體會自動解除，但關閉對應的檔案描述詞時不會解除對映。
返回值
如果解除對映成功則返回0，否則返回－1，錯誤原因存於errno中錯誤程式碼EINVAL
引數
start或length 不合法。
範例
參考mmap（）
　

[b]日期時間篇[/b]
　



asctime（將時間和日期以字串格式表示）
相關函式
time，ctime，gmtime，localtime
表頭檔案
#include<time.h>
定義函式
char * asctime(const struct tm * timeptr);
函式說明
asctime()將引數timeptr所指的tm結構中的資訊轉換成真實世界所使用的時間日期表示方法，然後將結果以字串形態返回。此函式已經由時區轉換成當地時間，字串格式為:“Wed Jun 30 21:49:08 1993\n”
返回值
若再呼叫相關的時間日期函式，此字串可能會被破壞。此函式與ctime不同處在於傳入的引數是不同的結構。
附加說明
返回一字串表示目前當地的時間日期。
範例
#include <time.h>
main()
{
time_t timep;
time (&timep);
printf(“%s”,asctime(gmtime(&timep)));
}
執行
Sat Oct 28 02:10:06 2000
　



ctime（將時間和日期以字串格式表示）
相關函式
time，asctime，gmtime，localtime
表頭檔案
#include<time.h>
定義函式
char *ctime(const time_t *timep);
函式說明
ctime()將引數timep所指的time_t結構中的資訊轉換成真實世界所使用的時間日期表示方法，然後將結果以字串形態返回。此函式已經由時區轉換成當地時間，字串格式為“Wed Jun 30 21 :49 :08 1993\n”。若再呼叫相關的時間日期函式，此字串可能會被破壞。
返回值
返回一字串表示目前當地的時間日期。
範例
#include<time.h>
main()
{
time_t timep;
time (&timep);
printf(“%s”,ctime(&timep));
}
執行
Sat Oct 28 10 : 12 : 05 2000
　



gettimeofday（取得目前的時間）
相關函式
time，ctime，ftime，settimeofday
表頭檔案
#include <sys/time.h>
#include <unistd.h>
定義函式
int gettimeofday ( struct timeval * tv , struct timezone * tz )
函式說明
gettimeofday()會把目前的時間有tv所指的結構返回，當地時區的資訊則放到tz所指的結構中。
timeval結構定義為:
struct timeval{
long tv_sec; /*秒*/
long tv_usec; /*微秒*/
};
timezone 結構定義為:
struct timezone{
int tz_minuteswest; /*和Greenwich 時間差了多少分鐘*/
int tz_dsttime; /*日光節約時間的狀態*/
};
上述兩個結構都定義在/usr/include/sys/time.h。tz_dsttime 所代表的狀態如下
DST_NONE /*不使用*/
DST_USA /*美國*/
DST_AUST /*澳洲*/
DST_WET /*西歐*/
DST_MET /*中歐*/
DST_EET /*東歐*/
DST_CAN /*加拿大*/
DST_GB /*大不列顛*/
DST_RUM /*羅馬尼亞*/
DST_TUR /*土耳其*/
DST_AUSTALT /*澳洲（1986年以後）*/
返回值
成功則返回0，失敗返回－1，錯誤程式碼存於errno。附加說明EFAULT指標tv和tz所指的記憶體空間超出存取許可權。
範例
#include<sys/time.h>
#include<unistd.h>
main(){
struct timeval tv;
struct timezone tz;
gettimeofday (&tv , &tz);
printf(“tv_sec; %d\n”, tv,.tv_sec) ;
printf(“tv_usec; %d\n”,tv.tv_usec);
printf(“tz_minuteswest; %d\n”, tz.tz_minuteswest);
printf(“tz_dsttime, %d\n”,tz.tz_dsttime);
}
執行
tv_sec: 974857339
tv_usec:136996
tz_minuteswest:-540
tz_dsttime:0
　



gmtime（取得目前時間和日期）
相關函式
time,asctime,ctime,localtime
表頭檔案
#include<time.h>
定義函式
struct tm*gmtime(const time_t*timep);
函式說明
gmtime()將引數timep 所指的time_t 結構中的資訊轉換成真實世界所使用的時間日期表示方法，然後將結果由結構tm返回。
結構tm的定義為
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};
int tm_sec 代表目前秒數，正常範圍為0-59，但允許至61秒
int tm_min 代表目前分數，範圍0-59
int tm_hour 從午夜算起的時數，範圍為0-23
int tm_mday 目前月份的日數，範圍01-31
int tm_mon 代表目前月份，從一月算起，範圍從0-11
int tm_year 從1900 年算起至今的年數
int tm_wday 一星期的日數，從星期一算起，範圍為0-6
int tm_yday 從今年1月1日算起至今的天數，範圍為0-365
int tm_isdst 日光節約時間的旗標
此函式返回的時間日期未經時區轉換，而是UTC時間。
返回值
返回結構tm代表目前UTC 時間
範例
#include <time.h>
main(){
char *wday[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
time_t timep;
struct tm *p;
time(&timep);
p=gmtime(&timep);
printf(“%d%d%d”,(1900+p->tm_year), (1+p->tm_mon),p->tm_mday);
printf(“%s%d;%d;%d\n”, wday[p->tm_wday], p->tm_hour, p->tm_min, p->tm_sec);
}
執行
2000/10/28 Sat 8:15:38
　



localtime（取得當地目前時間和日期）
相關函式
time, asctime, ctime, gmtime
表頭檔案
#include<time.h>
定義函式
struct tm *localtime(const time_t * timep);
函式說明
localtime()將引數timep所指的time_t結構中的資訊轉換成真實世界所使用的時間日期表示方法，然後將結果由結構tm返回。結構tm的定義請參考gmtime()。此函式返回的時間日期已經轉換成當地時區。
返回值
返回結構tm代表目前的當地時間。
範例
#include<time.h>
main(){
char *wday[]={“Sun”,”Mon”,”Tue”,”Wed”,”Thu”,”Fri”,”Sat”};
time_t timep;
struct tm *p;
time(&timep);
p=localtime(&timep); /*取得當地時間*/
printf (“%d%d%d ”, (1900+p->tm_year),( 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.h>
定義函式
time_t mktime(strcut tm * timeptr);
函式說明
mktime()用來將引數timeptr所指的tm結構資料轉換成從公元1970年1月1日0時0分0 秒算起至今的UTC時間所經過的秒數。
返回值
返回經過的秒數。
範例
/* 用time()取得時間（秒數），利用localtime()
轉換成struct tm 再利用mktine（）將struct tm轉換成原來的秒數*/
#include<time.h>
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<sys/time.h>
#include<unistd.h>
定義函式
int settimeofday ( const struct timeval *tv,const struct timezone *tz);
函式說明
settimeofday()會把目前時間設成由tv所指的結構資訊，當地時區資訊則設成tz所指的結構。詳細的說明請參考gettimeofday()。注意，只有root許可權才能使用此函式修改時間。
返回值
成功則返回0，失敗返回－1，錯誤程式碼存於errno。
錯誤程式碼
EPERM 並非由root許可權呼叫settimeofday（），許可權不夠。
EINVAL 時區或某個資料是不正確的，無法正確設定時間。
　



time（取得目前的時間）
相關函式
ctime，ftime，gettimeofday
表頭檔案
#include<time.h>
定義函式
time_t time(time_t *t);
函式說明
此函式會返回從公元1970年1月1日的UTC時間從0時0分0秒算起到現在所經過的秒數。如果t 並非空指標的話，此函式也會將返回值存到t指標所指的記憶體。
返回值
成功則返回秒數，失敗則返回((time_t)-1)值，錯誤原因存於errno中。
範例
#include<time.h>
mian()
{
int seconds= time((time_t*)NULL);
printf(“%d\n”,seconds);
}
執行
9.73E+08
　

記憶體及字串操作篇
　



bcmp（比較記憶體內容）
相關函式
bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp
表頭檔案
#include<string.h>
定義函式
int bcmp ( const void *s1,const void * s2,int n);
函式說明
bcmp()用來比較s1和s2所指的記憶體區間前n個位元組，若引數n為0，則返回0。
返回值
若引數s1 和s2 所指的記憶體內容都完全相同則返回0 值，否則返回非零值。
附加說明
建議使用memcmp()取代。
範例
參考memcmp()。
　



bcopy（拷貝記憶體內容）
相關函式
memccpy，memcpy，memmove，strcpy，ctrncpy
表頭檔案
#include <string.h>
定義函式
void bcopy ( const void *src,void *dest ,int n);
函式說明
bcopy()與memcpy()一樣都是用來拷貝src所指的記憶體內容前n個位元組到dest所指的地址，不過引數src與dest在傳給函式時是相反的位置。
返回值

附加說明
建議使用memcpy()取代
範例
#include<string.h>
main()
{
char dest[30]=”string(a)”;
char src[30]=”string\0string”;
int i;
bcopy(src,dest,30);/* src指標放在前*/
printf(bcopy(): “)
for(i=0;i<30;i++)
printf(“%c”,dest[i]);
memcpy(dest src,30); /*dest指標放在錢*/
printf(‘\nmemcpy() : “);
for(i=0;i<30;i++)
printf(“%c”,dest[i]);
執行
bcopy() : string string
memcpy() :string sring
　



bzero（將一段記憶體內容全清為零）
相關函式
memset，swab
表頭檔案
#include<string.h>
定義函式
void bzero(void *s,int n)；
函式說明
bzero()會將引數s所指的記憶體區域前n個位元組，全部設為零值。相當於呼叫memset((void*)s,0,size_tn);
返回值

附加說明
建議使用memset取代
範例
參考memset()。
　



index（查詢字串中第一個出現的指定字元）
相關函式
rindex，srechr，strrchr
表頭檔案
#include<string.h>
定義函式
char * index( const char *s, int c);
函式說明
index()用來找出引數s字串中第一個出現的引數c地址，然後將該字元出現的地址返回。字串結束字元(NULL)也視為字串一部分。
返回值
如果找到指定的字元則返回該字元所在地址，否則返回0。
範例
#include<string.h>
main()
{
char *s =”0123456789012345678901234567890”;
char *p;
p =index(s,’5’);
printf(%s\n”,p);
}
執行
5.68E+25
　



memccpy（拷貝記憶體內容）
相關函式
bcopy，memcpy，memmove，strcpy，strncpy
表頭檔案
#include<string.h>
定義函式
void * memccpy(void *dest, const void * src, int c,size_t n);
函式說明
memccpy()用來拷貝src所指的記憶體內容前n個位元組到dest所指的地址上。與memcpy()不同的是，memccpy()會在複製時檢查引數c是否出現，若是則返回dest中值為c的下一個位元組地址。
返回值
返回指向dest中值為c的下一個位元組指標。返回值為0表示在src所指記憶體前n個位元組中沒有值為c的位元組。
範例
#include<string.h>
main()
{
char a[]="string[a]";
char b[]="string(b)";
memccpy(a,b,'B',sizeof(b));
printf("memccpy():%s\n",a);
}
執行
memccpy():string(b)
　



memchr（在某一記憶體範圍中查詢一特定字元）
相關函式
index，rindex，strchr，strpbrk，strrchr，strsep，strspn，strstr
表頭檔案
#include<string.h>
定義函式
void * memchr(const void *s,int c,size_t n);
函式說明
memchr()從頭開始搜尋s所指的記憶體內容前n個位元組，直到發現第一個值為c的位元組，則返回指向該位元組的指標。
返回值
如果找到指定的位元組則返回該位元組的指標，否則返回0。
範例
#include <string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=memchr(s,'5',10);
printf("%s\n",p);
}
執行
5.68E+25
　



memcmp（比較記憶體內容）
相關函式
bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp
表頭檔案
#include<string.h>
定義函式
int memcmp (const void *s1,const void *s2,size_t n);
函式說明
memcmp()用來比較s1和s2所指的記憶體區間前n個字元。字串大小的比較是以ASCII碼錶上的順序來決定，次順序亦為字元的值。memcmp()首先將s1第一個字元值減去s2第一個字元的值，若差為0則再繼續比較下個字元，若差值不為0則將差值返回。例如，字串"Ac"和"ba"比較則會返回字元'A'(65)和'b'(98)的差值(－33)。
返回值
若引數s1和s2所指的記憶體內容都完全相同則返回0值。s1若大於s2則返回大於0的值。s1若小於s2則返回小於0的值。
範例
#include<string.h>
main()
{
char *a ="aBcDeF";
char *b="AbCdEf";
char *c="aacdef";
char *d="aBcDeF";
printf("memcmp(a,b):%d\n",memcmp((void*)a,(void*) b,6));
printf("memcmp(a,c):%d\n",memcmp((void*)a,(void*) c,6));
printf("memcmp(a,d):%d\n",memcmp((void*)a,(void*) d,6));
執行
memcmp(a,b):1 /*字串a>字串b，返回1*/
memcmp(a,c):-1 /* 字串a<字串c,返回－1*/
memcmp(a,d):0 /*字串a＝字串d，返回0*/
　



memcpy（拷貝記憶體內容）
相關函式
bcopy，memccpy，memcpy，memmove，strcpy，strncpy
表頭檔案
#include<string.h>
定義函式
void * memcpy (void * dest ,const void *src, size_t n);
函式說明
memcpy()用來拷貝src所指的記憶體內容前n個位元組到dest所指的記憶體地址上。與strcpy()不同的是，memcpy()會完整的複製n個位元組，不會因為遇到字串結束'\0'而結束。
返回值
返回指向dest的指標。
附加說明
指標src和dest所指的記憶體區域不可重疊。
範例
#include<string.h>
main()
{
char a[30]="string (a)";
char b[30]="string\0string";
int i;
strcpy(a,b);
printf("strcpy():");
for(i=0;i<30;i++)
printf("%c",a[i]);
memcpy(a,b,30);
printf("\nmemcpy() :");
for(i=0;i<30;i++)
printf("%c",a[i]);
}
執行
strcpy() : string a )
memcpy() : string string
　



memmove（拷貝記憶體內容）
相關函式
bcopy，memccpy，memcpy，strcpy，strncpy
表頭檔案
#include<string.h>
定義函式
void * memmove(void *dest,const void *src,size_t n);
函式說明
memmove()與memcpy()一樣都是用來拷貝src所指的記憶體內容前n個位元組到dest所指的地址上。不同的是，當src和dest所指的記憶體區域重疊時，memmove()仍然可以正確的處理，不過執行效率上會比使用memcpy()略慢些。
返回值
返回指向dest的指標。
附加說明
指標src和dest所指的記憶體區域可以重疊。
範例
參考memcpy()。
　



memset（將一段記憶體空間填入某值）
相關函式
bzero，swab
表頭檔案
#include<string.h>
定義函式
void * memset (void *s ,int c, size_t n);
函式說明
memset()會將引數s所指的記憶體區域前n個位元組以引數c填入，然後返回指向s的指標。在編寫程式時，若需要將某一陣列作初始化，memset()會相當方便。
返回值
返回指向s的指標。
附加說明
引數c雖宣告為int， 但必須是unsigned char ，所以範圍在0到255之間。
範例
#include <string.h>
main()
{
char s[30];
memset (s,'A',sizeof(s));
s[30]='\0';
printf("%s\n",s);
}
執行
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
　



rindex（查詢字串中最後一個出現的指定字元）
相關函式
index，memchr，strchr，strrchr
表頭檔案
#include<string.h>
定義函式
char * rindex( const char *s,int c);
函式說明
rindex()用來找出引數s字串中最後一個出現的引數c地址，然後將該字元出現的地址返回。字串結束字元(NULL)也視為字串一部分。
返回值
如果找到指定的字元則返回該字元所在的地址，否則返回0。
範例
#include <string.h>
mian()
{
char *s ="0123456789012345678901234567890";
char *p;
p=rindex(s,'5');
printf("%s\n",p);
}
執行
567890
　



strcasecmp（忽略大小寫比較字串）
相關函式
bcmp，memcmp，strcmp，strcoll，strncmp
表頭檔案
#include<string.h>
定義函式
int strcasecmp (const char *s1, const char *s2);
函式說明
strcasecmp()用來比較引數s1和s2字串，比較時會自動忽略大小寫的差異。
返回值
若引數s1和s2字串相同則返回0。s1長度大於s2長度則返回大於0 的值，s1 長度若小於s2 長度則返回小於0的值。
範例
#include <string.h>
main()
{
char *a="aBcDeF";
char *b="AbCdEf";
if(!strcasecmp(a,b))
printf("%s=%s\n",a,b);
}
執行
aBcDeF=AbCdEf
　



strcat（連線兩字串）
相關函式
bcopy，memccpy，memcpy，strcpy，strncpy
表頭檔案
#include <string.h>
定義函式
char *strcat (char *dest,const char *src);
函式說明
strcat()會將引數src字串拷貝到引數dest所指的字串尾。第一個引數dest要有足夠的空間來容納要拷貝的字串。
返回值
返回引數dest的字串起始地址
範例
#include <string.h.>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strcat() : %s\n",a);
printf("after strcat() : %s\n",strcat(a,b));
}
執行
before strcat () : string(1)
after strcat () : string(1)string(2)
　



strchr（查詢字串中第一個出現的指定字元）
相關函式
index，memchr，rinex，strbrk，strsep，strspn，strstr，strtok
表頭檔案
#include<string.h>
定義函式
char * strchr (const char *s,int c);
函式說明
strchr()用來找出引數s字串中第一個出現的引數c地址，然後將該字元出現的地址返回。
返回值
如果找到指定的字元則返回該字元所在地址，否則返回0。
範例
#include<string.h>
main()
{
char *s=0123456789012345678901234567890”;
char *p;
p=strchr(s,'5');
printf("%s\n",p);
}
執行
5.68E+25
　



strcmp（比較字串）
相關函式
bcmp，memcmp，strcasecmp，strncasecmp，strcoll
表頭檔案
#include<string.h>
定義函式
int strcmp(const char *s1,const char *s2);
函式說明
strcmp()用來比較引數s1和s2字串。字串大小的比較是以ASCII 碼錶上的順序來決定，此順序亦為字元的值。strcmp()首先將s1第一個字元值減去s2第一個字元值，若差值為0則再繼續比較下個字元，若差值不為0則將差值返回。例如字串"Ac"和"ba"比較則會返回字元"A"(65)和'b'(98)的差值(－33)。
返回值
若引數s1和s2字串相同則返回0。s1若大於s2則返回大於0的值。s1若小於s2則返回小於0 的值。
範例
#include<string.h>
main()
{
char *a="aBcDeF";
char *b="AbCdEf";
char *c="aacdef";
char *d="aBcDeF";
printf("strcmp(a,b) : %d\n",strcmp(a,b));
printf("strcmp(a,c) : %d\n",strcmp(a,c));
printf("strcmp(a,d) : %d\n",strcmp(a,d));
}
執行
strcmp(a,b) : 32
strcmp(a,c) :-31
strcmp(a,d) : 0
　



strcoll（採用目前區域的字元排列次序來比較字串）
相關函式
strcmp，bcmp，memcmp，strcasecmp，strncasecmp
表頭檔案
#include<string.h>
定義函式
int strcoll( const char *s1, const char *s2);
函式說明
strcoll()會依環境變數LC_COLLATE所指定的文字排列次序來比較s1和s2 字串。
返回值
若引數s1和s2字串相同則返回0。s1若大於s2則返回大於0的值。s1若小於s2則返回小於0 的值。
附加說明
若LC_COLLATE為"POSIX"或"C"，則strcoll()與strcmp()作用完全相同。
範例
參考strcmp()。
　



strcpy（拷貝字串）
相關函式
bcopy，memcpy，memccpy，memmove
表頭檔案
#include<string.h>
定義函式
char *strcpy(char *dest,const char *src);
函式說明
strcpy()會將引數src字串拷貝至引數dest所指的地址。
返回值
返回引數dest的字串起始地址。
附加說明
如果引數dest所指的記憶體空間不夠大，可能會造成緩衝溢位(buffer Overflow)的錯誤情況，在編寫程式時請特別留意，或者用strncpy()來取代。
範例
#include<string.h>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strcpy() :%s\n",a);
printf("after strcpy() :%s\n",strcpy(a,b));
}
執行
before strcpy() :string(1)
after strcpy() :string(2)
　



strcspn（返回字串中連續不含指定字串內容的字元數）
相關函式
strspn
表頭檔案
#inclued<string.h>
定義函式
size_t strcspn ( const char *s,const char * reject);
函式說明
strcspn()從引數s字串的開頭計算連續的字元，而這些字元都完全不在引數reject 所指的字串中。簡單地說，若strcspn()返回的數值為n，則代表字串s開頭連續有n個字元都不含字串reject內的字元。
返回值
返回字串s開頭連續不含字串reject內的字元數目。
範例
#include <string.h>
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<string.h>
定義函式
char * strdup( const char *s);
函式說明
strdup()會先用maolloc()配置與引數s字串相同的空間大小，然後將引數s字串的內容複製到該記憶體地址，然後把該地址返回。該地址最後可以利用free()來釋放。
返回值
返回一字串指標，該指標指向複製後的新字串地址。若返回NULL表示記憶體不足。
範例
#include<string.h>
main()
{
char a[]="strdup";
char *b;
b=strdup(a);
printf("b[ ]=\"%s\"\n",b);
}
執行
b[ ]="strdup"
　



strlen（返回字串長度）
相關函式

表頭檔案
#include<string.h>
定義函式
size_t strlen (const char *s);
函式說明
strlen()用來計算指定的字串s的長度，不包括結束字元"\0"。
返回值
返回字串s的字元數。
範例
/*取得字串str的長度*/
#include<string.h>
main()
{
char *str = "12345678";
printf("str length = %d\n", strlen(str));
}
執行
str length = 8
　



strncasecmp（忽略大小寫比較字串）
相關函式
bcmp，memcmp，strcmp，strcoll，strncmp
表頭檔案
#include<string.h>
定義函式
int strncasecmp(const char *s1,const char *s2,size_t n);
函式說明
strncasecmp()用來比較引數s1和s2字串前n個字元，比較時會自動忽略大小寫的差異。
返回值
若引數s1和s2 字串相同則返回0。s1 若大於s2則返回大於0的值，s1若小於s2則返回小於0 的值。
範例
#include<string.h>
main()
{
char *a="aBcDeF";
char *b="AbCdEf";
if(!strncasecmp(a,b))
printf("%s =%s\n",a,b);
}
執行
aBcDef=AbCdEf
　



strncat（連線兩字串）
相關函式
bcopy，memccpy，memecpy，strcpy，strncpy
表頭檔案
#inclue <string.h>
定義函式
char * strncat(char *dest,const char *src,size_t n);
函式說明
strncat()會將引數src字串拷貝n個字元到引數dest所指的字串尾。第一個引數dest要有足夠的空間來容納要拷貝的字串。
返回值
返回引數dest的字串起始地址。
範例
#include <string.h>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before 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<string.h>
定義函式
char * strncpy(char *dest,const char *src,size_t n);
函式說明
strncpy()會將引數src字串拷貝前n個字元至引數dest所指的地址。
返回值
返回引數dest的字串起始地址。
範例
#inclue <string.h>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strncpy() : %s\n",a);
printf("after strncpy() : %s\n",strncpy(a,b,6));
}
執行
before strncpy() : string(1)
after strncpy() : string(1)
　



strpbrk（查詢字串中第一個出現的指定字元）
相關函式
index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok
表頭檔案
#include <include.h>
定義函式
char *strpbrk(const char *s,const char *accept);
函式說明
strpbrk()用來找出引數s 字串中最先出現存在引數accept 字串中的任意字元。
返回值
如果找到指定的字元則返回該字元所在地址，否則返回0。
範例
#include <string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=strpbrk(s,"a1 839"); /*1會最先在s字串中找到*/
printf("%s\n",p);
p=strprk(s,"4398");/*3 會最先在s 字串中找到*/
printf("%s\n",p);
執行
1.23E+29
　



strrchr（查詢字串中最後出現的指定字元）
相關函式
index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok
表頭檔案
#include<string.h>
定義函式
char * strrchr(const char *s, int c);
函式說明
strrchr()用來找出引數s字串中最後一個出現的引數c地址，然後將該字元出現的地址返回。
返回值
如果找到指定的字元則返回該字元所在地址，否則返回0。
範例
#include<string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=strrchr(s,'5');
printf("%s\n",p);
}
執行
567890
　



strspn（返回字串中連續不含指定字串內容的字元數）
相關函式
strcspn，strchr，strpbrk，strsep，strstr
表頭檔案
#include<string.h>
定義函式
size_t strspn (const char *s,const char * accept);
函式說明
strspn()從引數s 字串的開頭計算連續的字元，而這些字元都完全是accept 所指字串中的字元。簡單的說，若strspn()返回的數值為n，則代表字串s 開頭連續有n 個字元都是屬於字串accept內的字元。
返回值
返回字串s開頭連續包含字串accept內的字元數目。
範例
#include<string.h>
main()
{
char *str="Linux was first developed for 386/486-based PCs.";
char *t1="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
printf("%d\n",strspn(str,t1));
}
執行
5 /*計算大小寫字母。不包含“ ”，所以返回Linux的長度。*/
　



strstr（在一字串中查詢指定的字串）
相關函式
index，memchr，rindex，strchr，strpbrk，strsep，strspn，strtok
表頭檔案
#include<string.h>
定義函式
char *strstr(const char *haystack,const char *needle);
函式說明
strstr()會從字串haystack 中搜尋字串needle，並將第一次出現的地址返回。
返回值
返回指定字串第一次出現的地址，否則返回0。
範例
#include<string.h>
main()
{
char * s="012345678901234567890123456789";
char *p;
p= strstr(s,"901");
printf("%s\n",p);
}
執行
9.01E+21
　



strtok（分割字串）
相關函式
index，memchr，rindex，strpbrk，strsep，strspn，strstr
表頭檔案
#include<string.h>
定義函式
char * strtok(char *s,const char *delim);
函式說明
strtok()用來將字串分割成一個個片段。引數s指向欲分割的字串，引數delim則為分割字串，當strtok()在引數s的字串中發現到引數delim的分割字元時則會將該字元改為\0 字元。在第一次呼叫時，strtok()必需給予引數s字串，往後的呼叫則將引數s設定成NULL。每次呼叫成功則返回下一個分割後的字串指標。
返回值
返回下一個分割後的字串指標，如果已無從分割則返回NULL。
範例
#include<string.h>
main()
{
char s[]="ab-cd : ef;gh :i-jkl;mnop;qrs-tu: vwx-y;z";
char *delim="-: ";
char *p;
printf("%s ";strtok(s,delim));
while((p=strtok(NULL,delim)))printf("%s ",p);
printf("\n");
}
執行
ab cd ef;gh i jkl;mnop;qrs tu vwx y;z /*－與:字元已經被\0 字元取代*/
　

[b]常用數學函式篇[/b]
　



abs（計算整型數的絕對值）
相關函式
labs, fabs
表頭檔案
#include<stdlib.h>
定義函式
int abs (int j)
函式說明
abs()用來計算引數j的絕對值，然後將結果返回。
返回值
返回引數j的絕對值結果。
範例
#ingclude <stdlib.h>
main(){
int ansert;
answer = abs(-12);
printf("|-12| = %d\n", answer);
}
執行
|-12| = 12
　



acos（取反餘弦函式數值）
相關函式
asin , atan , atan2 , cos , sin , tan
表頭檔案
#include <math.h>
定義函式
double acos (double x);
函式說明
acos()用來計算引數x的反餘弦值，然後將結果返回。引數x範圍為－1至1之間，超過此範圍則會失敗。
返回值
返回0至PI之間的計算結果，單位為弧度，在函式庫中角度均以弧度來表示。
錯誤程式碼
EDOM引數x超出範圍。
附加說明
使用GCC編譯時請加入－lm。
範例
#include <math.h>
main (){
double angle;
angle = acos(0.5);
printf("angle = %f\n", angle);
}
執行
angle = 1.047198
　



asin（取反正弦函式值）
相關函式
acos , atan , atan2 , cos , sin , tan
表頭檔案
#include <math.h>
定義函式
double asin (double x)
函式說明
asin()用來計算引數x的反正弦值，然後將結果返回。引數x範圍為－1至1之間，超過此範圍則會失敗。
返回值
返回－PI/2之PI/2之間的計算結果。
錯誤程式碼
EDOM引數x超出範圍
附加說明
使用GCC編譯時請加入－lm
範例
#include<math.h>
main()
{
double angle;
angle = asin (0.5);
printf("angle = %f\n",angle);
}
執行
angle = 0.523599
　



atan（取反正切函式值）
相關函式
acos，asin，atan2，cos，sin，tan
表頭檔案
#include<math.h>
定義函式
double atan(double x);
函式說明
atan()用來計算引數x的反正切值，然後將結果返回。
返回值
返回-PI/2至PI/2之間的計算結果。
附加說明
使用GCC編譯時請加入-lm
範例
#include<math.h>
main()
{
double angle;
angle =atan(1);
printf("angle = %f\n",angle);
}
執行
angle = 1.570796
　



atan2（取得反正切函式值）
相關函式
acos，asin，atan，cos，sin，tan
表頭檔案
#include<math.h>
定義函式
double atan2(double y,double x);
函式說明
atan2()用來計算引數y/x的反正切值，然後將結果返回。
返回值
返回-PI 至PI 之間的計算結果。
附加說明
使用GCC編譯時請加入-lm。
範例
#include<math.h>
main()
{
double angle;
angle = atan2(1,2);
printf("angle = %f\n", angle);
}
執行
angle = 0.463648
　



ceil（取不小於引數的最小整型數）
相關函式
fabs
表頭檔案
#include <math.h>
定義函式
double ceil (double x);
函式說明
ceil()會返回不小於引數x的最小整數值，結果以double形態返回。
返回值
返回不小於引數x的最小整數值。
附加說明
使用GCC編譯時請加入-lm。
範例
#include<math.h>
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<math.h>
定義函式
double cos(double x);
函式說明
cos()用來計算引數x 的餘玄值，然後將結果返回。
返回值
返回-1至1之間的計算結果。
附加說明
使用GCC編譯時請加入-lm。
範例
#include<math.h>
main()
{
double answer = cos(0.5);
printf("cos (0.5) = %f\n",answer);
}
執行
cos(0.5) = 0.877583
　



cosh（取雙曲線餘玄函式值）
相關函式
sinh，tanh
表頭檔案
#include<math.h>
定義函式
double cosh(double x);
函式說明
cosh()用來計算引數x的雙曲線餘玄值，然後將結果返回。數學定義式為:(exp(x)+exp(-x))/2。
返回值
返回引數x的雙曲線餘玄值。
附加說明
使用GCC編譯時請加入-lm。
範例
#include<math.h>
main()
{
double answer = cosh(0.5);
printf("cosh(0.5) = %f\n",answer);
}
執行
cosh(0.5) = 1.127626
　



exp（計算指數）
相關函式
log，log10，pow
表頭檔案
#include<math.h>
定義函式
double exp(double x);
函式說明
exp()用來計算以e為底的x次方值，即ex值，然後將結果返回。
返回值
返回e的x次方計算結果。
附加說明
使用GCC編譯時請加入-lm。
範例
#include<math.h>
main()
{
double answer;
answer = exp (10);
printf("e^10 =%f\n", answer);
}
執行
e^10 = 22026.465795
　



frexp（將浮點型數分為底數與指數）
相關函式
ldexp，modf
表頭檔案
#include<math.h>
定義函式
double frexp( double x, int *exp);
函式說明
frexp()用來將引數x 的浮點型數切割成底數和指數。底數部分直接返回，指數部分則借引數exp 指標返回，將返回值乘以2 的exp次方即為x的值。
返回值
返回引數x的底數部分，指數部分則存於exp指標所指的地址。
附加說明
使用GCC編譯時請加入-lm。
範例
#include <math.h>
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<math.h>
定義函式
double ldexp(double x,int exp);
函式說明
ldexp()用來將引數x乘上2的exp次方值，即x*2exp。
返回值
返回計算結果。
附加說明
使用GCC編譯時請加入-lm。
範例:
/* 計算3*(2^2)＝12 */
#include<math.h>
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 <math.h>
定義函式
double log (double x);
函式說明
log（）用來計算以e為底的x 對數值，然後將結果返回。
返回值
返回引數x的自然對數值。
錯誤程式碼
EDOM 引數x為負數，ERANGE 引數x為零值，零的對數值無定義。
附加說明
使用GCC編譯時請加入-lm。
範例
#include<math.h>
main()
{
double answer;
answer = log (100);
printf("log(100) = %f\n",answer);
}
執行
log(100) = 4.605170
　



log10（計算以10 為底的對數值）
相關函式
exp，log