C字符串處理函數

1）字符串操做 
strcpy(p, p1) 複製字符串 
strncpy(p, p1, n) 複製指定長度字符串 
strcat(p, p1) 附加字符串 
strncat(p, p1, n) 附加指定長度字符串 
strlen(p) 取字符串長度 
strcmp(p, p1) 比較字符串 
strcasecmp忽略大寫和小寫比較字符串
strncmp(p, p1, n) 比較指定長度字符串 
strchr(p, c) 在字符串中查找指定字符 
strrchr(p, c) 在字符串中反向查找 
strstr(p, p1) 查找字符串 
strpbrk(p, p1) 以目標字符串的所有字符做爲集合，在當前字符串查找該集合的任一元素 
strspn(p, p1) 以目標字符串的所有字符做爲集合。在當前字符串查找不屬於該集合的任一元素的偏移 
strcspn(p, p1) 以目標字符串的所有字符做爲集合，在當前字符串查找屬於該集合的任一元素的偏移  
* 具備指定長度的字符串處理函數在已處理的字符串以後填補零結尾符 

2）字符串到數值類型的轉換 
strtod(p, ppend) 從字符串 p 中轉換 double 類型數值。並將興許的字符串指針存儲到 ppend 指向的 char* 類型存儲。

strtol(p, ppend, base) 從字符串 p 中轉換 long 類型整型數值，base 顯式設置轉換的整型進制。設置爲 0 以依據特定格式推斷所用進制。0x, 0X 前綴以解釋爲十六進制格式整型，0    前綴以解釋爲八進制格式整型
atoi(p) 字符串轉換到 int 整型 
atof(p) 字符串轉換到 double 符點數 
atol(p) 字符串轉換到 long 整型 

3）字符檢查 
isalpha() 檢查是否爲字母字符 
isupper() 檢查是否爲大寫字母字符 
islower() 檢查是否爲小寫字母字符 
isdigit() 檢查是否爲數字 
isxdigit() 檢查是否爲十六進制數字表示的有效字符 
isspace() 檢查是否爲空格類型字符 
iscntrl() 檢查是否爲控制字符 
ispunct() 檢查是否爲標點符號 
isalnum() 檢查是否爲字母和數字 
isprint() 檢查是不是可打印字符 
isgraph() 檢查是不是圖形字符。等效於 isalnum() | ispunct() 

4）函數原型
原型：strcpy(char destination[], const char source[]); 
功能：將字符串source複製到字符串destination中 
例程：  
 #include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
　 char str1[10] = { "TsinghuaOK"}; 
　 char str2[10] = { "Computer"}; 
　 cout <<strcpy(str1,str2)<<endl; 
}

執行結果是:Computer 
第二個字符串將覆蓋掉第一個字符串的所有內容！ 
注意：在定義數組時，字符數組1的字符串長度必須大於或等於字符串2的字符串長度。

不能用賦值語句將一個字符串常量或字符數組直接賦給一個字符數組。

所有字符串處理函數都包括在頭文件string.h中。

strncpy(char destination[], const char source[], int numchars);

strncpy：將字符串source中前numchars個字符複製到字符串destination中。 
strncpy函數應用舉例 
原型：strncpy(char destination[], const char source[], int numchars); 
功能：將字符串source中前numchars個字符複製到字符串destination中 
例程： 

#include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
　 char str1[10] = { "Tsinghua "}; 
　 char str2[10] = { "Computer"}; 
　 cout <<strncpy(str1,str2,3)<<endl; 
}

執行結果：Comnghua 
注意：字符串source中前numchars個字符將覆蓋掉字符串destination中前numchars個字符！

原型：strcat(char target[], const char source[]); 
功能：將字符串source接到字符串target的後面 
例程： 
#include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
　 char str1[] = { "Tsinghua "}; 
　 char str2[] = { "Computer"}; 
　 cout <<strcpy(str1,str2)<<endl; 
}

執行結果：Tsinghua Computer

注意：在定義字符數組1的長度時應該考慮字符數組2的長度，因爲鏈接後新字符串的長度爲兩個字符串長度之和。進行字符串鏈接後。字符串1的結尾符將本身主動被去掉。在結尾串末尾保留新字符串後面一個結尾符。

 

原型：strncat(char target[], const char source[], int numchars); 
功能：將字符串source的前numchars個字符接到字符串target的後面 
例程：

#include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
　 char str1[] = { "Tsinghua "}; 
　 char str2[] = { "Computer"}; 
　 cout <<strncat(str1,str2,3)<<endl; 
}

執行結果：Tsinghua Com

原型：int strcmp(const char firststring[], const char secondstring); 
功能：比較兩個字符串firststring和secondstring 
例程： 

#include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
　 char buf1[] = "aaa"; 
　 char buf2[] = "bbb"; 
　 char buf3[] = "ccc"; 
　 int ptr;  
　 ptr = strcmp(buf2,buf1);  
　 if(ptr > 0) 
　　 cout <<"Buffer 2 is greater than buffer 1"<<endl; 
　 else  
　　 cout <<"Buffer 2 is less than buffer 1"<<endl; 
　 ptr = strcmp(buf2,buf3);  
　 if(ptr > 0) 
　　 cout <<"Buffer 2 is greater than buffer 3"<<endl; 
　 else  
　　 cout <<"Buffer 2 is less than buffer 3"<<endl; 
}

執行結果是:Buffer 2 is less than buffer 1  
                  Buffer 2 is greater than buffer 3

原型：strlen( const char string[] ); 
功能：統計字符串string中字符的個數 
例程： 

#include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
  char str[100];  
  cout <<"請輸入一個字符串:"; 
  cin >>str; 
  cout <<"The length of the string is :"<<strlen(str)<<"個"<<endl; 
}

執行結果The length of the string is x (x爲你輸入的字符總數字)

注意：strlen函數的功能是計算字符串的實際長度。不包含'\0'在內。

另外。strlen函數也可以直接測試字符串常量的長度。如：strlen("Welcome")。

  
void *memset(void *dest, int c, size_t count);  
將dest前面count個字符置爲字符c.  返回dest的值. 

void *memmove(void *dest, const void *src, size_t count);  
從src複製count字節的字符到dest. 假設src和dest出現重疊, 函數會本身主動處理。

返回dest的值. 

void *memcpy(void *dest, const void *src, size_t count);  
從src複製count字節的字符到dest. 與memmove功能同樣, 僅僅是不能處理src和dest出現重疊。 返回dest的值. 

void *memchr(const void *buf, int c, size_t count);  
在buf前面count字節中查找首次出現字符c的位置. 找到了字符c或者已經搜尋了count個字節, 查找即中止. 操做成功則返回buf中首次出現c的位置指針, 不然返回NULL. 

void *_memccpy(void *dest, const void *src, int c, size_t count);  
從src複製0個或多個字節的字符到dest. 當字符c被複制或者count個字符被複制時, 複製中止. 

假設字符c被複制, 函數返回這個字符後面緊挨一個字符位置的指針. 不然返回NULL. 

int memcmp(const void *buf1, const void *buf2, size_t count);  
比較buf1和buf2前面count個字節大小.  
返回值< 0, 表示buf1小於buf2;  
返回值爲0, 表示buf1等於buf2;  
返回值> 0, 表示buf1大於buf2. 

int memicmp(const void *buf1, const void *buf2, size_t count); 

比較buf1和buf2前面count個字節. 與memcmp不一樣的是, 它不區分大寫和小寫. 

返回值同上. 

char *strrev(char *string);  
將字符串string中的字符順序顛倒過來. NULL結束符位置不變.  返回調整後的字符串的指針. 

char *_strupr(char *string);  
將string中所有小寫字母替換成對應的大寫字母, 其餘字符保持不變.  返回調整後的字符串的指針. 

char *_strlwr(char *string);  
將string中所有大寫字母替換成對應的小寫字母, 其餘字符保持不變.  返回調整後的字符串的指針. 

char *strchr(const char *string, int c);  
查找字  串string中首次出現的位置, NULL結束符也包括在查找中.  返回一個指針, 指向字符c在字符串string中首次出現的位置, 假設沒有找到, 則返回NULL. 

char *strrchr(const char *string, int c);  
查找字符c在字符串string中最後一次出現的位置, 也就是對string進行反序搜索, 包括NULL結束符.  
返回一個指針, 指向字符c在字符串string中最後一次出現的位置, 假設沒有找到, 則返回NULL. 

char *strstr(const char *string, const char *strSearch);  
在字符串string中查找strSearch子串.  返回子串strSearch在string中首次出現位置的指針. 假設沒有找到子串strSearch, 則返回NULL. 假設子串strSearch爲空串, 函數返回string值. 

char *strdup(const char *strSource);  
函數執行中會本身調用malloc函數爲複製strSource字符串分配存儲空間, 而後再將strSource拷貝到分配到的空間中. 注意要及時釋放這個分配的空間. 
返回一個指針, 指向爲複製字符串分配的空間; 假設分配空間失敗, 則返回NULL值. 

char *strcat(char *strDestination, const char *strSource);  
將源串strSource加入到目標串strDestination後面, 並在獲得的新串後面加上NULL結束符. 源串strSource的字符會覆蓋目標串strDestination後面的結束符NULL. 在字符串的複製或加入過程當中沒有溢出檢查, 因此要保證目標串空間足夠大. 不能處理源串與目標串重疊的狀況.  函數返回strDestination值. 

char *strncat(char *strDestination, const char *strSource, size_t count); 
將源串strSource開始的count個字符加入到目標串strDest後. 源串strSource的字符會覆蓋目標串strDestination後面的結束符NULL. 假設count大於源串長度, 則會用源串的長度值替換count值. 獲得的新串後面會本身主動加上NULL結束符. 與strcat函數同樣, 本函數不能處理源串與目標串重疊的狀況. 函數返回strDestination值. 

char *strcpy(char *strDestination, const char *strSource);  
複製源串strSource到目標串strDestination所指定的位置, 包括NULL結束符. 不能處理源串與目標串重疊的狀況.函數返回strDestination值. 

char *strncpy(char *strDestination, const char *strSource, size_t count); 
將源串strSource開始的count個字符拷貝到目標串strDestination所指定的位置. 假設count值小於或等於strSource串的長度, 不會本身主動加入NULL結束符目標串中, 而count大於strSource串的長度時, 則將strSource用NULL結束符填充補齊count個字符, 拷貝到目標串中. 不能處理源串與目標串重疊的狀況.函數返回strDestination值. 

char *strset(char *string, int c);  
將string串的所有字符設置爲字符c, 遇到NULL結束符中止. 函數返回內容調整後的string指針. 

char *strnset(char *string, int c, size_t count);  
將string串開始count個字符設置爲字符c, 假設count值大於string串的長度, 將用string的長度替換count值. 函數返回內容調整後的string指針. 

size_t strspn(const char *string, const char *strCharSet);  
查找不論什麼一個不包括在strCharSet串中的字符 (字符串結束符NULL除外) 在string串中首次出現的位置序號.  返回一個整數值, 指定在string中全部由characters中的字符組成的子串的長度. 假設string以一個不包括在strCharSet中的字符開頭, 函數將返回0值. 

size_t strcspn(const char *string, const char *strCharSet);  
查找strCharSet串中不論什麼一個字符在string串中首次出現的位置序號, 包括字符串結束符NULL.  
返回一個整數值, 指定在string中全部由非characters中的字符組成的子串的長度. 假設string以一個包括在strCharSet中的字符開頭, 函數將返回0值. 

char *strspnp(const char *string, const char *strCharSet);  
查找不論什麼一個不包括在strCharSet串中的字符 (字符串結束符NULL除外) 在string串中首次出現的位置指針. 返回一個指針, 指向非strCharSet中的字符在string中首次出現的位置. 

char *strpbrk(const char *string, const char *strCharSet);  
查找strCharSet串中不論什麼一個字符在string串中首次出現的位置, 不包括字符串結束符NULL.  
返回一個指針, 指向strCharSet中任一字符在string中首次出現的位置. 假設兩個字符串參數不含一樣字符, 則返回NULL值. 

int strcmp(const char *string1, const char *string2);  
比較字符串string1和string2大小.  
返回值< 0, 表示string1小於string2;  
返回值爲0, 表示string1等於string2;  
返回值> 0, 表示string1大於string2. 

int stricmp(const char *string1, const char *string2);  
比較字符串string1和string2大小，和strcmp不一樣, 比較的是它們的小寫字母版本號.返回值與strcmp一樣. 

int strcmpi(const char *string1, const char *string2);  
等價於stricmp函數, 僅僅是提供一個向後兼容的版本號. 

int strncmp(const char *string1, const char *string2, size_t count);  
比較字符串string1和string2大小，僅僅比較前面count個字符. 比較過程當中, 不論什麼一個字符串的長度小於count, 則count將被較短的字符串的長度代替. 此時假設兩串前面的字符都相等, 則較短的串要小. 
返回值< 0, 表示string1的子串小於string2的子串;  
返回值爲0, 表示string1的子串等於string2的子串;  
返回值> 0, 表示string1的子串大於string2的子串. 

int strnicmp(const char *string1, const char *string2, size_t count); 
比較字符串string1和string2大小。僅僅比較前面count個字符. 與strncmp不一樣的是, 比較的是它們的小寫字母版本號.  返回值與strncmp一樣. 

char *strtok(char *strToken, const char *strDelimit);  
在strToken 串中查找下一個標記, strDelimit字符集則指定了在當前查找調用中可能遇到的分界符. 返回一個指針, 指向在strToken中找到的下一個標記. 假設找不到標記, 就返回NULL值. 每次調用都會改動strToken內容, 用NULL字符替換遇到的每個分界符.

c++概念字符串操做 

1、char_traits 字符特徵類 
1）意義：包裝特定串元素的通用行爲界面，以便容器實現時根據特徵信息而運行特定行爲 
2）定義了通用類型名 

typedef _Elem char_type; 
typedef int int_type; 
typedef streampos pos_type; 
typedef streamoff off_type; 
typedef mbstate_t state_type; 

當中 int_type 表示字符元素轉換到特定編碼時的整型表示，pos_type, off_type 分別做爲字符串索引和字符串元素偏移的類型，相似容器迭中的指針。迭代類型和指針，迭代器的偏移類型。最後的 state_type 用於存儲流狀態，如出錯。格式控制等等。

 

3）定義了字符 / 字符串操做的包裝界面。以便通用算法的調用 

assign(a, b) 定義將 b 字符賦值給 a 字符的過程，實現 a.operator = 的行爲 
eq(a, b) 定義 a 字符和 b 字符的相等關係。實現 a.operator == 的行爲 
lt(a, b) 定義 a 小於 b 的關係。實現 a.operator < 的行爲 
compare(a_ptr, b_ptr, cnt) 定義兩組字符串的比較。返回 int 類型。實現相似 memcmp 的行爲 
length(ptr) 定義取字符串長度，實現相似 strlen 的行爲 
copy(a_ptr, b_ptr, cnt) 定義兩組字符串的複製，實現相似 memcpy 的行爲 
move(a_ptr, b_ptr, cnt) 定義兩組字符串的不重疊複製。實現相似 memmove 的行爲 
assign(ptr, cnt, ch) 定義了填充字符串的過程，實現相似 memset 的行爲 
to_int_type(ch) 定義了 char_type 到 int_type 整型的轉換過程 
to_char_type(n) 定義了 int_type 到 char_type 字符型的轉換過程 
eq_int_type(a, b) 定義兩個和當前 char_type 類型相應的 int_type 的相等關係 
eof() 定義字符串結尾符，使用整型表示 
not_eof(n) 定義非字符串結尾符。若輸入結尾符，則返回 1。其它輸入返回原值，即老是不返回 eof() 

4）int_type 類型應是當前字符類型的整型編碼 

2、std::string 並不是序列容器，沒有 front() 和 back() 界面用於取出前端和尾端的元素，使用 std::string::operator [] 並傳遞 streampos 類型取得特定元素，如 std::string::size() - 1 做爲索引取得最後一個字符 

3、basic_string 支持的初始化 
1）默認初始化 
2）分配器 
3）複製構造 
4）局部複製 [_Roff, _Roff + _Count) 
5）局部複製 + 分配器 
6）C 字符串 [_Ptr, <null>) 
7）C 字符串 + _Count [_Ptr, _Ptr + _Count) 
8）C 字符串 + 分配器 
9）C 字符串 + _Count + 分配器 [_Ptr, _Ptr + _Count)

10）_Count * _Ch 
11）_Count * _Ch + 分配器 
12）迭代器 [_ItF, _ItL) 
13）迭代器 + 分配器 

字符到串不能初始化，但支持 operator = 賦值和 operator += 累加賦值運算。 

4、字符串的區間有效性 
對串的索引訪問在超過字符串的有效區間時，因爲串的在實現上對內置的字符緩衝區運行下標訪問，因此不會致使異常，但是將獲得不可預知的結果，通常是不可用的。
將其它字符串做爲右值輸入時。對該串取出計數大於串大小時按串大小計算。 
std::basic_string::size_type 的實際類型爲 size_t，在 Visual C++ 7.1 中實現爲 unsigned。std::basic_string::npos 被靜態設定爲 

(basic_string<_Elem, _Traits, _Alloc>::size_type)(-1); 

在查找子字符串等操做時，函數返回 npos 的值表示非法索引。

 

5、比較字符串 
贊成的比較對象 
1）compare(s2) 其它同類型字符串 
2）compare(p) C 風格字符串 
3）compare(off, cnt, s2) [off, off + cnt) 同 s2 運行比較 
4）compare(off, cnt, s2, off2, cnt2) [off, off + cnt) 同 s2 [off2, cnt2) 運行比較 
5）compare(off, cnt, p) [off, off + cnt) 同 [p , <null>) 運行比較 
6）compare(off, cnt, p, cnt2) [off, off + cnt) 同 [p, p + cnt2) 運行比較 

返回 -1, 0, 1 做爲小於、等於和大於的比較結果。 

 6、附加數據 
1）使用 operator += 接受其它字符串。C 風格字符串和字符 
2）使用 push_back() 在尾部附加字符，並使得經過字符串構造的 back_iterator 可以訪問 
3）append() 附加 
        一、append(s) 追加字符串 
        二、append(s, off, cnt) 追加字符串 s [off, off + cnt) 
        三、append(p) 追加字符串 [p, <null>) 
        四、append(p, cnt) 追加字符串 [p, p + cnt) 
        五、append(n, c) 填充 n * c 
        六、append(InF, InL) 追加輸入流 [InF, InL) 

4）insert() 插入 
        一、insert(off, s2) 插入字符串 
        二、insert(off, s2, off2, cnt2) 插入字符串 s [off2, off2 + cnt2) 
        三、insert(off, p) 插入字符串 [p, <null>) 
        四、insert(off, p, cnt) 插入字符串 [p, p + cnt)

        五、insert(off, n, c) 插入 n * c 
        六、insert(iter) 元素默認值填充 
        七、insert(iter, c) 插入特定元素 
        八、insert(iter, n, c) 插入 n*c 
        九、insert(iter, InF, InL) 插入 [InF, InL) 

5）operator +(a, b) 
字符串關聯運算符重載中支持 operator + 的形式 
        一、s + s 
        二、s + p 
        三、s + c 
        四、p + s 
        五、c + s 

7、查找、替換和清除 
1）find() 查找 
        一、find(c, off) 在 s [off, npos) 中查找 c 
        二、find(p, off, n) 在 s [off, npos) 中查找 [p, p + n) 
        三、find(p, off) 在 s [off, npos) 中查找 [p, <null>) 
        四、find(s2, off) 在 s [off, npos) 中查找 s2 

2）find() 的變種 
        一、rfind() 具備 find() 的輸入形式。反序查找 
        二、find_first_of() 具備 find() 的輸入形式，返回第一個匹配的索引 
        三、find_last_of() 具備 find() 的輸入形式。返回倒數第一個匹配的索引 
        四、find_first_not_of() 具備 find() 的輸入形式。返回第一個不匹配的索引 
        五、find_last_not_of() 具備 find() 的輸入形式，返回倒數第一個不匹配的索引 

3）replace() 替換 
        一、replace(off, cnt, s2) 將 s [off, off + cnt) 替換成 s2 
        二、replace(off, cnt, s2, off2, cnt2) 將 s [off, off + cnt) 替換成 s2 [off2, off2 + cnt2)
        三、replace(off, cnt, p) 將 s [off, off + cnt) 替換成 [p, <null>) 
        四、replace(off, cnt, p, cnt2) 將 s [off, off + cnt) 替換成 [p, p + cnt2)

        五、replace(off, cnt, n, c) 將 s [off, off + cnt) 替換成 c * n 

使用迭代器的狀況： 
        六、replace(InF, InL, s2) 將 [InF, InL) 替換成 s2 
        七、replace(InF, InL, p) 將 [InF, InL) 替換成 [p, <null>) 
        八、replace(InF, InL, p, cnt) 將 [InF, InL) 替換成 [p, p + cnt) 
        九、replace(InF, InL, n, c) 將 [InF, InL) 替換成 n * c 
        十、replace(InF, InL, InF2, InL2) 將 [InF, InL) 替換成 [InF2, InL2) 

4）erase() 刪除 
        一、erase(off, cnt) 從字符串 s 中刪除 s [off, off + cnt) 
        二、erase(iter) 從字符串 s 中刪除 *iter 
        三、erase(ItF, ItL) 從字符串 s 中刪除 [ItF, ItL) 

8、取出字符串 
1）取得 C 風格字符串 
c_str() 返回常量類型的 C 風格字符串指針，copy(ptr, cnt, off = 0) 則將指定大小的字符串拷貝到特定指針。data() 在 Visual C++ 7.1 中只調用了 c_str() 實現。

 
2）取得子字符串 
substr(off, cnt) 取得 s [off, off + cnt) 的副本。  
3）複製子字符串 
copy(p, off, cnt) 將 s [off, off + cnt) 拷貝到 p。 

9、字符串的緩衝區管理 
字符串具備相似 std::vector 的緩衝區管理界面。  
size() 取得有效元素長度 
max_size() 取得當前內存分配器能分配的有效空間 
reserve() 爲緩衝區預留空間 
capacity() 取得緩衝區的容量 
resize() 重設串的長度，可以爲其指定初始化值 

  10、定義輸入迭代器的尾端 
向 istream_iterator 傳遞輸入流對象以建立輸入迭代器。輸入迭代器持有輸入流對象的指針，默認建立和讀取流失敗的狀況下該指針被設置爲 0。並且在實現輸入迭代器間的 operator == 相等運算時，進行持有的流對象指針的相等比較，這樣，默認建立的輸入迭代器將被用於匹配輸入流的結束。

 

* 當輸入流讀取失敗，用戶運行 if, while 條件推斷時，實際上先將推斷值轉換成 void* 類型，或者依據 operator ! 運算符的返回結果，對輸入流重載 operator void* 和 operator ! 運算符。可以定義輸入流在布爾表達式中的行爲，使得當流讀取失敗的狀況下。輸入迭代器可以經過布爾表達式來確認，而不是顯式訪問 fail() 成員函數.