C/C++ 學習筆記：C++ 中 string 類使用總結

C++中的string類使用總結

需要使用 using  std::string; 或 using namespace std;

string類的構造函數

string(const char *s);// 用 C 類型字符串s初始化
string(int n,char c);// 用 n 個字符 'c' 初始化

此外，string類還支持默認構造函數和複製構造函數，如

string s1;
string s2 = "Buyun";

都是正確的寫法。當構造的string太長而無法表達時會拋出 length_error 異常。

string類的字符操作

const char &operator[](int n)const;
const char &at(int n)const;
char &operator[](int n);
char &at(int n);

說明：operator[] 和 at() 均返回當前字符串中第 n 個字符的位置，但 at 函數提供範圍檢查，當越界時會拋出 out_of_range 異常，下標運算符[]不提供檢查訪問。

const char *data()const;// 返回一個非 null 終止的 C  字符數組
const char *c_str()const;// 返回一個以 null 終止 C 字符串
int copy(char *s, int n, int pos = 0) const;// 把當前串中以 pos 開始的 n 個字符拷貝到以 s 爲起始位置的字符數組中，返回實際拷貝的數目

string的特性描述

int capacity()const;// 返回當前容量（即 string 中不必增加內存即可存放的元素個數）
int max_size()const;// 返回 string 對象中可存放的最大字符串的長度
int size()const;// 返回當前字符串的大小
int length()const;// 返回當前字符串的長度
bool empty()const;// 判斷當前字符串是否爲空
void resize(int len,char c);// 把字符串當前大小置爲 len，並用字符 'c' 填充不足的部分

string類的輸入輸出操作

string類重載了運算符 operator>> 用於輸入，同樣重載了運算符 operator<< 用於輸出操作。
函數 getline(istream &in,string &s); 用於從輸入流 in 中讀取字符串到 s 中，以換行符 '\n' 分開。

string的賦值

string &operator=(const string &s);// 把字符串 s 賦給當前字符串
string &assign(const char *s);// 用 C 類型字符串 s 賦值
string &assign(const char *s, int n);// 用 C 類型字符串 s 開始的 n 個字符賦值
string &assign(const string &s);// 把字符串 s 賦給當前字符串
string &assign(int n, char c);// 用 n 個字符 'c' 賦值給當前字符串
string &assign(const string &s, int start, int n);// 把字符串 s 中從 start 開始的 n 個字符賦給當前字符串
string &assign(const_iterator first, const_itertor last);// 把 first 和 last 迭代器之間的部分賦給字符串

string的連接

string &operator+=(const string &s);// 把字符串 s 連接到當前字符串的結尾 
string &append(const char *s);// 把 C 類型字符串 s 連接到當前字符串結尾
string &append(const char *s, int n);//把 C 類型字符串s的前n個字符連接到當前字符串結尾
string &append(const string &s);// 同 operator+=()
string &append(const string &s, int pos, int n);// 把字符串 s 中從 pos 開始的 n 個字符連接到當前字符串的結尾
string &append(int n, char c);// 在當前字符串結尾添加 n 個字符 'c'
string &append(const_iterator first, const_iterator last);// 把迭代器 first 和 last 之間的部分連接到當前字符串的結尾

string的比較

bool operator==(const string &s1, const string &s2)const;// 比較兩個字符串是否相等

// 運算符 ">","<",">=","<=","!=" 均被重載用於字符串的比較

int compare(const string &s) const;// 比較當前字符串和 s 的大小
int compare(int pos, int n, const string &s)const;// 比較當前字符串從 pos 開始的 n 個字符組成的字符串與 s 的大小
int compare(int pos, int n, const string &s, int pos2,int n2)const;// 比較當前字符串從 pos 開始的 n 個字符組成的字符串與 s 中 pos2 開始的 n2 個字符組成的字符串的大小
int compare(const char *s) const;
int compare(int pos, int n, const char *s) const;
int compare(int pos, int n, const char *s, int pos2) const;

compare函數在 > 時返回 1，< 時返回 -1，== 時返回 0  

string的子串

string substr(int pos = 0,int n = npos) const;// 返回 pos 開始的 n 個字符組成的字符串

string的交換

void swap(string &s2);// 交換當前字符串與 s2 的值

string類的查找函數

成功返回所在位置，失敗時返回 string::npos 的值 

int find(char c, int pos = 0) const;// 從 pos 開始查找字符 'c' 在當前字符串的位置
int find(const char *s, int pos = 0) const;// 從 pos 開始查找字符串 s 在當前串中的位置
int find(const char *s, int pos, int n) const;// 從 pos 開始查找字符串 s 中前 n 個字符在當前串中的位置
int find(const string &s, int pos = 0) const;// 從 pos 開始查找字符串 s 在當前串中的位置

int rfind(char c, int pos = npos) const;// 從 pos 開始從後向前查找字符 'c' 在當前串中的位置
int rfind(const char *s, int pos = npos) const;// 從 pos 開始從後向前查找 C 類型的字符串 s 的位置
int rfind(const string &s, int pos = npos) const;// 從 pos 開始從後向前查找字符串 s 的位置
int rfind(const char *s, int pos, int n = npos) const;// 從 pos 開始從後向前查找字符串 s 中前 n 個字符組成的字符串在當前串中的位置

int find_first_of(char c, int pos = 0) const;// 從 pos 開始查找字符 'c' 第一次出現的位置
int find_first_of(const string &s, int pos = 0) const;// 從 pos 開始查找字符串 s 第一次出現的位置
int find_first_of(const char *s, int pos = 0) const;// 從 pos 開始查找字符 'c' 第一次出現的位置
int find_first_of(const char *s, int pos, int n) const;// 從 pos 開始查找當前串中第一個由 s 的前 n 個字符組成的數組裏的字符的位置

int find_first_not_of(char c, int pos = 0) const;<span style="font-family: Arial, Helvetica, sans-serif;">// 從 pos 開始查找字符 'c' 第一次不出現的位置</span>
int find_first_not_of(const char *s, int pos = 0) const;
int find_first_not_of(const char *s, int pos, int n) const;
int find_first_not_of(const string &s, int pos = 0) const;// 從當前串中查找第一個不在串 s 中的字符出現的位置

int find_last_of(char c, int pos = npos) const;
int find_last_of(const char *s, int pos = npos) const;
int find_last_of(const char *s, int pos, int n = npos) const;
int find_last_of(const string &s, int pos = npos) const; 

int find_last_not_of(char c, int pos = npos) const;
int find_last_not_of(const char *s, int pos = npos) const;
int find_last_not_of(const char *s, int pos, int n) const;
int find_last_not_of(const string &s, int pos = npos) const;

string類的替換函數

string &replace(int p0, int n0, const char *s);// 刪除從 p0 開始的 n0 個字符，然後在 p0 處插入串 s
string &replace(int p0, int n0, const char *s, int n);// 刪除 p0 開始的 n0 個字符，然後在 p0 處插入字符串 s 的前 n 個字符
string &replace(int p0, int n0, const string &s);// 刪除從 p0 開始的 n0 個字符，然後在 p0 處插入串s
string &replace(int p0, int n0, const string &s, int pos, int n);// 刪除 p0 開始的 n0 個字符，然後在 p0 處插入串 s 中從 pos 開始的 n 個字符
string &replace(int p0, int n0, int n, char c);// 刪除 p0 開始的 n0 個字符，然後在 p0 處插入 n 個字符 'c'

string &replace(iterator first0, iterator last0, const char *s);// 把 [first0，last0) 之間的部分替換爲字符串 s
string &replace(iterator first0, iterator last0, const char *s, int n);// 把 [first0，last0) 之間的部分替換爲 s 的前 n 個字符
string &replace(iterator first0, iterator last0, const string &s);// 把 [first0，last0) 之間的部分替換爲串 s
string &replace(iterator first0, iterator last0, int n, char c);// 把 [first0，last0) 之間的部分替換爲n個字符 'c'
string &replace(iterator first0, iterator last0, const_iterator first, const_iterator last);// 把 [first0，last0) 之間的部分替換成 [first，last) 之間的字符串

string類的插入函數 

string &insert(int p0, const char *s);// 在 p0 位置插入 C 類型字符串 s
string &insert(int p0, const string &s);// 在 p0 位置插入字符串 s
string &insert(int p0, const char *s, int n);// 在 p0 位置插入字符串 s 前 n 個字符
string &insert(int p0, const string &s, int pos, int n);// 在 p0 位置插入字符串 s 中 pos 開始的前 n 個字符
string &insert(int p0, int n, char c);// 在 p0 處插入 n 個字符 'c'

iterator insert(iterator it, char c);// 在 it 處插入字符 'c'，返回插入後迭代器的位置
void insert(iterator it, int n, char c);// 在 it 處插入 n 個字符 'c'
void insert(iterator it, const_iterator first, const_iterator last);// 在 it 處插入 [first，last) 之間的字符

string類的刪除函數 

iterator erase(iterator first, iterator last);// 刪除 [first，last) 之間的所有字符，返回刪除後迭代器的位置
iterator erase(iterator it);// 刪除 it 指向的字符，返回刪除後迭代器的位置
string &erase(int pos = 0, int n = npos);// 刪除 pos 開始的 n 個字符，返回修改後的字符串

string類的迭代器處理

string類提供了向前和向後遍歷的迭代器iterator，迭代器提供了訪問各個字符的語法，類似於指針操作，迭代器不檢查範圍。
用 string::iterator 或 string::const_iterator 聲明迭代器變量，const_iterator 不允許改變迭代的內容。常用迭代器函數有：

const_iterator begin()const;
iterator begin();// 返回 string 的起始位置
const_iterator end()const;
iterator end();//返回 string 的最後一個字符後面的位置

const_iterator rbegin()const;
iterator rbegin();// 返回 string 的最後一個字符的位置
const_iterator rend()const;
iterator rend();//返回 string 第一個字符位置的前面

反向迭代器可以用於反向遍歷。eg：

string str = "Buyun Tang";
for(string::reverse_iterator it = str.rbegin(); it != str.rend(); it++) {
       cout << *it << ", ";
}

字符串流處理

通過定義 ostringstream 和 istringstream 變量實現，# include <sstream>  頭文件中
例如：

string input("hello,my name is Buyun");
istringstream is(input);
string s1,s2,s3,s4;
is >> s1 >> s2 >> s3 >> s4; // 結果爲 s1 = "hello,my", s2="name", s3="is", s4="Buyun"
ostringstream os;
os << s1 << s2 << s3 <<s4;
cout << os.str();