??🌟個人主頁：落葉

? 🌟當(dāng)前專欄:??C++專欄

---

目錄

為什么學(xué)習(xí)string類

C語言中的字符串

標(biāo)準(zhǔn)庫中的string類

auto和范圍for

auto關(guān)鍵字

?迭代器

范圍for

string類的常用接口說明和使用

1. string類對象的常見構(gòu)造

2.string類對象的容量操作

3.string類對象的訪問及遍歷操作 ?

4. string類對象的修改操作 ?

【push_back】在字符串后尾插字符c

?【append】在字符串后追加一個字符串

【?nd + npos(重 點(diǎn))】從字符串pos位置開始往后找字符c，返回該字符在字符串中的 位置

【r?nd】從字符串pos位置開始往前找字符c，返回該字符在字符串中的 位置。

【erase】從字符串中刪除字符

5.string類非成員函數(shù)

【operator+】盡量少用，因?yàn)閭髦捣祷?#xff0c;導(dǎo)致深拷貝效率低

【operator>> （重點(diǎn)）】輸入運(yùn)算符重載

【operator<< （重點(diǎn)）】輸出運(yùn)算符重載

【getline （重點(diǎn)）】獲取一行字符串

【relational operators （重點(diǎn)）】大小比較

string類的模擬實(shí)現(xiàn)

經(jīng)典的string類問題

?淺拷貝

?深拷貝

淺拷貝（Shallow Copy）

深拷貝（Deep Copy）

寫時拷貝(了解)

---

---

為什么學(xué)習(xí)string類

C語言中的字符串

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

標(biāo)準(zhǔn)庫中的string類

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

auto和范圍for

auto關(guān)鍵字

在這里補(bǔ)充2個C++11的小語法，方便我們后面的學(xué)習(xí)。

• 在早期C/C++中auto的含義是：使用auto修飾的變量，是具有自動存儲器的局部變量，后來這個 不重要了。C++11中，標(biāo)準(zhǔn)委員會變廢為寶賦予了auto全新的含義即：auto不再是一個存儲類型 指示符，而是作為一個新的類型指示符來指示編譯器，auto聲明的變量必須由編譯器在編譯時期 推導(dǎo)而得。
• 用auto聲明指針類型時，用auto和auto*沒有任何區(qū)別，但用auto聲明引用類型時則必須加&
• 當(dāng)在同一行聲明多個變量時，這些變量必須是相同的類型，否則編譯器將會報(bào)錯，因?yàn)榫幾g器實(shí)際 只對第一個類型進(jìn)行推導(dǎo)，然后用推導(dǎo)出來的類型定義其他變量。
• auto不能作為函數(shù)的參數(shù)，可以做返回值，但是建議謹(jǐn)慎使用
• auto不能直接用來聲明數(shù)組

auto聲明的變量編譯器會推導(dǎo)而得類型。

這個typeid是獲取變量的真實(shí)的類型，

我們可以看到類型是對得上的。

不能沒有值

// 編譯報(bào)錯:rror C3531: “e”: 類型包含“auto”的符號必須具有初始值設(shè)定項(xiàng)auto e;

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

?

auto不能用來聲明數(shù)組

當(dāng)在同一行聲明多個變量時，這些變量必須是相同的類型，否則編譯器將會報(bào)錯，因?yàn)榫幾g器實(shí)際 只對第一個類型進(jìn)行推導(dǎo)，然后用推導(dǎo)出來的類型定義其他變量。

---

?迭代器

https://legacy.cplusplus.com/reference/string/string/begin/

迭代器類似于指針，它指向容器中的一個元素，并且可以通過遞增或遞減來移動到下一個或前一個元素。迭代器提供了一組操作，如解引用（*），遞增（++），遞減（--），比較（==, !=）等。

add.begin()是指向第一個元素，

add.end()是指向最后一個元素，

通過i遍歷每個字符

在這個例子中，add.begin()返回一個指向vec第一個元素的迭代器，add.end()返回一個指向add最后一個元素之后位置的迭代器。循環(huán)中，i被用來遍歷add中的元素，*i用來訪問當(dāng)前元素的值。

迭代器使得算法可以與容器解耦，提高了代碼的復(fù)用性和靈活性。

---

范圍for

• 對于一個有范圍的集合而言，由程序員來說明循環(huán)的范圍是多余的，有時候還會容易犯錯誤。因此 C++11中引入了基于范圍的for循環(huán)。for循環(huán)后的括號由冒號“ ：”分為兩部分：第一部分是范圍 內(nèi)用于迭代的變量，第二部分則表示被迭代的范圍，自動迭代，自動取數(shù)據(jù)，自動判斷結(jié)束。
• 范圍for可以作用到數(shù)組和容器對象上進(jìn)行遍歷
• 范圍for的底層很簡單，容器遍歷實(shí)際就是替換為迭代器，這個從匯編層也可以看到。

范圍for底層就是迭代器，范圍for可以作用到數(shù)組和容器對象上進(jìn)行遍歷。

---

為什么要在auto后面加引用呢？

通過引用遍歷可以避免不必要的拷貝構(gòu)造函數(shù)的調(diào)用，從而提高性能。

這樣做有幾個優(yōu)點(diǎn)：

性能優(yōu)化：如果容器中的元素很大，或者元素是復(fù)雜類型（如類對象），通過引用遍歷可以避免不必要的拷貝構(gòu)造函數(shù)的調(diào)用，從而提高性能。

修改元素：如果需要在循環(huán)中修改容器中的元素，必須通過引用來遍歷它們。如果不使用引用，循環(huán)變量將是容器中元素的一個副本，對

副本的修改不會影響到原始容器中的元素。

舉個例子，auto&?告訴編譯器，num?是一個引用?add容器中的實(shí)際元素，而不是一個副本。因此，如果對?num?的修改會直接?add中的元素。

---

string類的常用接口說明和使用

在C++中，std::string?類是標(biāo)準(zhǔn)庫的一部分，它提供了一個方便的接口來處理字符串。std::string?位于?<string>?頭文件中，并且是?std?命名空間的一部分。

#include<string>

1. string類對象的常見構(gòu)造

https://legacy.cplusplus.com/reference/string/string/string/

(constructor)函數(shù)名稱	功能說明
string() （重點(diǎn)）	構(gòu)造空的string類對象，即空字符串
string(const char* s) （重點(diǎn)）	用C-string來構(gòu)造string類對象
string(size_t n, char c)	string類對象中包含n個字符c
string(const string&s) （重點(diǎn)）	拷貝構(gòu)造函數(shù)

?

#include<iostream>
using namespace std;
#include<string>int main()
{string s1;         //構(gòu)造空的string對象string s2("hello");//用字符串構(gòu)造string對象string s3(10, 'w');//用10個w構(gòu)造string對象string s4(s2);     //拷貝構(gòu)造函數(shù)return 0;
}

2.string類對象的容量操作

函數(shù)名稱	功能說明
size（重點(diǎn)）	返回字符串有效字符長度
capacity	返回空間總大小
empty （重點(diǎn)）	檢測字符串釋放為空串，是返回true，否則返回false
clear （重點(diǎn)）	清空有效字符
reserve （重點(diǎn)）	為字符串預(yù)留空間**
resize （重點(diǎn)）	將有效字符的個數(shù)該成n個，多出的空間用字符c填充

size我們可以看到字符串有效字符長度是5

https://legacy.cplusplus.com/reference/string/string/size/

---

?capacity返回空間總大小

https://legacy.cplusplus.com/reference/string/string/capacity/

明明只有4個字符，空間大小怎么會是15呢？

因?yàn)榈讓佑袀€16大小的數(shù)組存放數(shù)據(jù)，

當(dāng)我們給滿16個字符，會自動擴(kuò)容到32大小的空間。

---

empty（重點(diǎn)）檢測字符串釋放為空串，是返回true，否則返回false

https://legacy.cplusplus.com/reference/string/string/empty/

是空字符串返回true就是1，不是空字符串返回false就是0

---

clear （重點(diǎn)）清空有效字符

https://legacy.cplusplus.com/reference/string/string/clear/

我們可以看到清空了有效字符，但是空間大小不變。

---

reserve （重點(diǎn)）為字符串預(yù)留空間**

https://legacy.cplusplus.com/reference/string/string/reserve/

reserve 也就是擴(kuò)容空間的意思。

數(shù)據(jù)很多的話，我們可以提前擴(kuò)容空間避免多次2倍擴(kuò)容。

?

---

?resize （重點(diǎn)）將有效字符的個數(shù)改成n個，多出的空間用\0填充

https://legacy.cplusplus.com/reference/string/string/resize/

字符不變，多出來的空間都用\0填充。

這里是3，abc保留，cdef被清除。

---

注意： 1. size()與length()方法底層實(shí)現(xiàn)原理完全相同，引入size()的原因是為了與其他容器的接 口保持一致，一般情況下基本都是用size()。

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

3. resize(size_t n) 與 resize(size_t n, char c)都是將字符串中有效字符個數(shù)改變到n個，不 同的是當(dāng)字符個數(shù)增多時：resize(n)用0來填充多出的元素空間，resize(size_t n, char c)用字符c來填充多出的元素空間。注意：resize在改變元素個數(shù)時，如果是將元素個數(shù) 增多，可能會改變底層容量的大小，如果是將元素個數(shù)減少，底層空間總大小不變。

4. reserve(size_t res_arg=0)：為string預(yù)留空間，不改變有效元素個數(shù)，當(dāng)reserve的參 數(shù)小于string的底層空間總大小時，reserver不會改變?nèi)萘看笮　?/p>

---

3.string類對象的訪問及遍歷操作 ?

函數(shù)名稱	功能說明
operator[] （重 點(diǎn)）	返回pos位置的字符，const string類對象調(diào)用
begin+ end	begin獲取一個字符的迭代器 + end獲取最后一個字符下一個位 置的迭代器
rbegin + rend	begin獲取一個字符的迭代器 + end獲取最后一個字符下一個位 置的迭代器
范圍for	C++11支持更簡潔的范圍for的新遍歷方式

?operator[] （重 點(diǎn)）返回pos位置的字符，const string類對象調(diào)用】

https://legacy.cplusplus.com/reference/string/string/operator[]/

---

rbegin + rend? ? ?begin獲取一個字符的迭代器 + end獲取最后一個字符下一個位 置的迭代器。

https://legacy.cplusplus.com/reference/string/string/rbegin/

正向迭代器是iterator，反向迭代器是reverse_iterator。

reverse_iterator?是標(biāo)準(zhǔn)庫提供的一種迭代器適配器，它允許我們以逆序的方式遍歷容器。reverse_iterator?的設(shè)計(jì)是為了簡化反向遍歷容器的過程，使得我們可以像使用普通迭代器一樣使用它，但方向相反。

以下是使用?reverse_iterator?的幾個主要原因：

1.簡化代碼：使用?reverse_iterator?可以避免手動計(jì)算容器的結(jié)束位置和開始位置之間的偏移量，從而簡化代碼。

2.一致性：它提供了一種與普通迭代器使用方式一致的方法來反向遍歷容器，使得代碼更加直觀和易于理解。

3.與算法兼容：許多標(biāo)準(zhǔn)庫算法都設(shè)計(jì)為與迭代器一起工作。通過使用?reverse_iterator，我們可以將這些算法應(yīng)用于容器的反向遍歷，而無需修改算法本身。

4.安全性：使用?reverse_iterator?可以減少由于手動計(jì)算迭代器位置而可能引入的錯誤。

---

4. string類對象的修改操作 ?

函數(shù)名稱
push_back	在字符串后尾插字符c
append	在字符串后追加一個字符串
operator+= (重 點(diǎn))	在字符串后追加字符串str
c_str(重點(diǎn))	返回C格式字符串
?nd + npos(重 點(diǎn))	從字符串pos位置開始往后找字符c，返回該字符在字符串中的 位置
r?nd	從字符串pos位置開始往前找字符c，返回該字符在字符串中的 位置
substr	在str中從pos位置開始，截取n個字符，然后將其返回
erase	從字符串中刪除字符?

【push_back】在字符串后尾插字符c

https://legacy.cplusplus.com/reference/string/string/push_back/

---

?【append】在字符串后追加一個字符串

https://legacy.cplusplus.com/reference/string/string/append/

abcdefg插入了1111的后面

?

【operator+= (重 點(diǎn))】?在字符串后追加字符串str

https://legacy.cplusplus.com/reference/string/string/operator+=/

可以+=字符串和字符

也可以+=一個對象

---

?【c_str(重點(diǎn))】返回C格式字符串

https://legacy.cplusplus.com/reference/string/string/c_str/

可以返回字符串

---

【?nd + npos(重 點(diǎn))】從字符串pos位置開始往后找字符c，返回該字符在字符串中的 位置

https://legacy.cplusplus.com/reference/string/string/find/

在字符串中查找內(nèi)容

下面我們可以看到，從0下標(biāo)位置開始查找9這個字符，找到了返回9的下標(biāo)，沒有找到返回-1

沒有找到交換返回-1

---

【r?nd】從字符串pos位置開始往前找字符c，返回該字符在字符串中的 位置。

https://legacy.cplusplus.com/reference/string/string/rfind/

我們不寫下標(biāo)，默認(rèn)從最后一個下標(biāo)開始往前查找。

找到了返回下標(biāo)，沒有找到返回-1。

---

【substr 】?在str中從pos位置開始，截取n個字符，然后將其返回

https://legacy.cplusplus.com/reference/string/string/substr/

從3下標(biāo)開始截取4個字符，給s2。

我們也可以用find查找a這個下標(biāo)，?然后通過i下標(biāo)這個位置截取3個字符。

---

【erase】從字符串中刪除字符

https://legacy.cplusplus.com/reference/string/string/erase/

下面我們可以看到，從下標(biāo)1刪除到下標(biāo)5，就只剩下a和g了。

---

5.string類非成員函數(shù)

函數(shù)	功能說明
operator+	盡量少用，因?yàn)閭髦捣祷?#xff0c;導(dǎo)致深拷貝效率低
operator>> （重點(diǎn)）	輸入運(yùn)算符重載
operator<< （重點(diǎn)）	輸出運(yùn)算符重載
getline （重點(diǎn)）	獲取一行字符串
relational operators （重點(diǎn)）	大小比較

【operator+】盡量少用，因?yàn)閭髦捣祷?#xff0c;導(dǎo)致深拷貝效率低

https://legacy.cplusplus.com/reference/string/string/operator+/

我們可以看到s1是您好，s2是落葉，加起來就是您好落葉。

我們也可以加字符串

---

【operator>> （重點(diǎn)）】輸入運(yùn)算符重載

https://legacy.cplusplus.com/reference/string/string/operator%3E%3E/

可以往s1對象，輸入字符串,

但是遇到空格就會停止

---

【operator<< （重點(diǎn)）】輸出運(yùn)算符重載

https://legacy.cplusplus.com/reference/string/string/operator%3C%3C/

---

【getline （重點(diǎn)）】獲取一行字符串

https://legacy.cplusplus.com/reference/string/string/getline/

這個它遇到空格不會停止，會繼續(xù)往后讀取字符串，也會把空格給讀取了。

---

【relational operators （重點(diǎn)）】大小比較

https://legacy.cplusplus.com/reference/string/string/operators/

計(jì)算比較大小，如果大于為真，返回1，為假返回0。

---

string類的模擬實(shí)現(xiàn)

經(jīng)典的string類問題

上面已經(jīng)對string類進(jìn)行了簡單的介紹，大家只要能夠正常使用即可。在面試中，面試官總喜歡讓 學(xué)生自己來模擬實(shí)現(xiàn)string類，最主要是實(shí)現(xiàn)string類的構(gòu)造、拷貝構(gòu)造、賦值運(yùn)算符重載以及析 構(gòu)函數(shù)。大家看下以下string類的實(shí)現(xiàn)是否有問題？

// 為了和標(biāo)準(zhǔn)庫區(qū)分，此處使用String
class String
{
public:/*String():_str(new char[1]){*_str = '\0';}*///String(const char* str = "\0") 錯誤示范//String(const char* str = nullptr) 錯誤示范String(const char* str = ""){// 構(gòu)造String類對象時，如果傳遞nullptr指針，可以認(rèn)為程序非if (nullptr == str){assert(false);return;}_str = new char[strlen(str) + 1];strcpy(_str, str);}~String(){if (_str){delete[] _str;_str = nullptr;}}
private:char* _str;
};
// 測試
void TestString()
{String s1("hello bit!!!");String s2(s1);
}

說明：上述String類沒有顯式定義其拷貝構(gòu)造函數(shù)與賦值運(yùn)算符重載，此時編譯器會合成默認(rèn) 的，當(dāng)用s1構(gòu)造s2時，編譯器會調(diào)用默認(rèn)的拷貝構(gòu)造。最終導(dǎo)致的問題是，s1、s2共用同一塊內(nèi) 存空間，在釋放時同一塊空間被釋放多次而引起程序崩潰，這種拷貝方式，稱為淺拷貝。

?淺拷貝

淺拷貝：也稱位拷貝，編譯器只是將對象中的值拷貝過來。如果對象中管理資源，最后就會導(dǎo)致 多個對象共享同一份資源，當(dāng)一個對象銷毀時就會將該資源釋放掉，而此時另一些對象不知道該 資源已經(jīng)被釋放，以為還有效，所以當(dāng)繼續(xù)對資源進(jìn)項(xiàng)操作時，就會發(fā)生發(fā)生了訪問違規(guī)。

就像一個家庭中有兩個孩子，但父母只買了一份玩具，兩個孩子愿意一塊玩，則萬事大吉，萬一 不想分享就你爭我奪，玩具損壞。

可以采用深拷貝解決淺拷貝問題，即：每個對象都有一份獨(dú)立的資源，不要和其他對象共享。父 母給每個孩子都買一份玩具，各自玩各自的就不會有問題了。

?深拷貝

如果一個類中涉及到資源的管理，其拷貝構(gòu)造函數(shù)、賦值運(yùn)算符重載以及析構(gòu)函數(shù)必須要顯式給 出。一般情況都是按照深拷貝方式提供。

淺拷貝（Shallow Copy）

淺拷貝通常指的是對象之間的簡單位拷貝（bitwise?copy），這意味著新對象和原對象將共享相同的資源。在C++中，如果你沒有顯式地定義拷貝構(gòu)造函數(shù)和賦值運(yùn)算符，編譯器會為你生成默認(rèn)的版本，這些默認(rèn)版本執(zhí)行的是淺拷貝。

對于?std::string?來說，淺拷貝是不存在的，因?yàn)?std::string?內(nèi)部管理著自己的動態(tài)內(nèi)存。當(dāng)你進(jìn)行拷貝構(gòu)造或賦值操作時，std::string?會執(zhí)行深拷貝。這意味著新創(chuàng)建的字符串對象擁有自己獨(dú)立的內(nèi)存空間，與原字符串對象不共享任何資源。

深拷貝（Deep Copy）

深拷貝指的是創(chuàng)建一個新對象，并且遞歸地復(fù)制原對象中的所有元素，使得新對象和原對象完全獨(dú)立。在?std::string?的情況下，每次你進(jìn)行拷貝構(gòu)造或賦值操作時，都會執(zhí)行深拷貝

---

?stringl類模擬實(shí)現(xiàn)【代碼】

string.h

#define _CRT_SECURE_NO_WARNINGS 1#pragma once
#include<iostream>
#include<assert.h>
using namespace std;namespace bit
{class string{public://迭代器typedef char* iterator;static const int npos;string(const char* str = "");string(const string& s);~string();///擴(kuò)容void reserve(size_t n);//尾插字符void push_back(char ch);//尾插字符串void append(const char* str);string& operator+=(char ch);string& operator+=(const char* str);//傳統(tǒng)string& operator=(const string& s);//現(xiàn)代string& operator=(string s);//清除字符void clear(){_str[0] = '\0';_size = 0;}//首字符iterator begin(){return _str;}//最后的iterator end(){return _str + _size;}//返回_strchar* c_str() const{return _str;}//size_t size()const{return _size;}size_t capacity()const{return _capacity;}//指定位置修改字符char& operator[](size_t index){assert(index < _size);return _str[index];}//指定位置修改字符const char& operator[](size_t index)const{assert(index < _size);return _str[index];}////查詢字符size_t find(char ch, size_t pos = 0);//查詢字符串size_t find(const char* str, size_t pos = 0);//指定位置插入字符string& insert(size_t pos, char c);//指定位置插入字符串string& insert(size_t pos, const char* str);// 刪除pos位置上的元素，并返回該元素的下一個位置string& erase(size_t pos, size_t len);//調(diào)整字符串大小void resize(size_t n, char c = '\0');//判斷字符串是不是空bool empty()const;//字符串交換void swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}void swap(string& s, string& s1){s.swap(s1);}//流插入friend ostream& operator<<(ostream& _cout, const bit::string& s);//流提取friend istream& operator>>(istream& _cin, bit::string& s);private:char* _str;size_t _size;size_t _capacity;};//判斷大于-小于-大于等于 - 小于等于 - 等于 - 不等于bool operator<(const string& lhs, const string& rhs);bool operator>(const string& lhs, const string& rhs);bool operator<=(const string& lhs, const string& rhs);bool operator>=(const string& lhs, const string& rhs);bool operator==(const string& lhs, const string& rhs);bool operator!=(const string& lhs, const string& rhs);
}

string.cpp

#include"string.h"namespace bit
{const int string::npos = -1;//構(gòu)造string::string(const char* str):_size(strlen(str)){_capacity = _size;_str = new char[_size + 1];strcpy(_str, str);}深拷貝-(傳統(tǒng)寫法)//string::string(const string& s)//{//	_str = new char[s._capacity + 1];//	strcpy(_str, s._str);//	_size = s._size;//	_capacity = s._capacity;//}//深拷貝-(現(xiàn)代寫法)string::string(const string& s){string tmp(s._str);swap(tmp);}//析構(gòu)string::~string(){delete[] _str;_str = nullptr;_size = 0;_capacity = 0;}/////擴(kuò)容void string::reserve(size_t n){cout << "reserve:"<< n << endl;if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}//尾插字符void string::push_back(char ch){if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;_size++;}//尾插字符串void string::append(const char* str){size_t len = strlen(str);if ((_size + len) > _capacity){size_t tmp = _capacity * 2;if (tmp < (_size + len)){tmp = (_size + len);}reserve(tmp);}strcpy(_str + _size, str);_size += len;}string& string::operator+=(char ch){push_back(ch);return *this;}string& string::operator+=(const char* str){append(str);return  *this;}賦值-(傳統(tǒng)寫法)//string& string::operator=(const string& s)//{//	if (this != &s)//	{//		delete[] _str;//		_str = new char[s._capacity + 1];//		strcpy(_str, s._str);//		_size = s._size;//		_capacity = s._capacity;//	}//	return *this;//}//賦值-(現(xiàn)代寫法) string& string::operator=(string s){swap(s);return *this;}//查詢字符size_t string::find(char ch, size_t pos){assert(pos < _size);for (size_t i = pos; i < _size; i++){if (ch == _str[i]){return i;}}return npos;}//查詢字符串size_t string::find(const char* str, size_t pos){assert(pos < _size);const char* tmp = strstr(_str + pos, str);if (tmp == __nullptr){return npos;}return tmp - _str;}//在字符串里插入字符string& string::insert(size_t pos, char ch){assert(pos < _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}//循環(huán)移動字符int i = _size;while ((int)pos <= i){_str[i + 1] = _str[i];i--;}//在pos位置插入字符_str[pos] = ch;_size++;return *this;}//指定位置插入字符串string& string::insert(size_t pos, const char* str){size_t len = strlen(str);if ((_size + len) > _capacity){size_t tmp = _capacity * 2;if (tmp < (_size + len)){tmp = (_size + len);}reserve(tmp);}//循環(huán)往后移動字符size_t i = _size + len;while (pos < i){_str[i] = _str[i - len];i--;}//循環(huán)把str的字符一個一個，賦值給_str[pos+i]的位置for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size + len;return *this;}//指定位置刪除字符串string& string::erase(size_t pos, size_t len){if (len >= _size - pos){_str[pos] = '\0';_size = pos;}else{size_t i = pos + len;while (i <= _size){_str[i - len] = _str[i];i++;}_size = _size - len;}return *this;}//判斷大于-小于-大于等于 - 小于等于 - 等于 - 不等于bool operator<(const string& lhs, const string& rhs){return strcmp(lhs.c_str(), rhs.c_str()) < 0;}bool operator>(const string& lhs, const string& rhs){return !(lhs <= rhs);}bool operator<=(const string& lhs, const string& rhs){return (lhs < rhs) || (lhs == rhs);}bool operator>=(const string& lhs, const string& rhs){return !(lhs < rhs);}bool operator==(const string& lhs, const string& rhs){return strcmp(lhs.c_str(), rhs.c_str()) == 0;}bool operator!=(const string& lhs, const string& rhs){return !(lhs == rhs);}//調(diào)整字符串大小void string::resize(size_t n, char c){_str[n] = c;}//刪除pos位置上的元素，并返回該元素的下一個位置bool string::empty()const{if (_size != 0){return false;}else{return true;}}//流插入ostream& operator<<(ostream& _cout, const bit::string& s){for (size_t i = 0; i < s._size; i++){_cout << s._str[i];}return _cout;}//流提取istream& operator>>(istream& _cin, bit::string& str){str.clear();int i = 0;char buff[256];char ch;ch = _cin.get();while (ch != ' ' && ch != '\n'){buff[i++] += ch;if (i == 255){buff[i] = '\0';str += buff;i = 0;}ch = _cin.get();}if (i > 0){buff[i] = '\0';str += buff;}return _cin;}}

test.cpp【測試】

#include"string.h"//int main()
//{
//	bit::string n("asdasdf");
//	n += 'w';
//	cout << n.c_str() << endl;
//}//int main()
//{
//	bit::string n("asfsddfgdf");
//	//迭代器
//	bit::string::iterator i = n.begin();
//	while (i != n.end())
//	{
//		cout << *i << endl;
//		i++;
//	}
//}//int main()
//{
//	bit::string n("qweeqqqw");
//	//n.clear();
//	//cout << n.c_str() << endl;
//	n.insert(0, "11111111");
//	cout << n.c_str() << endl;
//}//int main()
//{
//	bit::string n("11223344556677");
//	/*n.erase(4, 99);*/
//	n[2] = 'x';
//	cout << n.c_str() << endl;
//}//int main()
//{
//	bit::string n("11223344556677");
//	bit::string s1(n);
//	cout << (n < s1) << endl;
//	cout << (n > s1) << endl;
//	cout << (n <= s1) << endl;
//	cout << (n >= s1) << endl;
//	cout << (n == s1) << endl;
//	cout << (n != s1) << endl;
//
//}//int main()
//{
//	bit::string n("11223344556677");
//	/*n.resize(8,'y');
//	n.resize(8);
//	cout << n.c_str() << endl;*/
//	
//	cout << n.empty() << endl;
//}//int main()
//{
//	string n("1122");
//	string s1("qqwee");
//	n.swap(s1);
//	cout << n << endl;
//	cout << s1 << endl;
//}int main()
{bit::string n("112233");bit::string n1 = n;//bit::string s1("qweqwer");//n.swap(s1);//cout << n << endl;//cout << s1 << endl;/*cin >> n;cout << n << endl;*///getline(cin, n);//n = n1;//swap(n, n1);//swap(n,n1);//cout << n << endl;cout << n1 << endl;
}

寫時拷貝(了解)

寫時拷貝就是一種拖延癥，是在淺拷貝的基礎(chǔ)之上增加了引用計(jì)數(shù)的方式來實(shí)現(xiàn)的。

引用計(jì)數(shù)：用來記錄資源使用者的個數(shù)。在構(gòu)造時，將資源的計(jì)數(shù)給成1，每增加一個對象使用該 資源，就給計(jì)數(shù)增加1，當(dāng)某個對象被銷毀時，先給該計(jì)數(shù)減1，然后再檢查是否需要釋放資源， 如果計(jì)數(shù)為1，說明該對象時資源的最后一個使用者，將該資源釋放；否則就不能釋放，因?yàn)檫€有 其他對象在使用該資源。 ?

寫時拷貝

寫時拷貝在讀取是的缺陷