字符串拷貝和內存拷貝函數：
strcpy
strncpy
memcpy
memmove
memccpy
bcopy
字符串和內存數據比較函數：
strcmp
strcasecmp
strncasecmp
memcmp
strcoll
bcmp
連接字符串的函數：
strcat
strncat
查找字符/字符串的函數：
strstr
strchr
strrchr
memchr
其它相關的函數：
index
rindex
strlen
strdup
memset
bzero
strspn
strcspn
strpbrk
strtok
字符串拷貝和內存拷貝函數：
strcpy（拷貝字符串）
定義函數：char *strcpy( char *dest, const char *src );
strcpy()函數只能拷貝字符串。strcpy()函數將源字符串src的每個字節拷貝到目的字符串dest中，src字符串末尾的‘\0‘也被拷貝過去。strcpy()函數返回參數dest的起始地址。如果參數dest所指的內存空間不夠大，可能會造成緩沖溢出(buffer Overflow)的錯誤情況，在編寫程序時請特別留意，或者用strncpy()來取代。
strncpy（拷貝字符串）
定義函數：char *strncpy( char *dest, const char *src, size_t n );
strncpy()會將參數src字符串拷貝前n個字符至參數dest所指的地址。函數返回參數dest的字符串起始地址。
注意n的取值范圍，不要超過src和dest的長度。
#include<string.h>
#include<stdio.h>
int main()
{
char a1[30]="string(1)";
char b1[]="STRING(2)";
printf("before strcpy() : %s\n", a1 );
printf("after strcpy() : %s\n", strcpy( a1, b1 ) );
char a2[30]="string(1)";
char b2[]="STRING(2)";
printf("before strncpy() : %s\n", a2 );
printf("after strncpy() : %s\n", strncpy( a2, b2, 6 ) );
}
memcpy（拷貝內存內容）
定義函數：void * memcpy( void * dest, const void *src, size_t n );
memcpy()用來拷貝src所指的內存內容前n個字節到dest所指的內存地址上。與strcpy()不同的是，memcpy()會完整的復制n個字節，不會因為遇到字符串結束‘\0‘而結束。memcpy()函數可以拷貝任意類型的數據。memcpy()函數返回指向dest的指針。指針src和dest所指的內存區域不可重疊。在拷貝字符串時，通常都使用strcpy()函數；在拷貝其它數據(例如結構)時，通常都使用memcpy()函數。
memmove（拷貝內存內容）
定義函數：void *memmove(void *dest, const void *src, size_t n );
memmove()與memcpy()一樣都是用來拷貝src所指的內存內容前n個字節到dest所指的地址上。不同的是，當src和dest所指的內存區域重疊時，memmove()仍然可以正確的處理，不過執行效率上會比使用memcpy()略慢些。該函數返回指向dest的指針。
#include<string.h>
int main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strcpy() :%s\n", a );
printf("after strcpy() :%s\n", strcpy( a, b ) );
a[30]="string(1)";
b[]="string(2)";
printf("before strncpy() : %s\n", a );
printf("after strncpy() : %s\n", strncpy( a, b, 6 ) );
}
memccpy（拷貝內存內容）
定義函數：void * memccpy( void *dest, const void *src, int c, size_t n );
memccpy()用來拷貝src所指的內存內容前n個字節到dest所指的地址上。與memcpy()不同的是，memccpy()會在復制時檢查參數c是否出現，若是則返回dest中值為c的下一個字節地址。該函數返回指向dest中值為c的下一個字節指針。返回值為NULL表示在src所指內存前n個字節中沒有值為c的字節。
#include<string.h>
#include<stdio.h>
int main()
{
char a[]="string(a)";
char b[]="string(b)";
char *p;
p = ( char * )memccpy( a, b, ‘k‘, sizeof( b ) );
if( p == NULL )
{
//注意p為NULL的情況，這時不能讀取p所指的地方的內容
printf("the return pointer of mymccpy is null !\n");
}
else
{
printf("memccpy(): %s, *p = %c\n", a, *p );
}
}
bcopy（拷貝內存內容）
定義函數：void bcopy ( const void *src,void *dest ,int n);
bcopy()與memcpy()一樣都是用來拷貝src所指的內存內容前n個字節到dest所指的地址，不過參數src與dest在傳給函數時是相反的位置。建議使用memcpy()取代 。
字符串和內存數據比較函數：
strcmp（比較字符串）
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 的值。
strcoll（采用目前區域的字符排列次序來比較字符串）
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()作用完全相同。
strcasecmp（忽略大小寫比較字符串）
int strcasecmp ( const char *s1, const char *s2 );
strcasecmp()用來比較參數s1和s2字符串，比較時會自動忽略大小寫的差異。若參數s1和s2字符串相同則返回0，s1長度大于s2長度則返回大于0 的值，s1 長度若小于s2 長度則返回小于0的值。
strncasecmp（忽略大小寫比較字符串）
int strncasecmp( const char *s1, const char *s2, size_t n );
strncasecmp()用來比較參數s1和s2字符串前n個字符，比較時會自動忽略大小寫的差異。若參數s1和s2 字符串相同則返回0。s1 若大于s2則返回大于0的值，s1若小于s2則返回小于0 的值。
strcmpi()或stricmp()：對兩個字符串進行大小寫不敏感的比較。
strncmp()：對兩個字符串的一部分進行大小寫敏感的比較。
strnicmp()：對兩個字符串的一部分進行大小寫不敏感的比較。
#include <stdio.h>
#include <string.h>
int main()
{
char *a="aBcDeF";
char *b="AbCdEf";
char *c="aacdef";
char *d="ABCDEF";
printf("strcmpi(a,b) : %d\n",strcmpi(a,b));
printf("stricmp(a,b) : %d\n",stricmp(a,b));
printf("strcmp(a,d) : %d\n",strcmp(a,d));
printf("strncmp(a,b,3) : %d\n",strncmp(a,b,3));
printf("strnicmp(a,b,3) : %d\n",strnicmp(a,b,3));
getchar();
return 0;
}
memcmp（比較內存內容）
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的值。
bcmp（比較內存內容）
int bcmp ( const void *s1,const void * s2,int n);
bcmp()用來比較s1和s2所指的內存區間前n個字節，若參數n為0，則返回0。若參數s1 和s2 所指的內存內容都完全相同則返回0 值，否則返回非零值。 建議使用memcmp()取代。
#include <stdio.h>
#include <string.h>
int 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));
}
連接字符串的函數：
strcat（連接兩字符串）
char *strcat (char *dest, const char *src );
strcat()會將參數src字符串拷貝到參數dest所指的字符串尾。第一個參數dest要有足夠的空間來容納要拷貝的字符串。該函數返回參數dest的字符串起始地址。
strncat（連接兩字符串）
char * strncat( char *dest, const char *src, size_t n );
strncat()會將參數src字符串拷貝n個字符到參數dest所指的字符串尾。第一個參數dest要有足夠的空間來容納要拷貝的字符串。該函數返回參數dest的字符串起始地址。
#include<stdio.h>
#include<string.h>
int main()
{
//strcat
char a[30]="string1ABCDE";
char b[]="STRING2";
printf( "before strcat() : %s\n",a );
printf( "after strcat() : %s\n",strcat( a, b ) );
//strncat
char a1[30]="string1";
char b1[]="STRING2";
printf( "before strnact(): %s\n", a1 );
printf( "after strncat() : %s\n", strncat( a1, b1, 6 ) );
getchar();
return 0;
}
查找字符/字符串的函數：
strstr（在一字符串中查找指定的字符串）
char *strstr( const char *haystack, const char *needle );
strstr()會從字符串haystack中搜尋字符串needle，并將第一次出現的地址返回。返回指定字符串第一次出現的地址，否則返回NULL。
strchr（查找字符串中第一個出現的指定字符）
char *strchr( const char *s, int c );
strchr()用來找出參數s字符串中第一個出現的參數c地址，然后將該字符出現的地址返回。如果找到指定的字符則返回該字符所在地址，否則返回NULL。
strrchr（查找字符串中最后出現的指定字符）
char * strrchr( const char *s, int c );
strrchr()用來找出參數s字符串中最后一個出現的參數c地址，然后將該字符出現的地址返回。如果找到指定的字符則返回該字符所在地址，否則返回NULL。
memchr（在某一內存范圍中查找一特定字符）
void *memchr( const void *s, int c, size_t n );
memchr()從頭開始搜尋s所指的內存內容前n個字節，直到發現第一個值為c的字節，則返回指向該字節的指針。如果找到指定的字節則返回該字節的指針，否則返回NULL。
#include<stdio.h>
#include<string.h>
int main()
{
char *s = "0123456789012345678901234567890";
char *p;
p = strchr(s,‘9‘);
printf(" strchr(): %s\n",p);
p = strrchr(s,‘9‘);
printf("strrchr(): %s\n",p);
p = strstr(s,"901");
printf(" strstr(): %s\n",p);
p = (char *)memchr( s, ‘9‘, 10 );
printf(" memchr(): %s\n",p);
}
其它相關的函數：
index（查找字符串中第一個出現的指定字符）
char * index( const char *s, int c );
index()用來找出參數s字符串中第一個出現的參數c的地址，然后將該字符出現的地址返回。字符串結束字符(NULL)也視為字符串一部分。如果找到指定的字符則返回該字符所在地址，否則返回NULL。[用Dev-C++4.9.9.2調試時，提示index為定義，在linux下確認一下]
rindex（查找字符串中最后一個出現的指定字符）
char * rindex( const char *s, int c );
rindex()用來找出參數s字符串中最后一個出現的參數c的地址，然后將該字符出現的地址返回。字符串結束字符(NULL)也視為字符串一部分。如果找到指定的字符則返回該字符所在的地址，否則返回NULL。[用Dev-C++4.9.9.2調試時，提示rindex為定義，在linux下確認一下]
strlen（返回字符串長度）
size_t strlen( const char *s );
strlen()用來計算指定的字符串s的長度，不包括結束字符"\0"，該函數返回字符串s的字符數。
strdup（復制字符串）
char *strdup( const char *s );
strdup()會先用maolloc()配置與參數s字符串相同的空間大小，然后將參數s字符串的內容復制到該內存地址，然后把該地址返回。該地址最后可以利用free()來釋放。函數返回一字符串指針，該指針指向復制后的新字符串地址，若返回NULL表示內存不足。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
char a[] = "strdup";
char *b;
b = strdup( a );
printf("b[]=\"%s\"\n", b );
free(b);
return 0;
}
bzero（將一段內存內容全清為零）
void bzero(void *s,int n)；
bzero()會將參數s所指的內存區域前n個字節，全部設為零值。相當于調用memset((void*)s,0,size_tn);建議使用memset取代該函數。
memset（將一段內存空間填入某值）
void * memset (void *s ,int c, size_t n );
memset()會將參數s所指的內存區域前n個字節以參數c填入，然后返回指向s的指針。在編寫程序時，若需要將某一數組作初始化，memset()會相當方便。附加說明：參數c雖聲明為int，但必須是unsigned char，所以范圍在0到255之間。
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
char s[30];
memset (s,‘A‘,sizeof(s));
s[29]=‘\0‘;
for( int i = 0; i < 30; i++ )
{
printf("%d ", s[i] );
}
printf("\n%s\n",s);
memset (s,‘\0‘,sizeof(s));
for( int i = 0; i < 30; i++ )
{
printf("%d ", s[i] );
}
printf("\n\n%s\n",s);
return 0;
}
輸出結果為：
65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 65 0
AAAAAAAAAAAAAAAAAAAAAAAAAAAAA
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
strspn（返回字符串中連續含指定字符串內容的字符數）
size_t strspn( const char *s, const char *accept );
strspn()從參數s 字符串的開頭計算連續的字符，而這些字符都完全是accept 所指字符串中的字符。簡單的說，若strspn()返回的數值為n，則代表字符串s 開頭連續有n 個字符都是屬于字符串accept內的字符。該函數返回字符串s開頭連續包含字符串accept內的字符數目。
strcspn（返回字符串中連續不含指定字符串內容的字符數）
size_t strcspn( const char *s, const char *reject );
strcspn()從參數s字符串的開頭計算連續的字符，而這些字符都完全不在參數reject 所指的字符串中。簡單地說，若strcspn()返回的數值為n，則代表字符串s開頭連續有n個字符都不含字符串reject內的字符。該函數返回字符串s開頭連續不含字符串reject內的字符數目。
#include<stdio.h>
#include<string.h>
int main()
{
char *str="Linux was first developed for 386/486-based PCs.";
char *t1="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
printf( "strspn:\n%d\n",strspn( str,t1 ) );
printf( "strcspn: %d\n",strcspn( str, " " ) );
printf( "strcspn: %d\n",strcspn( str, "/-" ) );
printf( "strcspn: %d\n",strcspn( str, "1234567890" ) );
}
strpbrk（查找字符串中第一個出現的指定字符）
char *strpbrk( const char *s, const char *accept );
strpbrk()用來找出參數s 字符串中最先出現存在參數accept 字符串中的任意字符。如果找到指定的字符則返回該字符所在地址，否則返回NULL。[用Dev-C++4.9.9.2調試時，提示index為定義，在linux下確認一下]
strtok（分割字符串）
char * strtok( char *s, const char *delim );
strtok()用來將字符串分割成一個個片段。參數s指向欲分割的字符串，參數delim則為分割字符串，當strtok()在參數s的字符串中發現到參數delim的分割字符時則會將該字符改為\0 字符。在第一次調用時，strtok()必需給予參數s字符串，往后的調用則將參數s設置成NULL。每次調用成功則返回下一個分割后的字符串指針。如果已無從分割則返回NULL。
函數strtok()具有“破壞性”，它會在原字符串中插入NUL字符(如果原字符串還要做其它的改變，應該拷貝原字符串，并將這份拷貝傳遞給函數strtok())。函數strtok()是不能“重新進入”的，你不能在一個信號處理函數中調用strtok()函數，因為在下一次調用strtok()函數時它總是會“記住”上一次被調用時的某些參數。strtok()函數是一個古怪的函數，但它在分解以逗號或空白符分界的數據時是非常有用的。
#include<stdio.h>
#include<string.h>
static char s0[] = "Now is the time for all good men . . . " ;
static char s1[] = "abcde--ABCDE--fghij--FGHIJ";
int main()
{
char *p;
p = strtok( s0, " ");
while( p )
{
printf( "%s\n", p );
p = strtok( NULL, " " );
}
p = strtok( s1, "--");
while( p )
{
printf( "%s\n", p );
p = strtok( NULL, "--" );
}
getchar();
return 0;
}
輸出結果為：
Now
is
the
time
for
all
good
men
.
.
.
abcde
ABCDE
fghij
FGHIJ
