trcpy(p, p1) 復(fù)制字符串
創(chuàng)新互聯(lián)公司是一家做網(wǎng)站、成都網(wǎng)站制作，提供網(wǎng)頁設(shè)計(jì)，網(wǎng)站設(shè)計(jì)，網(wǎng)站制作，建網(wǎng)站，按需網(wǎng)站開發(fā)，網(wǎng)站開發(fā)公司，自2013年創(chuàng)立以來是互聯(lián)行業(yè)建設(shè)者，服務(wù)者。以提升客戶品牌價(jià)值為核心業(yè)務(wù)，全程參與項(xiàng)目的網(wǎng)站策劃設(shè)計(jì)制作，前端開發(fā)，后臺程序制作以及后期項(xiàng)目運(yùn)營并提出專業(yè)建議和思路。
strncpy(p, p1, n) 復(fù)制指定長度字符串
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) 以目標(biāo)字符串的所有字符作為集合，在當(dāng)前字符串查找該集合的任一元素
strspn(p, p1) 以目標(biāo)字符串的所有字符作為集合，在當(dāng)前字符串查找不屬于該集合的任一元素的偏移
strcspn(p, p1) 以目標(biāo)字符串的所有字符作為集合，在當(dāng)前字符串查找屬于該集合的任一元素的偏移
* 具有指定長度的字符串處理函數(shù)在已處理的字符串之后填補(bǔ)零結(jié)尾符
2）字符串到數(shù)值類型的轉(zhuǎn)換
strtod(p, ppend) 從字符串 p 中轉(zhuǎn)換 double 類型數(shù)值，并將后續(xù)的字符串指針存儲到 ppend 指向的 char* 類型存儲。
strtol(p, ppend, base) 從字符串 p 中轉(zhuǎn)換 long 類型整型數(shù)值，base 顯式設(shè)置轉(zhuǎn)換的整型進(jìn)制，設(shè)置為 0 以根據(jù)特定格式判斷所用進(jìn)制，0x, 0X 前綴以解釋為十六進(jìn)制格式整型，0 前綴以解釋為八進(jìn)制格式整型
atoi(p) 字符串轉(zhuǎn)換到 int 整型
atof(p) 字符串轉(zhuǎn)換到 double 符點(diǎn)數(shù)
atol(p) 字符串轉(zhuǎn)換到 long 整型
3）字符檢查
isalpha() 檢查是否為字母字符
isupper() 檢查是否為大寫字母字符
islower() 檢查是否為小寫字母字符
isdigit() 檢查是否為數(shù)字
isxdigit() 檢查是否為十六進(jìn)制數(shù)字表示的有效字符
isspace() 檢查是否為空格類型字符
iscntrl() 檢查是否為控制字符
ispunct() 檢查是否為標(biāo)點(diǎn)符號
isalnum() 檢查是否為字母和數(shù)字
isprint() 檢查是否是可打印字符
isgraph() 檢查是否是圖形字符，等效于 isalnum() | ispunct()
4）函數(shù)原型
原型：strcpy(char destination[], const char source[]);
功能：將字符串source拷貝到字符串destination中
例程：
#include
#include
void main(void)
{
char str1[10] = { "TsinghuaOK"};
char str2[10] = { "Computer"};
cout strcpy(str1,str2)endl;
}
運(yùn)行結(jié)果是:Computer
第二個(gè)字符串將覆蓋掉第一個(gè)字符串的所有內(nèi)容！
注意：在定義數(shù)組時(shí)，字符數(shù)組1的字符串長度必須大于或等于字符串2的字符串長度。不能用賦值語句將一個(gè)字符串常量或字符數(shù)組直接賦給一個(gè)字符數(shù)組。所有字符串處理函數(shù)都包含在頭文件string.h中。
strncpy(char destination[], const char source[], int numchars);
strncpy：將字符串source中前numchars個(gè)字符拷貝到字符串destination中。
strncpy函數(shù)應(yīng)用舉例
原型：strncpy(char destination[], const char source[], int numchars);
功能：將字符串source中前numchars個(gè)字符拷貝到字符串destination中
例程：
#include
#include
void main(void)
{
char str1[10] = { "Tsinghua "};
char str2[10] = { "Computer"};
cout strncpy(str1,str2,3)endl;
}
運(yùn)行結(jié)果：Comnghua
注意：字符串source中前numchars個(gè)字符將覆蓋掉字符串destination中前numchars個(gè)字符！
原型：strcat(char target[], const char source[]);
功能：將字符串source接到字符串target的后面
例程：
#include
#include
void main(void)
{
char str1[] = { "Tsinghua "};
char str2[] = { "Computer"};
cout strcpy(str1,str2)endl;
}
運(yùn)行結(jié)果：Tsinghua Computer
注意：在定義字符數(shù)組1的長度時(shí)應(yīng)該考慮字符數(shù)組2的長度，因?yàn)檫B接后新字符串的長度為兩個(gè)字符串長度之和。進(jìn)行字符串連接后，字符串1的結(jié)尾符將自動(dòng)被去掉，在結(jié)尾串末尾保留新字符串后面一個(gè)結(jié)尾符。
原型：strncat(char target[], const char source[], int numchars);
功能：將字符串source的前numchars個(gè)字符接到字符串target的后面
例程：
#include
#include
void main(void)
{
char str1[] = { "Tsinghua "};
char str2[] = { "Computer"};
cout strncat(str1,str2,3)endl;
}
運(yùn)行結(jié)果：Tsinghua Com
原型：int strcmp(const char firststring[], const char secondstring);
功能：比較兩個(gè)字符串firststring和secondstring
例程：
#include
#include
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;
}
運(yùn)行結(jié)果是:Buffer 2 is less than buffer 1
Buffer 2 is greater than buffer 3
原型：strlen( const char string[] );
功能：統(tǒng)計(jì)字符串string中字符的個(gè)數(shù)
例程：
#include
#include
void main(void)
{
char str[100];
cout "請輸入一個(gè)字符串:";
cin str;
cout "The length of the string is :"strlen(str)"個(gè)"endl;
}
運(yùn)行結(jié)果The length of the string is x (x為你輸入的字符總數(shù)字)
注意：strlen函數(shù)的功能是計(jì)算字符串的實(shí)際長度，不包括'\0'在內(nèi)。另外，strlen函數(shù)也可以直接測試字符串常量的長度，如：strlen("Welcome")。
void *memset(void *dest, int c, size_t count);
將dest前面count個(gè)字符置為字符c. 返回dest的值.
void *memmove(void *dest, const void *src, size_t count);
從src復(fù)制count字節(jié)的字符到dest. 如果src和dest出現(xiàn)重疊, 函數(shù)會自動(dòng)處理. 返回dest的值.
void *memcpy(void *dest, const void *src, size_t count);
從src復(fù)制count字節(jié)的字符到dest. 與memmove功能一樣, 只是不能處理src和dest出現(xiàn)重疊. 返回dest的值.
void *memchr(const void *buf, int c, size_t count);
在buf前面count字節(jié)中查找首次出現(xiàn)字符c的位置. 找到了字符c或者已經(jīng)搜尋了count個(gè)字節(jié), 查找即停止. 操作成功則返回buf中首次出現(xiàn)c的位置指針, 否則返回NULL.
void *_memccpy(void *dest, const void *src, int c, size_t count);
從src復(fù)制0個(gè)或多個(gè)字節(jié)的字符到dest. 當(dāng)字符c被復(fù)制或者count個(gè)字符被復(fù)制時(shí), 復(fù)制停止.
如果字符c被復(fù)制, 函數(shù)返回這個(gè)字符后面緊挨一個(gè)字符位置的指針. 否則返回NULL.
int memcmp(const void *buf1, const void *buf2, size_t count);
比較buf1和buf2前面count個(gè)字節(jié)大小.
返回值 0, 表示buf1小于buf2;
返回值為0, 表示buf1等于buf2;
返回值 0, 表示buf1大于buf2.
int memicmp(const void *buf1, const void *buf2, size_t count);
比較buf1和buf2前面count個(gè)字節(jié). 與memcmp不同的是, 它不區(qū)分大小寫.
返回值同上.
char *strrev(char *string);
將字符串string中的字符順序顛倒過來. NULL結(jié)束符位置不變. 返回調(diào)整后的字符串的指針.
char *_strupr(char *string);
將string中所有小寫字母替換成相應(yīng)的大寫字母, 其它字符保持不變. 返回調(diào)整后的字符串的指針.
char *_strlwr(char *string);
將string中所有大寫字母替換成相應(yīng)的小寫字母, 其它字符保持不變. 返回調(diào)整后的字符串的指針.
char *strchr(const char *string, int c);
查找字 串string中首次出現(xiàn)的位置, NULL結(jié)束符也包含在查找中. 返回一個(gè)指針, 指向字符c在字符串string中首次出現(xiàn)的位置, 如果沒有找到, 則返回NULL.
char *strrchr(const char *string, int c);
查找字符c在字符串string中最后一次出現(xiàn)的位置, 也就是對string進(jìn)行反序搜索, 包含NULL結(jié)束符.
返回一個(gè)指針, 指向字符c在字符串string中最后一次出現(xiàn)的位置, 如果沒有找到, 則返回NULL.
char *strstr(const char *string, const char *strSearch);
在字符串string中查找strSearch子串. 返回子串strSearch在string中首次出現(xiàn)位置的指針. 如果沒有找到子串strSearch, 則返回NULL. 如果子串strSearch為空串, 函數(shù)返回string值.
char *strdup(const char *strSource);
函數(shù)運(yùn)行中會自己調(diào)用malloc函數(shù)為復(fù)制strSource字符串分配存儲空間, 然后再將strSource復(fù)制到分配到的空間中. 注意要及時(shí)釋放這個(gè)分配的空間.
返回一個(gè)指針, 指向?yàn)閺?fù)制字符串分配的空間; 如果分配空間失敗, 則返回NULL值.
char *strcat(char *strDestination, const char *strSource);
將源串strSource添加到目標(biāo)串strDestination后面, 并在得到的新串后面加上NULL結(jié)束符. 源串strSource的字符會覆蓋目標(biāo)串strDestination后面的結(jié)束符NULL. 在字符串的復(fù)制或添加過程中沒有溢出檢查, 所以要保證目標(biāo)串空間足夠大. 不能處理源串與目標(biāo)串重疊的情況. 函數(shù)返回strDestination值.
char *strncat(char *strDestination, const char *strSource, size_t count);
將源串strSource開始的count個(gè)字符添加到目標(biāo)串strDest后. 源串strSource的字符會覆蓋目標(biāo)串strDestination后面的結(jié)束符NULL. 如果count大于源串長度, 則會用源串的長度值替換count值. 得到的新串后面會自動(dòng)加上NULL結(jié)束符. 與strcat函數(shù)一樣, 本函數(shù)不能處理源串與目標(biāo)串重疊的情況. 函數(shù)返回strDestination值.
char *strcpy(char *strDestination, const char *strSource);
復(fù)制源串strSource到目標(biāo)串strDestination所指定的位置, 包含NULL結(jié)束符. 不能處理源串與目標(biāo)串重疊的情況.函數(shù)返回strDestination值.
char *strncpy(char *strDestination, const char *strSource, size_t count);
將源串strSource開始的count個(gè)字符復(fù)制到目標(biāo)串strDestination所指定的位置. 如果count值小于或等于strSource串的長度, 不會自動(dòng)添加NULL結(jié)束符目標(biāo)串中, 而count大于strSource串的長度時(shí), 則將strSource用NULL結(jié)束符填充補(bǔ)齊count個(gè)字符, 復(fù)制到目標(biāo)串中. 不能處理源串與目標(biāo)串重疊的情況.函數(shù)返回strDestination值.
char *strset(char *string, int c);
將string串的所有字符設(shè)置為字符c, 遇到NULL結(jié)束符停止. 函數(shù)返回內(nèi)容調(diào)整后的string指針.
char *strnset(char *string, int c, size_t count);
將string串開始count個(gè)字符設(shè)置為字符c, 如果count值大于string串的長度, 將用string的長度替換count值. 函數(shù)返回內(nèi)容調(diào)整后的string指針.
size_t strspn(const char *string, const char *strCharSet);
查找任何一個(gè)不包含在strCharSet串中的字符 (字符串結(jié)束符NULL除外) 在string串中首次出現(xiàn)的位置序號. 返回一個(gè)整數(shù)值, 指定在string中全部由characters中的字符組成的子串的長度. 如果string以一個(gè)不包含在strCharSet中的字符開頭, 函數(shù)將返回0值.
size_t strcspn(const char *string, const char *strCharSet);
查找strCharSet串中任何一個(gè)字符在string串中首次出現(xiàn)的位置序號, 包含字符串結(jié)束符NULL.
返回一個(gè)整數(shù)值, 指定在string中全部由非characters中的字符組成的子串的長度. 如果string以一個(gè)包含在strCharSet中的字符開頭, 函數(shù)將返回0值.
char *strspnp(const char *string, const char *strCharSet);
查找任何一個(gè)不包含在strCharSet串中的字符 (字符串結(jié)束符NULL除外) 在string串中首次出現(xiàn)的位置指針. 返回一個(gè)指針, 指向非strCharSet中的字符在string中首次出現(xiàn)的位置.
char *strpbrk(const char *string, const char *strCharSet);
查找strCharSet串中任何一個(gè)字符在string串中首次出現(xiàn)的位置, 不包含字符串結(jié)束符NULL.
返回一個(gè)指針, 指向strCharSet中任一字符在string中首次出現(xiàn)的位置. 如果兩個(gè)字符串參數(shù)不含相同字符, 則返回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);
等價(jià)于stricmp函數(shù), 只是提供一個(gè)向后兼容的版本.
int strncmp(const char *string1, const char *string2, size_t count);
比較字符串string1和string2大小，只比較前面count個(gè)字符. 比較過程中, 任何一個(gè)字符串的長度小于count, 則count將被較短的字符串的長度取代. 此時(shí)如果兩串前面的字符都相等, 則較短的串要小.
返回值 0, 表示string1的子串小于string2的子串;
返回值為0, 表示string1的子串等于string2的子串;
返回值 0, 表示string1的子串大于string2的子串.
int strnicmp(const char *string1, const char *string2, size_t count);
比較字符串string1和string2大小，只比較前面count個(gè)字符. 與strncmp不同的是, 比較的是它們的小寫字母版本. 返回值與strncmp相同.
char *strtok(char *strToken, const char *strDelimit);
在strToken 串中查找下一個(gè)標(biāo)記, strDelimit字符集則指定了在當(dāng)前查找調(diào)用中可能遇到的分界符. 返回一個(gè)指針, 指向在strToken中找到的下一個(gè)標(biāo)記. 如果找不到標(biāo)記, 就返回NULL值. 每次調(diào)用都會修改strToken內(nèi)容, 用NULL字符替換遇到的每個(gè)分界符.
c++概念字符串操作
一、char_traits 字符特征類
1）意義：包裝特定串元素的通用行為界面，以便容器實(shí)現(xiàn)時(shí)依據(jù)特征信息而執(zhí)行特定行為
2）定義了通用類型名
typedef _Elem char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
其中 int_type 表示字符元素轉(zhuǎn)換到特定編碼時(shí)的整型表示，pos_type, off_type 分別作為字符串索引和字符串元素偏移的類型，類似容器迭中的指針，迭代類型和指針，迭代器的偏移類型。最后的 state_type 用于存儲流狀態(tài)，如出錯(cuò)，格式控制等等。
3）定義了字符 / 字符串操作的包裝界面，以便通用算法的調(diào)用
assign(a, b) 定義將 b 字符賦值給 a 字符的過程，實(shí)現(xiàn) a.operator = 的行為
eq(a, b) 定義 a 字符和 b 字符的相等關(guān)系，實(shí)現(xiàn) a.operator == 的行為
lt(a, b) 定義 a 小于 b 的關(guān)系，實(shí)現(xiàn) a.operator 的行為
compare(a_ptr, b_ptr, cnt) 定義兩組字符串的比較，返回 int 類型，實(shí)現(xiàn)類似 memcmp 的行為
length(ptr) 定義取字符串長度，實(shí)現(xiàn)類似 strlen 的行為
copy(a_ptr, b_ptr, cnt) 定義兩組字符串的復(fù)制，實(shí)現(xiàn)類似 memcpy 的行為
move(a_ptr, b_ptr, cnt) 定義兩組字符串的不重疊復(fù)制，實(shí)現(xiàn)類似 memmove 的行為
assign(ptr, cnt, ch) 定義了填充字符串的過程，實(shí)現(xiàn)類似 memset 的行為
to_int_type(ch) 定義了 char_type 到 int_type 整型的轉(zhuǎn)換過程
to_char_type(n) 定義了 int_type 到 char_type 字符型的轉(zhuǎn)換過程
eq_int_type(a, b) 定義兩個(gè)和當(dāng)前 char_type 類型對應(yīng)的 int_type 的相等關(guān)系
eof() 定義字符串結(jié)尾符，使用整型表示
not_eof(n) 定義非字符串結(jié)尾符，若輸入結(jié)尾符，則返回 1，其他輸入返回原值，即總是不返回 eof()
4）int_type 類型應(yīng)是當(dāng)前字符類型的整型編碼
二、std::string 并不是序列容器，沒有 front() 和 back() 界面用于取出前端和尾端的元素，使用 std::string::operator [] 并傳遞 streampos 類型取得特定元素，如 std::string::size() - 1 作為索引取得最后一個(gè)字符
三、basic_string 支持的初始化
1）默認(rèn)初始化
2）分配器
3）復(fù)制構(gòu)造
4）局部復(fù)制 [_Roff, _Roff + _Count)
5）局部復(fù)制 + 分配器
6）C 字符串 [_Ptr, )
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 += 累加賦值運(yùn)算。
四、字符串的區(qū)間有效性
對串的索引訪問在超過字符串的有效區(qū)間時(shí)，因?yàn)榇脑趯?shí)現(xiàn)上對內(nèi)置的字符緩沖區(qū)執(zhí)行下標(biāo)訪問，所以不會導(dǎo)致異常，但是將得到不可預(yù)知的結(jié)果，通常是不可用的。
將其他字符串作為右值輸入時(shí)，對該串取出計(jì)數(shù)大于串大小時(shí)按串大小計(jì)算。
std::basic_string::size_type 的實(shí)際類型為 size_t，在 Visual C++ 7.1 中實(shí)現(xiàn)為 unsigned，std::basic_string::npos 被靜態(tài)設(shè)定為
(basic_string::size_type)(-1);
在查找子字符串等操作時(shí)，函數(shù)返回 npos 的值表示非法索引。
五、比較字符串
允許的比較對象
1）compare(s2) 其他同類型字符串
2）compare(p) C 風(fēng)格字符串
3）compare(off, cnt, s2) [off, off + cnt) 同 s2 執(zhí)行比較
4）compare(off, cnt, s2, off2, cnt2) [off, off + cnt) 同 s2 [off2, cnt2) 執(zhí)行比較
5）compare(off, cnt, p) [off, off + cnt) 同 [p , ) 執(zhí)行比較
6）compare(off, cnt, p, cnt2) [off, off + cnt) 同 [p, p + cnt2) 執(zhí)行比較
返回 -1, 0, 1 作為小于、等于和大于的比較結(jié)果。
六、附加數(shù)據(jù)
1）使用 operator += 接受其他字符串，C 風(fēng)格字符串和字符
2）使用 push_back() 在尾部附加字符，并使得通過字符串構(gòu)造的 back_iterator 可以訪問
3）append() 附加
1、append(s) 追加字符串
2、append(s, off, cnt) 追加字符串 s [off, off + cnt)
3、append(p) 追加字符串 [p, )
4、append(p, cnt) 追加字符串 [p, p + cnt)
5、append(n, c) 填充 n * c
6、append(InF, InL) 追加輸入流 [InF, InL)
4）insert() 插入
1、insert(off, s2) 插入字符串
2、insert(off, s2, off2, cnt2) 插入字符串 s [off2, off2 + cnt2)
3、insert(off, p) 插入字符串 [p, )
4、insert(off, p, cnt) 插入字符串 [p, p + cnt)
5、insert(off, n, c) 插入 n * c
6、insert(iter) 元素默認(rèn)值填充
7、insert(iter, c) 插入特定元素
8、insert(iter, n, c) 插入 n*c
9、insert(iter, InF, InL) 插入 [InF, InL)
5）operator +(a, b)
字符串關(guān)聯(lián)運(yùn)算符重載中支持 operator + 的形式
1、s + s
2、s + p
3、s + c
4、p + s
5、c + s
七、查找、替換和清除
1）find() 查找
1、find(c, off) 在 s [off, npos) 中查找 c
2、find(p, off, n) 在 s [off, npos) 中查找 [p, p + n)
3、find(p, off) 在 s [off, npos) 中查找 [p, )
4、find(s2, off) 在 s [off, npos) 中查找 s2
2）find() 的變種
1、rfind() 具有 find() 的輸入形式，反序查找
2、find_first_of() 具有 find() 的輸入形式，返回第一個(gè)匹配的索引
3、find_last_of() 具有 find() 的輸入形式，返回倒數(shù)第一個(gè)匹配的索引
4、find_first_not_of() 具有 find() 的輸入形式，返回第一個(gè)不匹配的索引
5、find_last_not_of() 具有 find() 的輸入形式，返回倒數(shù)第一個(gè)不匹配的索引
3）replace() 替換
1、replace(off, cnt, s2) 將 s [off, off + cnt) 替換成 s2
2、replace(off, cnt, s2, off2, cnt2) 將 s [off, off + cnt) 替換成 s2 [off2, off2 + cnt2)
3、replace(off, cnt, p) 將 s [off, off + cnt) 替換成 [p, )
4、replace(off, cnt, p, cnt2) 將 s [off, off + cnt) 替換成 [p, p + cnt2)
5、replace(off, cnt, n, c) 將 s [off, off + cnt) 替換成 c * n
使用迭代器的情況：
6、replace(InF, InL, s2) 將 [InF, InL) 替換成 s2
7、replace(InF, InL, p) 將 [InF, InL) 替換成 [p, )
8、replace(InF, InL, p, cnt) 將 [InF, InL) 替換成 [p, p + cnt)
9、replace(InF, InL, n, c) 將 [InF, InL) 替換成 n * c
10、replace(InF, InL, InF2, InL2) 將 [InF, InL) 替換成 [InF2, InL2)
4）erase() 刪除
1、erase(off, cnt) 從字符串 s 中刪除 s [off, off + cnt)
2、erase(iter) 從字符串 s 中刪除 *iter
3、erase(ItF, ItL) 從字符串 s 中刪除 [ItF, ItL)
八、取出字符串
1）取得 C 風(fēng)格字符串
c_str() 返回常量類型的 C 風(fēng)格字符串指針，copy(ptr, cnt, off = 0) 則將指定大小的字符串復(fù)制到特定指針。data() 在 Visual C++ 7.1 中僅僅調(diào)用了 c_str() 實(shí)現(xiàn)。
2）取得子字符串
substr(off, cnt) 取得 s [off, off + cnt) 的副本。
3）復(fù)制子字符串
copy(p, off, cnt) 將 s [off, off + cnt) 復(fù)制到 p。
九、字符串的緩沖區(qū)管理
字符串具有類似 std::vector 的緩沖區(qū)管理界面。
size() 取得有效元素長度
max_size() 取得當(dāng)前內(nèi)存分配器能分配的有效空間
reserve() 為緩沖區(qū)預(yù)留空間
capacity() 取得緩沖區(qū)的容量
resize() 重設(shè)串的長度，可以為其指定初始化值
十、定義輸入迭代器的尾端
向 istream_iterator 傳遞輸入流對象以創(chuàng)建輸入迭代器，輸入迭代器持有輸入流對象的指針，默認(rèn)創(chuàng)建和讀取流失敗的情況下該指針被設(shè)置為 0。并且在實(shí)現(xiàn)輸入迭代器間的 operator == 相等運(yùn)算時(shí)，進(jìn)行持有的流對象指針的相等比較，這樣，默認(rèn)創(chuàng)建的輸入迭代器將被用于匹配輸入流的結(jié)束。
* 當(dāng)輸入流讀取失敗，用戶執(zhí)行 if, while 條件判斷時(shí)，實(shí)際上先將判斷值轉(zhuǎn)換成 void* 類型，或者根據(jù) operator ! 運(yùn)算符的返回結(jié)果，對輸入流重載 operator void* 和 operator ! 運(yùn)算符，可以定義輸入流在布爾表達(dá)式中的行為，使得當(dāng)流讀取失敗的情況下，輸入迭代器可以通過布爾表達(dá)式來確認(rèn)，而不是顯式訪問 fail() 成員函數(shù).
C語言提供了豐富的字符串處理函數(shù)， 大致可分為字符串的輸入、輸出、合并、修改、比較、轉(zhuǎn)換、復(fù)制、搜索幾類。 使用這些函數(shù)可大大減輕編程的負(fù)擔(dān)。用于輸入輸出的字符串函數(shù)， 在使用前應(yīng)包含頭文件"stdio.h" ； 使用其它字符串函數(shù)則應(yīng)包含頭文件"string.h"。 下面介紹幾個(gè)最常用的字符串函數(shù)。
1.字符串輸出函數(shù) puts 格式： puts (字符數(shù)組名) 功能：把字符數(shù)組中的字符串輸出到顯示器。 即在屏幕上顯示該字符串
#include"stdio.h"
main()
{
static char c[]="BASIC\ndBASE";
puts(c);
}
2.字符串輸入函數(shù)gets 格式： gets (字符數(shù)組名) 功能：從標(biāo)準(zhǔn)輸入設(shè)備鍵盤上輸入一個(gè)字符串。 本函數(shù)得到一個(gè)函數(shù)值，即為該字符數(shù)組的首地址。
#include"stdio.h"
main()
{
char st[15];
printf("input string:\n");
gets(st);
puts(st);
}
3.字符串連接函數(shù)strcat 格式： strcat (字符數(shù)組名1，字符數(shù)組名2) 功能：把字符數(shù)組2中的字符串連接到字符數(shù)組1 中字符串的后面，并刪去字符串1后的串標(biāo)志“\0”。本函數(shù)返回值是字符數(shù)組1的首地址。
#include"string.h"
main()
{
static char st1[30]="My name is ";
int st2[10];
printf("input your name:\n");
gets(st2);
strcat(st1,st2);
puts(st1);
}
4.字符串拷貝函數(shù)strcpy 格式： strcpy (字符數(shù)組名1，字符數(shù)組名2) 功能：把字符數(shù)組2中的字符串拷貝到字符數(shù)組1中。串結(jié)束標(biāo)志“\0”也一同拷貝。字符數(shù)名2， 也可以是一個(gè)字符串常量。這時(shí)相當(dāng)于把一個(gè)字符串賦予一個(gè)字符數(shù)組。
#include"string.h"
main()
{
static char st1[15],st2[]="C Language";
strcpy(st1,st2);
puts(st1);printf("\n");
}
5.字符串比較函數(shù)strcmp 格式： strcmp(字符數(shù)組名1，字符數(shù)組名2) 功能：按照ASCII碼順序比較兩個(gè)數(shù)組中的字符串，并由函數(shù)返回值返回比較結(jié)果。
字符串1＝字符串2，返回值＝0；
字符串2〉字符串2，返回值〉0；
字符串1〈字符串2，返回值〈0。
本函數(shù)也可用于比較兩個(gè)字符串常量，或比較數(shù)組和字符串常量。
#include"string.h"
main()
{ int k;
static char st1[15],st2[]="C Language";
printf("input a string:\n");
gets(st1);
k=strcmp(st1,st2);
if(k==0) printf("st1=st2\n");
if(k0) printf("st1st2\n");
if(k0) printf("st1st2\n");
}
6.測字符串長度函數(shù)strlen 格式： strlen(字符數(shù)組名) 功能：測字符串的實(shí)際長度(不含字符串結(jié)束標(biāo)志‘\0’) 并作為函數(shù)返回值。
#include"string.h"
main()
{ int k;
static char st[]="C language";
k=strlen(st);
printf("The lenth of the string is %d\n",k);
}
C語言是一門面向過程的、抽象化的通用程序設(shè)計(jì)語言，廣泛應(yīng)用于底層開發(fā)。C語言能以簡易的方式編譯、處理低級存儲器。C 語言string的用法有哪些呢，請看看下面我為你整理 總結(jié) 的c語言string的用法大全_C語言中string使用 方法 。
c語言string的用法
函數(shù)原型:char *strdup(const char *s)
函數(shù)功能:字符串拷貝，目的空間由該函數(shù)分配
函數(shù)返回:指向拷貝后的字符串指針
參數(shù)說明:src-待拷貝的源字符串
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
#includealloc.h
intmain()
{
char*dup_str,*string="abcde";
dup_str=strdup(string);
printf("%s",dup_str);
free(dup_str);
return0;
}
@函數(shù)名稱:strcpy
函數(shù)原型:char* strcpy(char* str1,char* str2);
函數(shù)功能:把str2指向的字符串拷貝到str1中去
函數(shù)返回:返回str1,即指向str1的指針
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charstring[10];
char*str1="abcdefghi";
strcpy(string,str1);
printf("thestringis:%s\n",string);
return0;
}
@函數(shù)名稱:strncpy
函數(shù)原型:char *strncpy(char *dest, const char *src，intcount)
函數(shù)功能:將字符串src中的count個(gè)字符拷貝到字符串dest中去
函數(shù)返回:指向dest的指針
參數(shù)說明:dest-目的字符串，src-源字符串，count-拷貝的字符個(gè)數(shù)
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*src="bbbbbbbbbbbbbbbbbbbb";//20'b's
chardest[50]="aaaaaaaaaaaaaaaaaaaa";//20'a's
puts(dest);
strncpy(dest,src,10);
puts(dest);
return0;
}
輸出：
[cpp] view plain
/*******************************************
aaaaaaaaaaaaaaaaaaaa
bbbbbbbbbbaaaaaaaaaa
*******************************************/
注意：strncpy只復(fù)制指定長度的字符，不會自動(dòng)在末尾加'\0'。若指定長度超過源字符串長度，不夠的部分補(bǔ)‘\0’，
@函數(shù)名稱:strcat
函數(shù)原型:char* strcat(char * str1,char * str2);
函數(shù)功能:把字符串str2接到str1后面,str1最后的'\0'被取消
函數(shù)返回:str1
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charbuffer[80];
strcpy(buffer,"Hello");
strcat(buffer,"world");
printf("%s\n",buffer);
return0;
}
@函數(shù)名稱:strncat
函數(shù)原型:char *strncat(char *dest, const char *src, size_t maxlen)
函數(shù)功能:將字符串src中前maxlen個(gè)字符連接到dest中
函數(shù)返回:
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
charbuffer[80];
intmain()
{
strcpy(buffer,"Hello");
strncat(buffer,"world",8);
printf("%s\n",buffer);
strncat(buffer,"*************",4);
printf("%s\n",buffer);
return0;
}
注意：與strncpy不同的是，strncat會自動(dòng)在末尾加‘\0’，若指定長度超過源字符串長度，則只復(fù)制源字符串長度即停止
@函數(shù)名稱:strcmp
函數(shù)原型:int strcmp(char * str1,char * str2);
函數(shù)功能:比較兩個(gè)字符串str1,str2.
函數(shù)返回:str1str2,返回負(fù)數(shù);str1=str2,返回 0;str1str2,返回正數(shù).
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
char*buf1="aaa",*buf2="bbb",*buf3="ccc";
intptr;
ptr=strcmp(buf2,buf1);
if(ptr0)
printf("buffer2isgreaterthanbuffer1\n");
else
printf("buffer2islessthanbuffer1\n");
ptr=strcmp(buf2,buf3);
if(ptr0)
printf("buffer2isgreaterthanbuffer3\n");
else
printf("buffer2islessthanbuffer3\n");
return0;
}
@函數(shù)名稱:strncmp
函數(shù)原型:int strncmp(char *str1,char *str2,int count)
函數(shù)功能:對str1和str2中的前count個(gè)字符按字典順序比較
函數(shù)返回:小于0：str1str2，等于0：str1=str2，大于0：str1str2
參數(shù)說明:str1,str2-待比較的字符串，count-比較的長度
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
charstr1[]="aabbc";//
charstr2[]="abbcd";//
//為使測試程序更簡練，此處假定了strncmp只返回-1,0,1三個(gè)數(shù)
charres_info[]={'','=',''};
intres;
//前1個(gè)字符比較
res=strncmp(str1,str2,1);
printf("1：str1%cstr2\n",res_info[res+1]);
//前3個(gè)字符比較
res=strncmp(str1,str2,3);
printf("3：str1%cstr2\n",res_info[res+1]);
}
輸出：
[cpp] view plain
/****************************************
1：str1=str2
3：str1str2
*****************************************/
@函數(shù)名稱:strpbrk
函數(shù)原型:char *strpbrk(const char *s1, const char *s2)
函數(shù)功能:得到s1中第一個(gè)“同時(shí)也出現(xiàn)在s2中”字符的位置指針
函數(shù)返回:位置指針
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*p="Findallvowels";
p=strpbrk(p+1,"aeiouAEIOU");
while(p)
{
printf("%s\n",p);
p=strpbrk(p+1,"aeiouAEIOU");
}
return0;
}
輸出：
[cpp] view plain
/**************************************
indallvowels
allvowels
owels
els
**************************************/
@函數(shù)名稱:strcspn
函數(shù)原型:int strcspn(const char *s1, const char *s2)
函數(shù)功能:統(tǒng)計(jì)s1中從頭開始直到第一個(gè)“來自s2中的字符”出現(xiàn)的長度
函數(shù)返回:長度
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
printf("%d\n",strcspn("abcbcadef","cba"));
printf("%d\n",strcspn("xxxbcadef","cba"));
printf("%d\n",strcspn("123456789","cba"));
return0;
}
輸出：
[cpp] view plain
/************************
3
9
************************/
@函數(shù)名稱:strspn
函數(shù)原型:int strspn(const char *s1, const char *s2)
函數(shù)功能:統(tǒng)計(jì)s1中從頭開始直到第一個(gè)“不來自s2中的字符”出現(xiàn)的長度
函數(shù)返回:位置指針
參數(shù)說明:
所屬文件:string.h
[html] view plain
#includestdio.h
#includestring.h
#includealloc.h
intmain()
{
printf("%d\n",strspn("abcbcadef","cba"));
printf("%d\n",strspn("xxxbcadef","cba"));
printf("%d\n",strspn("123456789","cba"));
return0;
}
輸出：
[cpp] view plain
/************************
6
************************/
@函數(shù)名稱:strchr
函數(shù)原型:char* strchr(char* str,char ch);
函數(shù)功能:找出str指向的字符串中第一次出現(xiàn)字符ch的位置
函數(shù)返回:返回指向該位置的指針,如找不到,則返回空指針
參數(shù)說明:str-待搜索的字符串，ch-查找的字符
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
char*str="Thisisastring!";
charch;
char*p;
while(1)
{
printf("Pleaseinputachar:");
ch=getchar();
p=strchr(str,ch);
if(p)
printf("%cisthe%dcharacterof\"%s\"\n",ch,(int)(p-str+1),str);
else
printf("Notfound!\n");
printf("PressESCtoquit!\n\n");
if(27==getch())
break;
fflush(stdin);
}
return0;
}
運(yùn)行結(jié)果：
[cpp] view plain
/********************************************
Pleaseinputachar:i
iisthe3characterof"Thisisastring!"
PressESCtoquit!
Pleaseinputachar:l
Notfound!
PressESCtoquit!
Pleaseinputachar:s
sisthe4characterof"Thisisastring!"
PressESCtoquit!
**********************************************/
@函數(shù)名稱:strrchr
函數(shù)原型:char *strrchr(const char *s, int c)
函數(shù)功能:得到字符串s中最后一個(gè)含有c字符的位置指針
函數(shù)返回:位置指針
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
charstring[15];
char*ptr,c='r';
strcpy(string,"Thisisastring");
ptr=strrchr(string,c);
if(ptr)
printf("Thecharacter%cisatposition:%d",c,ptr-string);
else
printf("Thecharacterwasnotfound");
return0;
}
@函數(shù)名稱:strstr
函數(shù)原型:char* strstr(char* str1,char* str2);
函數(shù)功能:找出str2字符串在str1字符串中第一次出現(xiàn)的位置(不包括str2的串結(jié)束符)
函數(shù)返回:返回該位置的指針,如找不到,返回空指針
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*str1="OpenWatcomC/C++",*str2="Watcom",*ptr;
ptr=strstr(str1,str2);
printf("Thesubstringis:%s\n",ptr);
return0;
}
輸出：
The substringis:Watcom C/C++
@函數(shù)名稱:strrev
函數(shù)原型:char *strrev(char *s)
函數(shù)功能:將字符串中的所有字符顛倒次序排列
函數(shù)返回:指向s的指針
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
charforward[]="string";//原文中定義為char*是不對的，指向代碼段的指針內(nèi)容是不可變的
printf("Beforestrrev():%s",forward);
strrev(forward);
printf("Afterstrrev():%s",forward);
return0;
}
輸出：
[cpp] view plain
/************************************
Beforestrrev():string
Afterstrrev():gnirts
************************************/
@函數(shù)名稱:strnset
函數(shù)原型:char *strnset(char *s, int ch, size_t n)
函數(shù)功能:將字符串s中前n個(gè)字符設(shè)置為ch的值
函數(shù)返回:指向s的指針
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charstring[]="aaaaaaaaaaaaaaaaaaaaaaa";
charletter='x';
printf("stringbeforestrnset:%s\n",string);
strnset(string,letter,10);
printf("stringafterstrnset:%s\n",string);
return0;
}
輸出：
[cpp] view plain
/*************************************************
stringbeforestrnset:aaaaaaaaaaaaaaaaaaaaaaa
stringafterstrnset:xxxxxxxxxxaaaaaaaaaaaaa
*************************************************/
@函數(shù)名稱:strset
函數(shù)原型:char *strset(char *s, int ch)
函數(shù)功能:將字符串s中所有字符設(shè)置為ch的值
函數(shù)返回:指向s的指針
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charstring[10]="123456789";
charsymbol='c';
printf("Beforestrset():%s",string);
strset(string,symbol);
printf("Afterstrset():%s",string);
return0;
}
@函數(shù)名稱:strtok
函數(shù)原型:char *strtok(char *s1, const char *s2)
函數(shù)功能:分解s1字符串為用特定分隔符分隔的多個(gè)字符串(一般用于將英文句分解為單詞)
函數(shù)返回:字符串s1中首次出現(xiàn)s2中的字符前的子字符串指針
參數(shù)說明:s2一般設(shè)置為s1中的分隔字符
規(guī)定進(jìn)行子調(diào)用時(shí)（即分割s1的第二、三及后續(xù)子串）第一參數(shù)必須是NULL
在每一次匹配成功后，將s1中分割出的子串位置替換為NULL(摘下鏈中第一個(gè)環(huán))，因此s1被破壞了
函數(shù)會記憶指針位置以供下一次調(diào)用
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
char*p;
char*buffer;
char*delims={".,"};
buffer=strdup("Findwords,allofthem.");
printf("%s\n",buffer);
p=strtok(buffer,delims);
while(p!=NULL){
printf("word:%s\n",p);
p=strtok(NULL,delims);
}
printf("%s\n",buffer);
return0;
}//根據(jù)測試，可以隨時(shí)給strtok的第一個(gè)參數(shù)輸入一個(gè)新的字符串，開始新字符串的分隔
PS：根據(jù)測試，可以隨時(shí)給strtok的第一個(gè)參數(shù)輸入一個(gè)新的字符串，開始新字符串的分隔
@函數(shù)名稱:strupr
函數(shù)原型:char *strupr(char *s)
函數(shù)功能:將字符串s中的字符變?yōu)榇髮?/p>
函數(shù)返回:
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charstring[]="abcdefghijklmnopqrstuvwxyz",*ptr;//會影響原字符串的內(nèi)存，用char[]來聲明
ptr=strupr(string);
printf("%s",ptr);
return0;
}
@函數(shù)名稱:strlwr
函數(shù)原型:char *strlwr(char *s)
函數(shù)功能:將字符串中的字符變?yōu)樾懽址?/p>
函數(shù)返回:指向s的指針
參數(shù)說明:
所屬文件:string.h
[cpp] view plain
#includestring.h
intmain()
{
charstr[]="HOWTOSAY";
printf("%s",strlwr(str));
return0;
}
@函數(shù)名稱:strerror
函數(shù)原型:char *strerror(int errnum)
函數(shù)功能:得到錯(cuò)誤信息的內(nèi)容信息
函數(shù)返回:錯(cuò)誤提示信息字符串指針
參數(shù)說明:errnum-錯(cuò)誤編號
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includeerrno.h
intmain()
{
char*buffer;
buffer=strerror(errno);
printf("Error:%s",buffer);
return0;
}
@函數(shù)名稱:memcpy
函數(shù)原型:void *memcpy(void *dest, const void *src, size_t n)
函數(shù)功能:字符串拷貝
函數(shù)返回:指向dest的指針
參數(shù)說明:src-源字符串，n-拷貝的最大長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charsrc[]="******************************";
chardest[]="abcdefghijlkmnopqrstuvwxyz0123456709";
char*ptr;
printf("destinationbeforememcpy:%s\n",dest);
ptr=memcpy(dest,src,strlen(src));
if(ptr)
printf("destinationaftermemcpy:%s\n",dest);
else
printf("memcpyfailed");
return0;
}
輸出：
[cpp] view plain
/*************************************************************
destinationbeforememcpy:abcdefghijlkmnopqrstuvwxyz0123456709
destinationaftermemcpy:******************************456709
**************************************************************/
@函數(shù)名稱:memccpy
函數(shù)原型:void *memccpy(void *dest, const void *src, int c, size_t n)
函數(shù)功能:字符串拷貝，到指定長度或遇到指定字符時(shí)停止拷貝
函數(shù)返回:
參數(shù)說明:src-源字符串指針，c-中止拷貝檢查字符，n-長度,dest-拷貝底目的字符串指針
所屬文件:string.h,mem.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
char*src="Thisisthesourcestring";
chardest[50];
char*ptr;
ptr=memccpy(dest,src,'c',strlen(src));
if(ptr)
{
*ptr='\0';
printf("Thecharacterwasfound:%s",dest);
}
else
printf("Thecharacterwasn'tfound");
return0;
}
輸出：
[cpp] view plain
/*****************************************
Thecharacterwasfound:Thisisthesourc
*****************************************/
PS：指定字符被復(fù)制到dest中，memccpy返回了dest中指定字符的下一處的地址，返回NULL表示未遇到指定字符
@函數(shù)名稱:memchr
函數(shù)原型:void *memchr(const void *s, int c, size_t n)
函數(shù)功能:在字符串中第開始n個(gè)字符中尋找某個(gè)字符c的位置
函數(shù)返回:返回c的位置指針，返回NULL時(shí)表示未找到
參數(shù)說明:s-要搜索的字符串，c-要尋找的字符，n-指定長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
charstr[17];
char*ptr;
strcpy(str,"Thisisastring");
ptr=memchr(str,'r',strlen(str));
if(ptr)
printf("Thecharacter'r'isatposition:%d",ptr-str);
else
printf("Thecharacterwasnotfound");
return0;
}
@函數(shù)名稱:memcmp
函數(shù)原型:int memcmp(const void *s1, const void *s2,size_t n)
函數(shù)功能:按字典順序比較兩個(gè)串s1和s2的前n個(gè)字節(jié)
函數(shù)返回:0,=0,0分別表示s1,=,s2
參數(shù)說明:s1,s2-要比較的字符串，n-比較的長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*buf1="ABCDE123";
char*buf2="abcde456";
intstat;
stat=memcmp(buf1,buf2,5);
printf("Thestringstoposition5are");
if(stat)printf("not");
printf("thesame\n");
return0;
}
@函數(shù)名稱:memicmp
函數(shù)原型:int memicmp(const void *s1, const void *s2, size_t n)
函數(shù)功能:按字典順序、不考慮字母大小寫對字符串s1,s2前n個(gè)字符比較
函數(shù)返回:0,=0,0分別表示s1,=,s2
參數(shù)說明:s1,s2-要比較的字符串，n-比較的長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*buf1="ABCDE123";
char*buf2="abcde456";
intstat;
stat=memicmp(buf1,buf2,5);
printf("Thestringstoposition5are");
if(stat)printf("not");
printf("thesame");
return0;
}
輸出：
[cpp] view plain
/**************************************
Thestringstoposition5arethesame
***************************************/
@函數(shù)名稱:memmove
函數(shù)原型:void *memmove(void *dest, const void *src, size_t n)
函數(shù)功能:字符串拷貝
函數(shù)返回:指向dest的指針
參數(shù)說明:src-源字符串，n-拷貝的最大長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
chardest[40]="abcdefghijklmnopqrstuvwxyz0123456789";
printf("destinationpriortomemmove:%s\n",dest);
memmove(dest+1,dest,35);
printf("destinationaftermemmove:%s",dest);
return0;
}
PS：與memcpy不同的是，memmove可以處理目的字符串與源字符串地址空間出現(xiàn)重疊的情況，可保證待復(fù)制的內(nèi)容不被破壞。
@函數(shù)名稱: memset
函數(shù)原型: void *memset(void *s, int c, size_t n)
函數(shù)功能: 字符串中的n個(gè)字節(jié)內(nèi)容設(shè)置為c
函數(shù)返回:
參數(shù)說明: s-要設(shè)置的字符串，c-設(shè)置的內(nèi)容，n-長度
所屬文件: string.h,mem.h
[cpp] view plain
#includestring.h
#includestdio.h
#includemem.h
intmain()
{
charbuffer[]="Helloworld";
printf("Bufferbeforememset:%s/n",buffer);
memset(buffer,'*',strlen(buffer)-1);
printf("Bufferaftermemset:%s",buffer);
return0;
}
c語言string的用法大全相關(guān) 文章 ：
★ c語言string的用法
★ c語言的用法
★ Linux C語言字符與字符串處理
★ c語言中strcmp的用法
★ c語言大括號的用法
★ c語言位運(yùn)算符的用法
★ c語言char的用法
★ c語言中sort的用法詳解
★ c語言中int的用法
★ c語言map的用法
string.h頭文件中包含的字符串函數(shù)
void?*memcpy(void?*dest,?const?void?*src,?size_t?n);//將n字節(jié)長的內(nèi)容從一個(gè)內(nèi)存地址復(fù)制到另一個(gè)地址；如果兩個(gè)地址存在重疊，則最終行為未定義
void?*memmove(void?*dest,?const?void?*src,?size_t?n);//將n字節(jié)長的內(nèi)容從一個(gè)內(nèi)存地址復(fù)制到另一個(gè)地址；與memcpy不同的是它可以正確作用于兩個(gè)存在重疊的地址
void?*memchr(const?void?*s,?char?c,?size_t?n);//在從s開始的n個(gè)字節(jié)內(nèi)查找c第一次出現(xiàn)的地址并返回，若未找到則返回NULL
int?memcmp(const?void?*s1,?const?void?*s2,?size_t?n);//對從兩個(gè)內(nèi)存地址開始的n個(gè)字符進(jìn)行比較
void?*memset(void?*,?int,?size_t);//用某種字節(jié)內(nèi)容覆寫一段內(nèi)存空間
char?*strcat(char?*dest,?const?char?*src);//在字符串dest之后連接上src
char?*strncat(char?*dest,?const?char?*src,?size_t?n);//從src截取n個(gè)字符連接在字符串dest之后，返回dest字符串
char?*strchr(const?char*?str,?int?ch);//從字符串str頭開始查找字符ch首次出現(xiàn)的位置
char?*strrchr(const?char*?str,int?ch);//從字符串str尾開始查找字符ch首次出現(xiàn)的位置
int?strcmp(const?char?*,?const?char?*);//基于字典順序比較兩個(gè)字符串
int?strncmp(const?char?*,?const?char?*,?size_t);//基于字典順序比較兩個(gè)字符串，最多比較n個(gè)字節(jié)
int?strcoll(const?char?*,?const?char?*);//基于當(dāng)前區(qū)域設(shè)置的字符順序比較兩個(gè)字符串
char?*strcpy(char*?str1,?const?char*?str2);//將str2拷貝給str1
char?*strncpy(char*?str1,?const?char*?str2,?size_t?n);//截取str2的n個(gè)字符拷貝給str1
char?*strerror(int);//返回錯(cuò)誤碼對應(yīng)的解釋字符串，參見errno.h（非線程安全函數(shù)）
size_t?strlen(const?char?*);//返回一個(gè)字符串的長度
size_t?strspn(const?char?*s,?const?char?*strCharSet);//從字符串s的起始處開始，尋找第一個(gè)不出現(xiàn)在strCharSet中的字符，返回其位置索引值。換句話說，返回從字符串s的起始位置的完全由strCharSet中的字符構(gòu)成的子串的最大長度。strspn為string?span的縮寫。不支持多字節(jié)字符集。
size_t?strcspn(const?char?*s,?const?char?*strCharSet);//從字符串s的起始處開始，尋找第一個(gè)出現(xiàn)在strCharSet中的字符，返回其位置索引值。換句話說，返回從字符串s的起始位置的完全由不屬于strCharSet中的字符構(gòu)成的子串的最大長度。strcspn為string?complement?span的縮寫。不支持多字節(jié)字符集。
char?*strpbrk(const?char?*s,?const?char?*strCharSet);//在字符串s中查找strCharSet中任意字符第一次出現(xiàn)的位置的指針值。strpbrk為string?pointer?break縮寫。不支持多字節(jié)字符集。
char?*strstr(const?char?*haystack,?const?char?*needle);//在字符串haystack中查找字符串needle第一次出現(xiàn)的位置，heystack的長度必須長于needle
char?*strtok(char?*strToken,?const?char?*strDelimit?);//將一個(gè)字符串strToken依據(jù)分界符（delimiter)分隔成一系列字符串。此函數(shù)非線程安全，且不可重入；但MSVC實(shí)現(xiàn)時(shí)使用了thread-local?static?variable因而是線程安全的單仍然是不可重入，即在單線程中不能對兩個(gè)源字符串交替調(diào)用該函數(shù)來分析token，應(yīng)當(dāng)對一個(gè)字符串分析完成后再處理別的字符串。
size_t?strxfrm(char?*dest,?const?char?*src,?size_t?n);//根據(jù)當(dāng)前l(fā)ocale轉(zhuǎn)換一個(gè)字符串為strcmp使用的內(nèi)部格式
重慶分公司
重慶分公司
