1.C語言中的字符串

C語言中，字符串是以'\0'結尾的一些字符的集合，為了操作方便，C標準庫中提供了一些str系列的庫函數(shù)，但是這些庫函數(shù)與字符串是分離開的，不太符合OOP的思想，而且底層空間需要用戶自己管理，稍不留神可能還會越界訪問。

在OJ中，有關字符串的題目基本以string類的形式出現(xiàn)，而且在常規(guī)工作中，為了簡單、方便、快捷，基本都使用string類，很少有人去使用C庫中的字符串操作函數(shù)。

2. 標準庫中string類的常見接口

(1) 簡介

在使用string類時，必須包含#include頭文件以及using namespace std;

字符串是表示字符序列（順序表）的對象

(2) 成員函數(shù)

● string類對象的常見構造

● 析構函數(shù)。

當字符串生命周期結束，會自動調用析構函數(shù)。

int main()
{string s1;//構造空的string類對象s1string s2("123");//帶參構造,用C格式字符串構造string類對象s2string s3(s2);//拷貝構造string s4(s2, 2, 3);//從下標為2的位置拷貝是3個字符string s5(s2, 2, 10);//超出拷貝字符串的范圍，拷貝到原字符串結尾就結束string s6("123456", 4);//復制前4個string s7( 10 ,'x');//用10個'x'填充字符串(初始化)return 0;
}

● 賦值重載

(3) 迭代器

<1> 正向迭代器Iterator

提供了一種通用的（所用）訪問容器的方式，比如訪問字符串，鏈表等

//iterator類似于指針
string::iterator it = s1.begin();//begin返回開始位置的迭代器
while (it != s1.end())//end返回最后一個有效字符的下一個位置的迭代器
{it += 2;//可以修改cout << *it << " ";++it;
}
cout << endl;    

● begin

● end

<2> 反向迭代器reverse_iterator

string s1("1234");
string::reverse_iterator rit = s1.rbegin();//返回反向迭代器以反向開始
while (rit != s1.rend())//將反向迭代器返回到反向端
{rit += 2;//可以修改cout << *rit << " ";++rit;
}
cout << endl;
return 0;

● rbegin

● rend

<3> 迭代器訪問const類型容器

普通的迭代器是可讀可寫的，const迭代器訪問const修飾的容器只能讀不能寫（指向的內容）

注意const迭代迭代器不是指const修飾迭代器，因為迭代器本身可以修改，而它指向的內容不能修改！

const string s2("1234");
string::const_iterator cit = s2.begin();//const迭代器
while (cit != s2.end())//只能讀不能寫(指向的內容)
{cout << *cit << " ";++cit;
}
cout << endl;

const string s3("1234");
string::const_reverse_iterator rit = s3.rbegin();//const迭代器
while (rit != s3.rend())//只能讀不能寫(指向的內容)
{cout << *rit << " ";++rit;
}
cout << endl;

(3) string類對象的常見容量操作

● string容量相關方法使用（擴容）：

std::string 的內部實現(xiàn)可能使用了一些優(yōu)化技術，比如小字符串優(yōu)化（SSO），在這種情況下，短字符串可能直接存儲在 std::string 對象的內存空間內，而不是在堆上分配。但是，當字符串增長超出了這個內部空間時，就會觸發(fā)堆上的內存分配和擴容。

當std::string對象通過連續(xù)的push_back操作增加元素時，其容量會根據(jù)元素數(shù)量增長，初始容量可能是15個字節(jié)，并且當size達到capacity時，容量會增加，通常是以一定的增量增長，如16個字節(jié)。在某些實現(xiàn)中，如果當前容量小于32，新的容量可能增加16；如果當前容量大于或等于32，新的容量可能是當前容量的1.5倍或者直接翻倍，以減少將來可能的內存重新分配次數(shù)，提高性能 。（了解）?

void TestPushBack()
{string s;size_t sz = s.capacity();cout << "making s grow:\n";for (int i = 0; i < 100; ++i){s.push_back('c');if (sz != s.capacity())//擴容{sz = s.capacity();cout << "capacity changed: " << sz << '\n';}}
}

容量只顯示有效字符的個數(shù)，內存會比容量多一個空間（存儲‘ \0 ’）

● 注意：

1. size()與length()方法底層實現(xiàn)原理完全相同，引入size()的原因是為了與其他容器的接

口保持一致， 一般情況下基本都是用size() 。

2. clear()只是將string中有效字符清空，不改變底層空間大小。

3. resize(size_t n) 與 resize(size_t n, char c)都是 將字符串中有效字符個數(shù)改變到n個 ，不

同的是當字符個數(shù)增多時：resize(n)用0來填充多出的元素空間，resize(size_t n, char

c) 用字符c來填充多出的元素空間 。注意： resize在改變元素個數(shù)時，如果是將元素個數(shù)

增多，可能會改變底層容量的大小，如果是將元素個數(shù)減少，底層空間總大小不變。

4. reserve(size_t res_arg=0)：為string預留空間，不改變有效元素個數(shù)，當reserve的參

數(shù)小于string的底層空間總大小時，reserver不會改變容量大小。vs下，有效元素個數(shù)小于預留空間大小時，不縮容。

reserve擴容：?

//預留100的容量，但會發(fā)生內存對齊，所以最終預留容量會大于100
s.reserve(100);

(4) 元素訪問

● 運算符重載[ ]

底層模擬實現(xiàn)：

char& operator[](size_t pos)
{assert(pos < size);//越界會報錯return _str[pos];
}

返回的是引用，方便我們進行讀和修改的操作：

string s1("hello world");
cout << s1 << endl;
s1[0] = 'd';
cout << s1 << endl;
//下標 + []
for (size_t i = 0; i < s1.size(); i++)
{cout << s1[i] << " ";
}
cout << endl;

● at?獲取字符串中的字符

返回對字符串中位置 pos 處的字符的引用。

該函數(shù)自動檢查 pos 是否是字符串中字符的有效位置（即 pos 是否小于字符串長度），如果不是，則拋出 out_of_range 異常。

// string::at
#include <iostream>
#include <string>int main ()
{std::string str ("Test string");for (unsigned i=0; i<str.length(); ++i){std::cout << str.at(i);}return 0;
}

(5) 修改器

●?push_back

string s1("hello world");
cout << s1 << endl;
s1.push_back('1');
cout << s1 << endl << endl;

●?append

string s2;
s2.append(s1);
cout << s2 << endl;

?● 賦值重載+=

s1 += "234";
cout << s1 << endl;

?● insert（插入）

s2.insert(0, "123");
cout << s2 << endl;

● erase（刪除）

string s3("hello world");
s3.erase(0,1);//頭刪
cout << s3 << endl;
s3.erase(6);//6位置之后的全部刪除
cout << s3 << endl;

?● replace（替換）

string s4("hello world");
s4.replace(5, 1, "00");
//將從第五個位置開始的一個字符替換成"00"
cout << s4 << endl;

replace替換有很多的風險，少替換多時，會有字符挪動，可能會有多次擴容，?導致效率低下。在替換個數(shù)相同時，可以使用。

(6) 字符串修改

?● c_str（兼容C）

string file;
cin >> file;//輸入當前文件，例如Test.cpp
FILE* fout = fopen(file.c_str(), "r");//傳指向文件底層的指針
char ch = fgetc(fout);//讀取文件的字符串
while (ch != EOF)
{cout << ch;ch = fgetc(fout);
}
fclose(fout);

● data（類似于c_str）

● substr（子串）

返回一個新構造的字符串對象，其值初始化為從pos位置開始，長度為len（或直到字符串末尾，以先到者為準）的原字符串的拷貝

	string s1("test.cpp");size_t pos = s1.find(".");//返回找到的第一個.string subfix = s1.substr(pos);//取后綴，從pos位置開始取子字符串

● find（正向）

?將所有“ ”替換成“%%” ：

// 將所有“ ”替換成“%%”
void test1()
{string s1("hello world");cout << s1 << endl;size_t pos = s1.find(" ");//效率較低while (pos != string::npos){s1.replace(pos, 1, "%%");//將一個空格替換成%%(少替換多)pos = s1.find(" ",pos+2);//從pos+2的位置開始向后找}cout << s1 << endl;string tmp;//定義新的string類型，避免多次字符串多次移動，效率低下的問題for (auto ch : s1){if (ch == ' ')tmp += "%%";elsetmp += ch;}cout << tmp << endl;//s1 = tmp;//將結果直接賦值給s1s1.swap(tmp);//直接交換，tmp構造的空間直接交換給s1(更高效)cout << s1 << endl;
} 

● rfind（倒著找）

?題目：找出文件的后綴名

    // 題目：找出文件的后綴名string s1("test.cpp");size_t pos = s1.find(".");//返回找到的第一個.string subfix = s1.substr(pos);//取后綴，從pos位置開始取子字符串cout << subfix << endl;//這次要求返回的是.zipstring s2("test.cpp.zip");size_t rpos = s2.rfind(".");string rsubfix = s2.substr(rpos);//取后綴，從pos位置開始取子字符串cout << rsubfix << endl;

●?find_first_of

在字符串中搜索與其參數(shù)中指定的任何字符匹配的第一個字符。

	string str("Please, replace the vowels in this sentence by asterisks.");size_t found = str.find_first_of("aeiou");//在str中找到"aeiou"的任意一個都會返回下標while (found != string::npos){str[found] = '*';found = str.find_first_of("aeiou", found + 1);}cout << str << '\n';

●?find_last_of（倒著找）

在字符串中搜索與參數(shù)中指定的任何字符匹配的最后一個字符。

// 將路徑和文件分隔開?

//將路徑和文件分隔開
void SplitFilename(const string& str)
{cout << "Splitting: " << str << '\n';size_t found = str.find_last_of("/\\");//無論包含包含的是linu下的分割還是Windows下的分割都進行下標返回cout << " path: " << str.substr(0, found) << '\n';cout << " file: " << str.substr(found + 1) << '\n';
}
int main()
{string str1("/usr/bin/man");//Linux下的分隔符是/string str2("c:\\windows\\winhelp.exe");//Windows下的分隔符是\，Windows下顯示寫\要寫兩個\\SplitFilename(str1);SplitFilename(str2);return 0;
}

●?find_first_not_of

查找字符串中與參數(shù)中指定的任何字符都不匹配的第一個字符

●?find_last_not_of?

在字符串中搜索與參數(shù)中指定的任何字符都不匹配的最后一個字符

?(7)成員常數(shù)npos

npos是一個靜態(tài)成員常量值，對于size-t類型的元素，它是size_t的最大值。

(8)非成員函數(shù)

● 運算符重載+

返回一個新構造的字符串對象，其值是lhs中字符的連接，后跟rhs中的字符。

運算符重載要求至少有一個是類類型的參數(shù)

void test5()
{	string s1("hello");string s2 = s1 + "world";string s3 = "world" + s1;cout << s1 << endl;cout << s2 << endl;cout << s3 << endl;
}

● 比較運算符重載

在字符串對象lhs和rhs之間執(zhí)行適當?shù)谋容^操作

● getline（將線從流轉換為字符串）

從is中提取字符并將其存儲到str中，直到找到分隔符delim（或換行符'\n'，用于（2））

字符串最后一個單詞的長度_?？皖}霸_?？途W(wǎng)

#include <iostream>
using namespace std;int main() {string str;//cin >> str;// cin 和 scanf 將空格和換行默認成分割getline(cin,str);// 無定界默認遇到換行才停止輸入size_t pos = str.rfind(' ');cout << str.size() - (pos + 1) << endl;
}

eg：?

getline(cin,str,"*");//流提取，直到遇到*才停止

3. auto和范圍for

(1) auto關鍵字

●? 在早期C/C++ 中 auto 的含義是：使用 auto 修飾的變量，是具有自動存儲器的局部變量，后來這個 不重要了。 C++11 中，標準委員會變廢為寶賦予了 auto 全新的含義即： auto 不再是一個存儲類型 指示符，而是作為一個新的類型指示符來指示編譯器， auto聲明的變量必須由編譯器在編譯時期推導而得。

●? 用auto 聲明指針類型時，用 auto 和 auto*（必須是指針） 沒有任何區(qū)別，但用 auto 聲明引用類型時則必須加 & 當在同一行聲明多個變量時，這些變量必須是相同的類型，否則編譯器將會報錯，因為編譯器實際 只對第一個類型進行推導，然后用推導出來的類型定義其他變量 。

●? auto 不能作為函數(shù)的參數(shù)，可以做返回值 ，但是建議謹慎使用

●? auto 不能直接用來聲明數(shù)組

#include<iostream>
#include <string>
#include <map>
using namespace std;
int main()
{
std::map<std::string, std::string> dict = { { "apple", "蘋果" },{ "orange",
"橙子" }, {"pear","梨"} };
// auto的用武之地
//std::map<std::string, std::string>::iterator it = dict.begin();
auto it = dict.begin();
while (it != dict.end())
{
cout << it->first << ":" << it->second << endl;
++it;
}

#include<iostream>
using namespace std;
int func1()
{
return 10;
}
// 不能做參數(shù)
void func2(auto a)
{}
// 可以做返回值，但是建議謹慎使用
auto func3()
{
return 3;
}
int main()
{
int a = 10;
auto b = a;
auto c = 'a';
auto d = func1();
// 編譯報錯:rror C3531: “e”: 類型包含“auto”的符號必須具有初始值設定項
auto e;//無法從右邊的類型推出auto的類型
cout << typeid(b).name() << endl;//打印類型
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
int x = 10;
auto y = &x;
auto* z = &x;
auto& m = x;
cout << typeid(x).name() << endl;
cout << typeid(y).name() << endl;
cout << typeid(z).name() << endl;
auto aa = 1, bb = 2;
// 編譯報錯：error C3538: 在聲明符列表中，“auto”必須始終推導為同一類型
auto cc = 3, dd = 4.0;
// 編譯報錯：error C3318: “auto []”: 數(shù)組不能具有其中包含“auto”的元素類型
auto array[] = { 4, 5, 6 };
return 0;
}

(2) 范圍for

●?對于一個 有范圍的集合 而言，由程序員來說明循環(huán)的范圍是多余的，有時候還會容易犯錯誤。因此C++11中引入了基于范圍的for循環(huán)。 for循環(huán)后的括號由冒號“ ：”分為兩部分：第一部分是范圍內用于迭代的變量（每個字符的拷貝），第二部分則表示被迭代的范圍， 自動迭代，自動取數(shù)據(jù)，自動判斷結束。

●?范圍for可以作用到 數(shù)組和容器對象 上進行遍歷

●?范圍for的底層很簡單，容器遍歷實際就是 替換為迭代器 ，這個從匯編層也可以看到。

//自動賦值，自動迭代，自動判斷結束
//底層就是迭代器
// C++11的遍歷
for (auto& e : array)
e *= 2;
for (auto e : array)
cout << e << " " << endl;for (auto ch : s1)
{ch -= 2;//這里修改的只是字符串的拷貝ch(ch是局部變量)cout << ch << " ";
}
cout << endl;for (auto& ch : s1)//ch就是s1里每個字符的別名
{ch -= 2;//修改了s1字符串cout << ch << " ";
}
cout << endl;

4.string類的常用接口說明

(1) string類對象的遍歷訪問操作

(2)?string類對象的修改操作

1. 在string尾部追加字符時， s.push_back(c) / s.append(1, c) / s += 'c'三種的實現(xiàn)方式差

不多 ，一般情況下string類的+=操作用的比較多， +=操作不僅可以連接單個字符，還可

以連接字符串 。

2. 對string操作時，如果能夠大概預估到放多少字符，可以先通過 reserve 把空間預留

好。