STL

STL提供了六大組件，彼此之間可以組合套用，這六大組件分別是:容器、算法、迭代器、仿函數(shù)、適配器、空間配置器。

1. 數(shù)據(jù)結(jié)構(gòu)和容器管理：STL 提供了多種數(shù)據(jù)結(jié)構(gòu)和容器，如向量（vector）、鏈表（list）、集合（set）、映射（map）等。這些容器可以幫助程序員方便地存儲和管理數(shù)據(jù)，根據(jù)需求進(jìn)行動態(tài)調(diào)整和操作。
2. 算法和數(shù)據(jù)處理：STL 中提供了大量的算法，如排序、查找、遍歷等，這些算法可以直接應(yīng)用于不同類型的容器，幫助程序員高效地對數(shù)據(jù)進(jìn)行處理和操作。
3. 迭代器和訪問控制：STL 中的迭代器提供了統(tǒng)一的訪問接口，使得程序員能夠方便地遍歷容器中的元素并進(jìn)行讀寫操作。迭代器可以靈活地控制訪問范圍和方式，為數(shù)據(jù)訪問提供了高度的靈活性。
4. 泛型編程：STL 的設(shè)計基于泛型編程思想，通過模板機制實現(xiàn)了通用的數(shù)據(jù)結(jié)構(gòu)和算法。這使得 STL 能夠適用于各種數(shù)據(jù)類型，并且支持用戶自定義類型的操作，從而提高了代碼的重用性和可擴展性。
5. 性能優(yōu)化：STL 中的容器和算法都經(jīng)過高度優(yōu)化，使用 STL 可以借助這些優(yōu)化的實現(xiàn)來提高程序的執(zhí)行效率和性能。

總的來說，STL 適用于需要數(shù)據(jù)結(jié)構(gòu)、算法和迭代器等功能的各種場景。它為 C++ 程序員提供了豐富的工具和功能，幫助他們更加高效地處理和操作數(shù)據(jù)，提高代碼的可讀性、重用性和性能。無論是簡單的數(shù)據(jù)存儲管理還是復(fù)雜的數(shù)據(jù)處理和算法實現(xiàn)，STL 都是一個強大而實用的工具庫。

容器：各種數(shù)據(jù)結(jié)構(gòu)，如vector、list、deque、set、map等,用來存放數(shù)據(jù)，從實現(xiàn)角度來看，STL容器是一種class template。

算法：各種常用的算法，如sort、find、copy、for_each。從實現(xiàn)的角度來看，STL算法是一種function tempalte.

迭代器：扮演了容器與算法之間的膠合劑，共有五種類型，從實現(xiàn)角度來看，迭代器是一種將operator* , operator-> , operator++,operator--等指針相關(guān)操作予以重載的class template. 所有STL容器都附帶有自己專屬的迭代器，只有容器的設(shè)計者才知道如何遍歷自己的元素。原生指針(native pointer)也是一種迭代器。

仿函數(shù)：行為類似函數(shù)，可作為算法的某種策略。從實現(xiàn)角度來看，仿函數(shù)是一種重載了operator()的class 或者class template

適配器：一種用來修飾容器或者仿函數(shù)或迭代器接口的東西。

空間配置器：負(fù)責(zé)空間的配置與管理。從實現(xiàn)角度看，配置器是一個實現(xiàn)了動態(tài)空間配置、空間管理、空間釋放的class tempalte.

STL優(yōu)點

• STL 是 C++的一部分，因此不用額外安裝什么，它被內(nèi)建在你的編譯器之內(nèi)。

• STL 的一個重要特點是數(shù)據(jù)結(jié)構(gòu)和算法的分離。盡管這是個簡單的概念，但是這種分離使得 STL 變得非常通用。例如:在 STL 的 vector 容器中，可以放入元素、基礎(chǔ)數(shù)據(jù)類型變量、元素的地址；STL 的 sort() 排序函數(shù)可以用來操作 vector,list 等容器。

• 程序員可以不用思考 STL 具體的實現(xiàn)過程，只要能夠熟練使用 STL 就 OK 了。這樣他們就可以把精力放在程序開發(fā)的別的方面。

• STL 具有高可重用性，高性能，高移植性，跨平臺的優(yōu)點。

STL三大組件

容器

常用的數(shù)據(jù)結(jié)構(gòu)無外乎數(shù)組(array),鏈表(list),tree(樹)，棧(stack),隊列(queue),集合(set),映射表(map),根據(jù)數(shù)據(jù)在容器中的排列特性，這些數(shù)據(jù)分為序列式容器和關(guān)聯(lián)式容器兩種。

? 序列式容器就是容器元素在容器中的位置是由元素進(jìn)入容器的時間和地點來決定。Vector容器、Deque容器、List容器、Stack容器、Queue容器。

? 關(guān)聯(lián)式容器是指容器已經(jīng)有了一定的規(guī)則，容器元素在容器中的位置由我的規(guī)則來決定。Set/multiset容器 Map/multimap容器

算法

算法分為:質(zhì)變算法和非質(zhì)變算法。

質(zhì)變算法：是指運算過程中會更改區(qū)間內(nèi)的元素的內(nèi)容。例如拷貝，替換，刪除等等

非質(zhì)變算法：是指運算過程中不會更改區(qū)間內(nèi)的元素內(nèi)容，例如查找、計數(shù)、遍歷、尋找極值等等

迭代器

迭代器(iterator)是一種抽象的設(shè)計概念，現(xiàn)實程序語言中并沒有直接對應(yīng)于這個概念的實物。在<>一書中提供了23中設(shè)計模式的完整描述，其中iterator模式定義如下：提供一種方法，使之能夠依序?qū)ぴL某個容器所含的各個元素，而又無需暴露該容器的內(nèi)部表示方式。

迭代器的設(shè)計思維-STL的關(guān)鍵所在，STL的中心思想在于將數(shù)據(jù)容器(container)和算法(algorithms)分開，彼此獨立設(shè)計，最后再一貼膠著劑將他們撮合在一起。從技術(shù)角度來看，容器和算法的泛型化并不困難，c++的class template和function template可分別達(dá)到目標(biāo)，如果設(shè)計出兩這個之間的良好的膠著劑，才是大難題。

迭代器的種類:

void test2() {
	vector<int>r;//STL 中的標(biāo)準(zhǔn)容器之一 ：動態(tài)數(shù)組
	r.push_back(1);//vector 容器提供的插入數(shù)據(jù)的方法
	r.push_back(2);
	r.push_back(7);
	//vector 容器提供了 begin()方法 返回指向第一個元素的迭代器
	//vector 容器提供了 end()方法 返回指向最后一個元素下一個位置的迭代器
	vector<int>::iterator reg = r.begin();
	vector<int>::iterator ina = r.end();//這是一種隨機訪問類型的迭代器
	while (reg != ina) {
		cout << *reg << " ";
		reg++;
	}
	cout << endl;

	//算法 count 算法 用于統(tǒng)計元素的個數(shù)
	int total = count(reg, ina, 5);
	cout << "total:" << total << endl;
}

STL 容器不單單可以存儲基礎(chǔ)數(shù)據(jù)類型，也可以存儲類對象

class Regina {
public:
	Regina(int a) : age(a) {};
	int age;
	~Regina(){};
};
vector<Regina>r;
Regina r1(1), r2(2), r3(7);
r.push_back(r1);
r.push_back(r2);
r.push_back(r3);
vector<Regina>::iterator pStart = r.begin();
vector<Regina>::iterator pEnd = r.end();
while (pStart != pEnd) {
	cout << "pStart->age: " << pStart->age << " ";
	pStart++;
}
cout << endl;

還可以存儲類的指針

在 C++ 中，當(dāng)我們使用迭代器遍歷容器時，迭代器本身是一個指向容器中元素的對象，而不是實際的元素本身。因此，為了訪問容器中存儲的元素，我們需要通過解引用操作符 * 來獲取迭代器指向的實隕對象.具體的vector怎么用在下一篇

vector<Regina*> v;//存儲 Teacher 類型指針
Regina* r1 = new Regina(1);
Regina* r2 = new Regina(2);
Regina* r3 = new Regina(7);
v.push_back(r1);
v.push_back(r2);
v.push_back(r3);
//拿到容器迭代器
vector<Regina*>::iterator pStart = v.begin();
vector<Regina*>::iterator pEnd = v.end();
//通過迭代器遍歷
while (pStart != pEnd) {
	cout << (*pStart)->age << " ";
	pStart++;
}
cout << endl;

常用容器講解

string

C風(fēng)格字符串(以空字符結(jié)尾的字符數(shù)組)太過復(fù)雜難于掌握，不適合大程序的開發(fā)，所以C++標(biāo)準(zhǔn)庫定義了一種string類，定義在頭文件。

String和c風(fēng)格字符串對比：

• Char是一個指針，String是一個類

  string封裝了char，管理這個字符串，是一個char型的容器。

• String封裝了很多實用的成員方法

  查找find，拷貝copy，刪除delete 替換replace，插入insert

• 不用考慮內(nèi)存釋放和越界

  string管理char*所分配的內(nèi)存。每一次string的復(fù)制，取值都由string類負(fù)責(zé)維護(hù)，不用擔(dān)心復(fù)制越界和取值越界等。

string regina1("regina");
string regina2(7, '$');
string regina3(regina1);
cout << regina1 << endl;  // 輸出 "regina"
cout << regina2 << endl;  // 輸出 "$$$$$$$"
cout << regina3 << endl;  // 輸出 "regina"
regina1 += "baby";
cout << regina1 << endl;  // 輸出 "reginababy"
string regina4 = regina1 + regina3;
char arr[] = "arr loop";
string regina5(arr, 2);
string regina6(arr + 1, arr + 3);
cout << regina1 << endl;  // 輸出 "reginababy"
cout << regina4 << endl;  // 輸出 "reginababyregina"
cout << regina5 << endl;  // 輸出 "ar"
cout << regina6 << endl;  // 輸出 "rr"
string regina7(&regina4[1], &regina4[4]);
string regina8(regina4, 1, 5);
cout << regina7 << endl;  // 輸出 "egi"
cout << regina8 << endl;  // 輸出 "egina"

基本賦值操作

string& operator=(const char* s)：將 char* 類型的字符串賦值給當(dāng)前的字符串。
string& operator=(const string& s)：將另一個字符串對象 s 賦值給當(dāng)前的字符串。
string& operator=(char c)：將單個字符 c 賦值給當(dāng)前的字符串。
string& assign(const char* s)：將 char* 類型的字符串 s 賦值給當(dāng)前的字符串。
string& assign(const char* s, int n)：將 char* 類型的字符串 s 的前 n 個字符賦值給當(dāng)前的字符串。
string& assign(const string& s)：將另一個字符串對象 s 賦值給當(dāng)前的字符串。
string& assign(int n, char c)：使用 n 個字符 c 來賦值給當(dāng)前的字符串。
string& assign(const string& s, int start, int n)：將字符串 s 從位置 start 開始的 n 個字符賦值給當(dāng)前的字符串。

	string s1, s2, s3;

	// 使用賦值操作符重載將 char* 類型的字符串賦值給當(dāng)前的字符串
	s1 = "regina, baby!";
	cout << "s1: " << s1 << endl;

	// 使用賦值操作符重載將另一個字符串對象賦值給當(dāng)前的字符串
	s2 = s1;
	cout << "s2: " << s2 << endl;

	// 使用 assign() 成員函數(shù)將 char* 類型的字符串賦值給當(dāng)前的字符串
	s3.assign("regina", 4);
	cout << "s3: " << s3 << endl;

	// 使用 assign() 成員函數(shù)將另一個字符串對象賦值給當(dāng)前的字符串
	s1.assign(s3);
	cout << "s1: " << s1 << endl;

	// 使用 assign() 成員函數(shù)使用 n 個字符 c 賦值給當(dāng)前的字符串
	s2.assign(8, '*');
	cout << "s2: " << s2 << endl;

	// 使用 assign() 成員函數(shù)將字符串 s 的子串賦值給當(dāng)前的字符串
	string s4 = "regina, baby!";
	string s5;
	s5.assign(s4, 7, 5); // 從索引 7 開始的 5 個字符
	cout << "s5: " << s5 << endl;

存取字符串

1. char& operator[](int n)：通過重載 [] 運算符來獲取字符串中索引為 n 的字符。這種方式不進(jìn)行邊界檢查，如果訪問超出字符串范圍的位置，可能導(dǎo)致未定義行為。
2. char& at(int n)：通過 at 方法來獲取字符串中索引為 n 的字符。與使用 operator[] 不同的是，at 方法會進(jìn)行邊界檢查，如果訪問超出字符串范圍的位置，會拋出 out_of_range 異常。

string r = "regina";
// 使用 operator[] 獲取字符
cout << "Character at index 7 (using operator[]): " << r[5] << endl;

// 使用 at 方法獲取字符
try {
	cout << "Character at index 3 (using at): " << r.at(3) << endl;
	cout << "Character at index 13 (using at): " << r.at(13) << endl;
}
catch (const out_of_range& e) {
	cerr << "Exception caught: " << e.what() << endl;
}

cerr 是 C++ 中的一個輸出流對象，它與標(biāo)準(zhǔn)錯誤流 (stderr) 相關(guān)聯(lián)。與標(biāo)準(zhǔn)輸出流 (cout) 不同，標(biāo)準(zhǔn)錯誤流用于輸出程序中的錯誤消息和診斷信息。

cerr 對象通常會直接將消息輸出到終端或日志文件，而不會進(jìn)行緩沖操作。這意味著錯誤消息會立即顯示在終端上，而不需要等待緩沖區(qū)刷新。因此，cerr 在處理錯誤和調(diào)試信息時非常有用。

拼接字符串

string& operator+=(const string& str), string& operator+=(const char* str), string& operator+=(const char c)：這些是重載 += 操作符的方法，用于將另一個字符串、C風(fēng)格字符串或字符連接到當(dāng)前字符串的末尾。

string& append(const char *s)：將 C 風(fēng)格的字符串 s 追加到當(dāng)前字符串的末尾。

string& append(const char *s, int n)：將 C 風(fēng)格的字符串 s 的前 n 個字符追加到當(dāng)前字符串的末尾。

string& append(const string& s)：將字符串 s 追加到當(dāng)前字符串的末尾，與 operator+= 的功能類似。

string& append(const string& s, int pos, int n)：將字符串 s 中從索引 pos 開始的 n 個字符追加到當(dāng)前字符串的末尾。

string& append(int n, char c)：在當(dāng)前字符串的末尾添加 n 個字符 c。

string str = "Hello";

    // 使用 += 操作符連接字符串
    str += ", world!";
    cout << "After +=: " << str << endl;

    // 使用 append(const char*) 連接字符串
    str.append(" This is a test.");
    cout << "After append(const char*): " << str << endl;

    // 使用 append(const string&) 連接字符串
    string additional = " Have a nice day!";
    str.append(additional);
    cout << "After append(const string&): " << str << endl;

    // 使用 append(const char*, int) 連接部分字符串
    str.append(" Testing", 4); // 添加 " Test"
    cout << "After append(const char*, int): " << str << endl;

    // 使用 append(int, char) 添加字符
    str.append(3, '!'); // 添加 "!!!"
    cout << "After append(int, char): " << str << endl;

查找和替換

	string words = "regina baby is my sM baby";
	int pos = words.find("baby");
	cout << pos << '\n';
	pos = words.find("sM", 4, 2);
	cout << pos << '\n';
	pos = words.rfind("baby");
	cout << pos << '\n';

比較操作

/*
compare函數(shù)在>時返回 1，<時返回 -1，==時返回 0。
比較區(qū)分大小寫，比較時參考字典順序，排越前面的越小。
大寫的A比小寫的a小。
*/
int compare(const string& s) const;//與字符串s比較
int compare(const char *s) const;//與字符串s比較

	string s1 = "regina";
	string s2 = "ivanlee";
	cout << "s1.compare(s2): " << s1.compare(s2) << "\n";
	const char* cs2 = "leeivan";
	cout << "s2.compare(cs2): " << s2.compare(cs2) << "\n";

插入和刪除

string& insert(int pos, constchar* s); //插入字符串
string& insert(int pos, conststring& str); //插入字符串
string& insert(int pos, int n, char c);//在指定位置插入n個字符c
string& erase(int pos, int n = npos);//刪除從Pos開始的n個字符 

	string s = "hello regina";
	s.insert(5, "beautiful");
	cout << s << "\n";
	s.insert(s.length(), 2, '!'); //單引號
	cout << s << "\n";
	s.erase(5, 3);
	cout << s << "\n";

string和c-style字符串轉(zhuǎn)換

	string s = "regina";
	const char* c = s.c_str();//返回的是一個指向常量字符的指針
	cout << "s.c_str(): " << typeid(c).name() << endl;
	const char* c1 = "regina";
	string s1(s);
	cout << "string s1(s); " << typeid(s1).name() << endl;

在c++中存在一個從const char*到string的隱式類型轉(zhuǎn)換，卻不存在從一個string對象到C_string的自動類型轉(zhuǎn)換。對于string類型的字符串，可以通過c_str()函數(shù)返回string對象對應(yīng)的C_string.

通常，程序員在整個程序中應(yīng)堅持使用string類對象，直到必須將內(nèi)容轉(zhuǎn)化為char*時才將其轉(zhuǎn)換為C_string.

為了修改string字符串的內(nèi)容，下標(biāo)操作符[]和at都會返回字符的引用。但當(dāng)字符串的內(nèi)存被重新分配之后，可能發(fā)生錯誤.

自動擴容

在 C++ 的標(biāo)準(zhǔn)庫中，std::string 類具有自動調(diào)整大小的功能。當(dāng)你向 std::string 對象添加字符時，如果當(dāng)前容量不足以存儲新的字符，std::string 會自動重新分配內(nèi)存以擴展容量，從而確?？梢源鎯π碌淖址⒈３肿址挠行?。

這種自動調(diào)整大小的過程是由 std::string 類內(nèi)部管理的，開發(fā)者無需手動管理字符串的內(nèi)存大小。當(dāng)添加字符導(dǎo)致字符串超出當(dāng)前容量時，std::string 會選擇一個新的更大的內(nèi)存塊，將舊數(shù)據(jù)復(fù)制到新的內(nèi)存塊中，并釋放舊的內(nèi)存塊。

這種自動調(diào)整大小的機制使得 std::string 更加方便和易用，開發(fā)者可以專注于操作字符串內(nèi)容而不必?fù)?dān)心內(nèi)存管理的細(xì)節(jié)。

	std::string str = "regina";
	std::cout << "Initial capacity: " << str.capacity() << std::endl;
	// 添加字符，觀察容量的變化
	for (char c = 'a'; c <= 'z'; ++c) {
		str.push_back(c);
		std::cout << "Capacity after adding '" << c << "': " << str.capacity() << std::endl;
	}

std::string 類提供了 capacity() 方法，用于返回當(dāng)前字符串對象的容量大小。容量表示為當(dāng)前存儲空間的大小，它可能大于等于字符串的長度，因為 std::string 可能會分配比實際字符串長度更多的內(nèi)存，以便進(jìn)行后續(xù)的添加操作而不需要頻繁地重新分配內(nèi)存。

通常情況下，當(dāng)你向 std::string 對象添加字符時，如果當(dāng)前的容量不足以存儲新的字符，std::string 會自動重新分配內(nèi)存以擴展容量，從而確?？梢源鎯π碌淖址⒈３肿址挠行?。這樣的設(shè)計可以提高性能，因為它避免了頻繁的內(nèi)存分配和釋放操作。

文章來源地址http://www.zghlxwxcb.cn/news/detail-837864.html

到了這里，關(guān)于C++STL學(xué)習(xí)第一篇（什么是STL以及string的各種功能用法）的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！