C++标準庫第十三章字元串--上半節

C++标準庫中的String Class是用來處理字元串的類。它提供了一系列的成員函數和操作符，可以友善地進行字元串的操作和處理。

String Class的目的是為了台灣字元串的操作和管理。它封裝了字元串的存儲和操作細節，使得程式員可以更加專注于字元串的邏輯處理，而不需要關注底層的記憶體管理和字元串操作的細節。

舉例來說，我們可以使用String Class來建立一個字元串對象，并對其進行各種操作，比如拼接、截取、查找等等。下面是一個使用String Class的簡單示例：

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";

    // 字元串拼接
    std::string result = str1 + " " + str2;

    // 字元串長度
    std::cout << "Length: " << result.length() << std::endl;

    // 字元串查找
    if (result.find("World") != std::string::npos) {
        std::cout << "Found!" << std::endl;
    }

    return 0;
}

在上面的示例中，我們使用了String Class的成員函數來進行字元串的拼接、長度擷取和查找操作。這些操作都是通過String Class提供的方法來實作的，使得代碼更加簡潔和易讀。

總而言之，C++标準庫中的String Class的目的是為了提供一種友善、高效的方式來處理字元串，使得程式員可以更加專注于字元串的邏輯處理，而不需要關注底層的實作細節。

std::string::npos是一個std::string類中的靜态成員常量，表示一個無效的或無法找到的位置。

std::string::npos的值是一個特定的标記值，通常被定義為-1，表示在字元串中無法找到指定的子字元串或字元。

在字元串的相關操作中，std::string::npos常常用于表示找不到比對的位置或結束标志。

例如，可以使用std::string::find()函數來查找一個子字元串在另一個字元串中的位置，如果找不到該子字元串，則傳回std::string::npos。

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    std::size_t pos = str.find("abc"); // 在str中查找子字元串"abc"
    
    if (pos == std::string::npos) {
        std::cout << "Subtring not found." << std::endl;
    } else {
        std::cout << "Substring found at position: " << pos << std::endl;
    }
    
    return 0;
}

輸出結果：

Substring not found.

在上述示例中，由于字元串"abc"在str中不存在，是以find()函數傳回std::string::npos，表示未找到子字元串。

在C++标準庫中，可以使用臨時檔案名來建立臨時檔案，這在一些需要臨時存儲資料的場景中非常有用。通過使用C++标準庫中的函數，可以生成唯一的臨時檔案名，以確定檔案名的唯一性和避免沖突。

舉例來說，可以使用C++标準庫中的函數std::tmpnam來生成臨時檔案名。該函數接受一個字元數組作為參數，将生成的臨時檔案名存儲在該數組中。下面是一個示例代碼：

#include <iostream>
#include <cstdio>

int main() {
    char filename[L_tmpnam];
    std::tmpnam(filename);
    std::cout << "臨時檔案名：" << filename << std::endl;
    return 0;
}

運作以上代碼，将會輸出一個唯一的臨時檔案名，例如：

臨時檔案名：C:\Users\Username\AppData\Local\Temp\fileS7T8Zf

這樣，我們就可以使用生成的臨時檔案名來建立臨時檔案，并進行相應的操作。需要注意的是，std::tmpnam函數并不能保證生成的臨時檔案名是安全的，是以在實際使用中需要注意安全性。

C++标準庫中的String Class是用于處理字元串的類。它提供了許多成員函數和操作符重載，使得對字元串的操作更加友善和高效。

String Class的細節描述如下：

構造函數：String Class提供了多個構造函數，可以使用不同的方式來建立字元串對象。例如：
String str; // 預設構造函數，建立一個空字元串
String str("Hello"); // 使用C風格字元串建立字元串對象
String str2(str); // 使用另一個字元串對象來初始化新的字元串對象
成員函數：
length()：傳回字元串的長度。
empty()：檢查字元串是否為空。
clear()：清空字元串内容。
append()：将一個字元串追加到目前字元串的末尾。
substr()：傳回一個子字元串，可以指定起始位置和長度。
find()：在字元串中查找指定的子字元串，并傳回第一次出現的位置。
操作符重載：
=：用于字元串的指派操作。
+：用于字元串的拼接操作。
[]：用于通路字元串中的單個字元。

舉例：

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";

    std::string str3 = str1 + " " + str2; // 字元串拼接
    std::cout << str3 << std::endl; // 輸出：Hello World

    std::cout << str3.length() << std::endl; // 輸出：11

    std::string subStr = str3.substr(0, 5); // 提取子字元串
    std::cout << subStr << std::endl; // 輸出：Hello

    int index = str3.find("World"); // 查找子字元串
    std::cout << index << std::endl; // 輸出：6

    return 0;
}

上述代碼示範了如何使用String Class來操作字元串。首先，我們建立了兩個字元串對象str1和str2，然後使用+操作符将它們拼接成一個新的字元串對象str3。接着，我們使用length()函數擷取字元串的長度，并使用substr()函數提取出子字元串。最後，我們使用find()函數查找子字元串的位置。

C++标準庫中的String類是用來處理字元串的類。它提供了各種方法和操作符，用于處理字元串的建立、修改、查找、比較等操作。下面是C++标準庫String類的一些相關類型的解釋及舉例：

std::string：這是String類的主要類型，用于表示字元串。它是一個可變長度的字元序列，可以包含任意字元，包括空字元。舉例：

std::string str = "Hello World!";
std::cout << str << std::endl;  // 輸出：Hello World!

std::wstring：這是String類的寬字元版本，用于表示寬字元串。它使用wchar_t類型表示字元，可以包含任意Unicode字元。舉例：

std::wstring wstr = L"你好，世界！";
std::wcout << wstr << std::endl;  // 輸出：你好，世界！

std::u16string：這是String類的UTF-16版本，用于表示UTF-16編碼的字元串。它使用char16_t類型表示字元，可以包含任意Unicode字元。舉例：

std::u16string u16str = u"こんにちは、世界！";
std::wcout << u16str << std::endl;  // 輸出：こんにちは、世界！

std::u32string：這是String類的UTF-32版本，用于表示UTF-32編碼的字元串。它使用char32_t類型表示字元，可以包含任意Unicode字元。舉例：

std::u32string u32str = U"안녕하세요, 세상!";
std::wcout << u32str << std::endl;  // 輸出：안녕하세요, 세상!

這些類型都是String類的不同版本，用于處理不同的字元編碼和字元集。可以根據具體需要選擇适合的類型來操作字元串。

C++标準庫提供了許多操作函數來處理字元串。下面是一些常用的操作函數的概覽：

size()：傳回字元串的長度。
std::string str = "Hello"; std::cout << str.size(); // 輸出 5
length()：傳回字元串的長度，與size()功能相同。
std::string str = "Hello"; std::cout << str.length(); // 輸出 5
empty()：檢查字元串是否為空。
std::string str = "Hello"; if (str.empty()) { std::cout << "字元串為空"; } else { std::cout << "字元串不為空"; }
clear()：清空字元串内容。
std::string str = "Hello"; str.clear(); std::cout << str; // 輸出空字元串
push_back(char c)：在字元串末尾添加一個字元。
std::string str = "Hello"; str.push_back('!'); std::cout << str; // 輸出 "Hello!"
pop_back()：删除字元串末尾的一個字元。
std::string str = "Hello!"; str.pop_back(); std::cout << str; // 輸出 "Hello"
insert(pos, str)：在指定位置插入一個字元串。
std::string str = "Hello"; str.insert(2, " world"); std::cout << str; // 輸出 "He worldllo"
erase(pos, len)：删除指定位置開始的指定長度的字元。
std::string str = "Hello world"; str.erase(6, 5); std::cout << str; // 輸出 "Hello"
replace(pos, len, str)：用指定字元串替換從指定位置開始的指定長度的字元。
std::string str = "Hello world"; str.replace(6, 5, "C++"); std::cout << str; // 輸出 "Hello C++"
substr(pos, len)：傳回從指定位置開始的指定長度的子字元串。
std::string str = "Hello world"; std::string sub = str.substr(6, 5); std::cout << sub; // 輸出 "world"

這些操作函數可以幫助我們對字元串進行常見的操作，如擷取長度、判斷是否為空、添加、删除、插入、替換和提取子字元串等。

C++标準庫中的字元串類（std::string）提供了多個構造函數和析構函數，用于建立和銷毀字元串對象。

構造函數用于建立字元串對象，可以接受不同類型的參數：

預設構造函數：建立一個空字元串對象。
std::string str; // 建立一個空字元串對象
字元串字面值構造函數：接受一個字元串字面值參數，建立一個字元串對象。
std::string str("Hello"); // 建立一個字元串對象，内容為"Hello"
拷貝構造函數：接受一個字元串對象作為參數，建立一個新的字元串對象，内容和參數相同。
std::string str1("Hello"); std::string str2(str1); // 建立一個新的字元串對象，内容和str1相同
帶起始位置和長度的構造函數：接受一個字元串對象、起始位置和長度作為參數，建立一個新的字元串對象，内容為參數指定位置和長度的子串。
std::string str1("Hello World"); std::string str2(str1, 6, 5); // 建立一個新的字元串對象，内容為"World"

析構函數用于銷毀字元串對象，在對象被銷毀時自動調用，釋放對象占用的記憶體。

std::string str("Hello");
// 對象str在這裡超出了作用域，析構函數被調用，釋放記憶體

C++标準庫中的字元串類（std::string）和C-字元串（C-String）是兩種不同的字元串表示方式。

字元串類（std::string）是C++标準庫提供的字元串類型，它是一個類模闆，封裝了字元串的操作和功能。使用字元串類可以友善地進行字元串的操作和處理。
#include <iostream> #include <string> int main() { std::string str = "Hello"; std::cout << str << std::endl; // 輸出 Hello str += " World"; std::cout << str << std::endl; // 輸出 Hello World return 0; }
C-字元串是以字元數組的形式表示的字元串，以null字元（'\0'）作為字元串的結束标志。C-字元串使用C語言的字元數組和字元指針來表示和操作。
#include <iostream> #include <cstring> int main() { char str[6] = "Hello"; std::cout << str << std::endl; // 輸出 Hello strcat(str, " World"); std::cout << str << std::endl; // 輸出 Hello World return 0; }

需要注意的是，C++标準庫中的字元串類和C-字元串是不相容的，不能直接進行指派或比較操作。如果需要将字元串類和C-字元串進行轉換，可以使用字元串類的成員函數c_str()和C-字元串的轉換函數std::string()。

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello";
    const char* cstr = str.c_str();
    std::cout << cstr << std::endl; // 輸出 Hello

    std::string newStr = std::string(cstr);
    std::cout << newStr << std::endl; // 輸出 Hello

    return 0;
}

在C++标準庫中，字元串類（std::string）提供了兩個成員函數來擷取字元串的大小和容量。

大小（Size）：字元串的大小指的是字元串中字元的個數，不包括結尾的空字元。可以使用成員函數size()或length()來擷取字元串的大小。
std::string str = "Hello"; int size = str.size(); // 擷取字元串的大小，size的值為5
容量（Capacity）：字元串的容量指的是為字元串配置設定的記憶體空間的大小。可以使用成員函數capacity()來擷取字元串的容量。
std::string str = "Hello"; int capacity = str.capacity(); // 擷取字元串的容量，capacity的值可能大于等于5

需要注意的是，字元串的大小和容量不總是相等的。當字元串的大小超過了目前容量時，字元串會自動重新配置設定更大的記憶體空間來容納更多的字元。這個過程稱為動态記憶體配置設定。是以，字元串的容量可能會大于其大小。

在C++标準庫中，字元串類（std::string）提供了多種方法來通路字元串的元素。

使用下标運算符[]：可以使用下标運算符[]來通路字元串中的單個字元。下标從0開始，可以使用正整數或負整數作為索引。
#include <iostream> #include <string> int main() { std::string str = "Hello"; char ch1 = str[0]; // 通路第一個字元 'H' char ch2 = str[4]; // 通路最後一個字元 'o' std::cout << ch1 << " " << ch2 << std::endl; return 0; }
使用at()函數：at()函數與下标運算符類似，可以用來通路字元串中的單個字元。但是，與下标運算符不同的是，at()函數會進行邊界檢查，如果索引超出了字元串的範圍，會抛出一個std::out_of_range異常。
#include <iostream> #include <string> int main() { std::string str = "Hello"; char ch1 = str.at(0); // 通路第一個字元 'H' char ch2 = str.at(4); // 通路最後一個字元 'o' std::cout << ch1 << " " << ch2 << std::endl; return 0; }
使用front()和back()函數：front()函數用于通路字元串的第一個字元，back()函數用于通路字元串的最後一個字元。
#include <iostream> #include <string> int main() { std::string str = "Hello"; char first = str.front(); // 通路第一個字元 'H' char last = str.back(); // 通路最後一個字元 'o' std::cout << first << " " << last << std::endl; return 0; }

總結：字元串類提供了多種方法來通路字元串的元素，包括下标運算符[]、at()函數、front()函數和back()函數。可以根據需要選擇合适的方法來通路字元串中的元素。

在C++标準庫中，字元串類（std::string）提供了多種方法來比較字元串的内容。

使用比較運算符：可以使用比較運算符（==、!=、<、>、<=、>=）來比較兩個字元串的内容。比較運算符會按照字典序比較字元串的字元。
#include <iostream> #include <string> int main() { std::string str1 = "Hello"; std::string str2 = "World"; if (str1 == str2) { std::cout << "str1 is equal to str2" << std::endl; } else if (str1 < str2) { std::cout << "str1 is less than str2" << std::endl; } else { std::cout << "str1 is greater than str2" << std::endl; } return 0; }
使用成員函數compare()：字元串類提供了成員函數compare()來比較兩個字元串的内容。compare()函數傳回一個整數，表示兩個字元串的比較結果。如果傳回值為0，則表示兩個字元串相等；如果傳回值小于0，則表示第一個字元串小于第二個字元串；如果傳回值大于0，則表示第一個字元串大于第二個字元串。
#include <iostream> #include <string> int main() { std::string str1 = "Hello"; std::string str2 = "World"; int result = str1.compare(str2); if (result == 0) { std::cout << "str1 is equal to str2" << std::endl; } else if (result < 0) { std::cout << "str1 is less than str2" << std::endl; } else { std::cout << "str1 is greater than str2" << std::endl; } return 0; }

總結：字元串類提供了比較運算符和compare()函數來比較字元串的内容。可以根據需要選擇合适的方法來進行字元串的比較。

在C++标準庫中，字元串類（std::string）提供了多種方法來修改字元串的内容。

使用指派運算符=：可以使用指派運算符=來将一個字元串指派給另一個字元串。
#include <iostream> #include <string> int main() { std::string str1 = "Hello"; std::string str2 = "World"; str1 = str2; // 将str2的内容指派給str1 std::cout << str1 << std::endl; // 輸出 "World" return 0; }
使用assign()函數：assign()函數可以用來将一個字元串指派給另一個字元串，或者将一個子字元串指派給另一個字元串的一部分。
#include <iostream> #include <string> int main() { std::string str1 = "Hello"; std::string str2 = "World"; str1.assign(str2); // 将str2的内容指派給str1 std::cout << str1 << std::endl; // 輸出 "World" std::string str3 = "Hello"; std::string str4 = "World"; str3.assign(str4, 0, 3); // 将str4的前三個字元指派給str3 std::cout << str3 << std::endl; // 輸出 "Wor" return 0; }
使用insert()函數：insert()函數可以在指定位置插入一個字元串或字元。
#include <iostream> #include <string> int main() { std::string str = "Hello"; str.insert(2, "World"); // 在位置2插入字元串 "World" std::cout << str << std::endl; // 輸出 "HeWorldllo" str.insert(5, 1, '-'); // 在位置5插入字元 '-' std::cout << str << std::endl; // 輸出 "HeWor-ldllo" return 0; }
使用erase()函數：erase()函數可以删除指定位置的字元或一段字元。
#include <iostream> #include <string> int main() { std::string str = "Hello World"; str.erase(5, 5); // 删除從位置5開始的5個字元 std::cout << str << std::endl; // 輸出 "Hello" str.erase(2); // 删除從位置2開始到末尾的所有字元 std::cout << str << std::endl; // 輸出 "He" return 0; }

總結：字元串類提供了多種方法來修改字元串的内容，包括指派運算符=、assign()函數、insert()函數和erase()函數。可以根據需要選擇合适的方法來修改字元串的内容。

在C++标準庫中，字元串類（std::string）提供了子字元串和字元串接合的功能。

子字元串：可以使用substr()函數來擷取原字元串的子字元串。該函數接受兩個參數，第一個參數是子字元串的起始位置，第二個參數是子字元串的長度。
#include <iostream> #include <string> int main() { std::string str = "Hello World"; std::string subStr = str.substr(6, 5); // 擷取從位置6開始的長度為5的子字元串 std::cout << "Sub String: " << subStr << std::endl; return 0; }
輸出結果為：Sub String: World
字元串接合：可以使用+運算符或append()函數來将兩個字元串連接配接起來。
#include <iostream> #include <string> int main() { std::string str1 = "Hello"; std::string str2 = "World"; std::string result = str1 + " " + str2; // 使用+運算符連接配接字元串 std::cout << "Concatenated String: " << result << std::endl; str1.append(" "); // 使用append()函數連接配接字元串 str1.append(str2); std::cout << "Concatenated String: " << str1 << std::endl; return 0; }
輸出結果為：Concatenated String: Hello World

在C++标準庫中，I/O操作符（輸入/輸出操作符）用于從輸入流（如鍵盤、檔案）讀取資料或将資料寫入輸出流（如螢幕、檔案）。

輸入操作符（>>）：用于從輸入流中讀取資料并将其存儲到變量中。
#include <iostream> int main() { int num; std::cout << "Enter a number: "; std::cin >> num; // 從鍵盤讀取一個整數 std::cout << "You entered: " << num << std::endl; return 0; }
輸出操作符（<<）：用于将資料寫入輸出流。
#include <iostream> int main() { std::cout << "Hello, World!" << std::endl; // 将字元串輸出到螢幕 return 0; }

這些操作符可以用于各種資料類型，包括整數、浮點數、字元、字元串等。

在C++标準庫中，npos是一個常量，表示無效的或不存在的位置。

它通常與字元串類（如std::string）的成員函數find()一起使用，用于訓示未找到比對項的情況。

舉例來說，假設我們有一個字元串str，我們想要查找子字元串"abc"的位置：

#include <iostream>
#include <string>

int main() {
    std::string str = "defghijklm";
    std::string subStr = "abc";

    size_t found = str.find(subStr);
    if (found != std::string::npos) {
        std::cout << "Substring found at position: " << found << std::endl;
    } else {
        std::cout << "Substring not found" << std::endl;
    }

    return 0;
}

在上面的例子中，由于字元串str中不存在子字元串"abc"，find()函數傳回了npos，是以輸出結果為"Substring not found"。

npos的值是一個特定的無符号整數，通常是一個很大的值（如std::string::npos的值是-1）。是以，我們可以通過檢查find()函數的傳回值是否等于npos來判斷是否找到了比對項。

在C++标準庫中，數值轉換是指将不同類型的數值進行轉換的過程。C++标準庫提供了一些函數和類來執行數值轉換操作。

stoi()和stol()：這些函數用于将字元串轉換為整數或長整數。例如：

#include <iostream>
#include <string>

int main() {
    std::string str = "12345";
    int num = std::stoi(str);
    std::cout << num << std::endl; // 輸出：12345
    return 0;
}

to_string()：這個函數用于将數字轉換為字元串。例如：

#include <iostream>
#include <string>

int main() {
    int num = 12345;
    std::string str = std::to_string(num);
    std::cout << str << std::endl; // 輸出：12345
    return 0;
}

stringstream類：這個類可以用于在字元串和數值之間進行轉換。例如：

#include <iostream>
#include <string>
#include <sstream>

int main() {
    std::string str = "12345";
    int num;
    std::stringstream ss(str);
    ss >> num;
    std::cout << num << std::endl; // 輸出：12345

    num = 67890;
    std::stringstream ss2;
    ss2 << num;
    std::string str2 = ss2.str();
    std::cout << str2 << std::endl; // 輸出：67890

    return 0;
}

這些是C++标準庫中一些常用的數值轉換函數和類的例子。它們可以幫助我們在不同的數值類型之間進行轉換，友善資料處理和操作。

在C++标準庫中，字元串類std::string提供了對疊代器的支援。疊代器是一種類似指針的對象，可以用于周遊容器中的元素。

std::string類提供了begin()和end()成員函數，用于擷取指向字元串的第一個字元和最後一個字元之後的位置的疊代器。這樣，我們可以使用疊代器來周遊字元串中的每個字元。

以下是一個示例：

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    
    // 使用疊代器周遊字元串
    for (auto it = str.begin(); it != str.end(); ++it) {
        std::cout << *it;
    }
    
    return 0;
}

輸出結果為：

Hello, World!

在上面的示例中，我們使用疊代器it來周遊字元串str中的每個字元，并使用*it來通路疊代器指向的字元。

在C++标準庫中，國際化（Internationalization）是指為了适應不同地區和語言的需求，提供了一些函數和類來處理多語言和多地區的問題。

C++标準庫中的國際化支援主要通過locale類來實作。locale類提供了一種機制，可以根據特定的地區和語言設定來調整程式的行為。

例如，可以使用locale類的facet來設定日期、時間、貨币、數字格式等。下面是一個示例：

#include <iostream>
#include <locale>

int main() {
    std::locale::global(std::locale("")); // 設定目前地區的預設locale

    std::cout.imbue(std::locale()); // 使用預設locale來格式化輸出

    double num = 12345.6789;
    std::cout << num << std::endl; // 輸出：12,345.6789

    return 0;
}

在這個示例中，使用std::locale::global()函數設定了目前地區的預設locale為系統預設的地區設定。然後使用std::cout.imbue()函數将預設locale應用于std::cout流，以便在輸出時使用正确的數字格式。最後輸出一個浮點數，會根據地區的不同而使用适當的數字格式。

在C++标準庫中，效率（Performance）是指庫中的函數和類在執行時所消耗的時間和資源的數量。C++标準庫的設計目标之一就是提供高效的實作，以最大限度地減少執行時間和資源消耗。

C++标準庫提供了許多經過優化的算法和資料結構，以提高程式的執行效率。例如，标準庫中的容器類（如std::vector、std::list、std::map等）都是經過優化的資料結構，它們在插入、删除和通路元素時都具有高效的性能。

另外，标準庫中的算法函數（如std::sort、std::find、std::accumulate等）也經過了優化，以提供高效的執行速度。這些算法函數使用了各種優化技術，如使用快速排序算法、二分查找算法等，以提高執行效率。

以下是一個示例，展示了如何使用C++标準庫中的算法函數來實作對一個數組的排序：

#include <iostream>
#include <algorithm>

int main() {
    int arr[] = {5, 2, 8, 1, 9};
    int size = sizeof(arr) / sizeof(arr[0]);
    
    std::sort(arr, arr + size);
    
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }
    
    return 0;
}

該示例使用std::sort函數對數組進行排序，std::sort函數使用了高效的排序算法來提高執行效率。

C++标準庫中的String和Vector是兩個常用的容器類。

String類是用于處理字元串的類，提供了一系列的成員函數來進行字元串的操作。例如，可以使用String類的成員函數來擷取字元串的長度、連接配接字元串、截取子串等。下面是一個使用String類的示例：

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";

    std::string str3 = str1 + " " + str2; // 連接配接字元串
    std::cout << str3 << std::endl; // 輸出 "Hello World"

    std::string subStr = str3.substr(6, 5); // 截取子串
    std::cout << subStr << std::endl; // 輸出 "World"

    return 0;
}

Vector類是一個動态數組容器，可以在運作時動态地調整數組的大小。Vector類提供了一系列的成員函數來進行數組的操作。例如，可以使用Vector類的成員函數來添加元素、删除元素、通路元素等。下面是一個使用Vector類的示例：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;

    vec.push_back(1); // 添加元素
    vec.push_back(2);
    vec.push_back(3);

    std::cout << "Size: " << vec.size() << std::endl; // 輸出數組大小

    vec.pop_back(); // 删除最後一個元素

    std::cout << "Size: " << vec.size() << std::endl; // 輸出數組大小

    std::cout << "Elements: ";
    for (int i : vec) {
        std::cout << i << " "; // 輸出數組元素
    }
    std::cout << std::endl;

    return 0;
}

這是使用C++标準庫中String和Vector的基本示例，它們是非常常用的容器類，可以友善地進行字元串和數組的操作。

C++标準庫中的String類是用于處理字元串的類，它提供了一系列的成員函數和操作符重載，友善進行字元串的操作。

String類的特點包括：

動态記憶體管理：String類會自動管理字元串的記憶體，無需手動配置設定和釋放記憶體。
可變性：String類中的字元串是可變的，可以通過成員函數修改字元串的内容。
字元串操作：String類提供了豐富的字元串操作函數，如字元串的拼接、查找、替換、截取等。

下面是一個使用String類的簡單示例：

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";

    // 擷取字元串長度
    std::cout << "Length: " << str.length() << std::endl;

    // 字元串拼接
    str += " I'm C++.";
    std::cout << "Concatenated string: " << str << std::endl;

    // 查找子串
    std::size_t found = str.find("C++");
    if (found != std::string::npos) {
        std::cout << "Substring found at index: " << found << std::endl;
    } else {
        std::cout << "Substring not found." << std::endl;
    }

    // 替換子串
    str.replace(found, 3, "C++ programming");
    std::cout << "Replaced string: " << str << std::endl;

    return 0;
}

輸出結果：

Length: 13
Concatenated string: Hello, World! I'm C++.
Substring found at index: 17
Replaced string: Hello, World! I'm C++ programming.

在這個示例中，我們使用了String類的length()函數擷取字元串的長度，使用+=操作符進行字元串的拼接，使用find()函數查找子串的位置，使用replace()函數替換子串。

C++标準庫中定義了許多常用的類型和靜态值，這些定義可以在程式中直接使用，無需額外的聲明或定義。

一些常用的類型定義包括：

size_t：無符号整數類型，用于表示對象的大小或數組的長度。
iterator：疊代器類型，用于周遊容器中的元素。
string：字元串類型，用于表示文本資料。
vector：向量類型，用于表示可變長度的數組。
map：映射類型，用于表示鍵值對的集合。

一些常用的靜态值包括：

nullptr：表示空指針。
true和false：表示布爾類型的真和假。
numeric_limits<T>::max()：表示類型T的最大值。
numeric_limits<T>::min()：表示類型T的最小值。

以下是一個使用C++标準庫類型定義和靜态值的示例：

#include <iostream>
#include <cstddef>
#include <vector>
#include <string>

int main() {
    size_t size = 10;
    std::vector<int> numbers(size);
    
    for (size_t i = 0; i < size; i++) {
        numbers[i] = i;
    }
    
    std::string message = "Hello, world!";
    
    std::cout << "Size of numbers vector: " << numbers.size() << std::endl;
    std::cout << "Message: " << message << std::endl;
    
    return 0;
}

在上面的示例中，使用了size_t類型來表示向量的大小，使用vector類型來定義一個可變長度的數組，使用string類型來表示一個字元串。同時，使用了cout和endl來輸出結果。

在C++标準庫中，建立、複制和銷毀是針對容器和對象的三個重要操作。

建立（Create）：建立操作用于建立容器或對象的執行個體。在C++标準庫中，我們可以使用類模闆來建立容器，例如vector、list等。同時，也可以使用類的構造函數來建立對象。
複制（Copy）：複制操作用于将一個容器或對象的值複制到另一個容器或對象中。在C++标準庫中，提供了複制構造函數和指派運算符重載函數，用于實作容器和對象的複制。
銷毀（Destroy）：銷毀操作用于釋放容器或對象占用的資源，并将其從記憶體中删除。在C++标準庫中，提供了析構函數來實作容器和對象的銷毀。

下面是一個使用C++标準庫進行建立、複制和銷毀操作的示例：

#include <iostream>
#include <vector>

class MyClass {
public:
    MyClass() {
        std::cout << "Creating MyClass object" << std::endl;
    }
    
    MyClass(const MyClass& other) {
        std::cout << "Copying MyClass object" << std::endl;
    }
    
    ~MyClass() {
        std::cout << "Destroying MyClass object" << std::endl;
    }
};

int main() {
    std::vector<MyClass> vec;
    
    // 建立容器并添加對象
    vec.push_back(MyClass());
    
    // 複制容器
    std::vector<MyClass> vec2 = vec;
    
    // 銷毀容器
    vec.clear();
    
    return 0;
}

在上面的示例中，我們定義了一個名為MyClass的類，其中包含了構造函數、複制構造函數和析構函數。然後，我們建立了一個vector容器，并在其中添加了一個MyClass對象。接着，我們使用指派運算符将vec複制給vec2。最後，我們通過調用clear()函數銷毀了vec容器中的所有對象。

輸出結果：

Creating MyClass object
Copying MyClass object
Destroying MyClass object
Destroying MyClass object

在C++标準庫中，比較（Comparison）是用于比較容器和對象之間的大小關系的操作。

比較操作通常用于判斷兩個容器或對象是否相等、大小關系等。在C++标準庫中，比較操作符和函數被提供用于實作這些比較操作。

以下是一些常用的比較操作符和函數：

比較操作符：C++标準庫提供了一系列的比較操作符，如==、!=、<、>、<=、>=等，用于比較容器和對象之間的大小關系。例如：

std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2 = {1, 2, 3};

if (vec1 == vec2) {
    // vec1和vec2相等
}

if (vec1 < vec2) {
    // vec1小于vec2
}

比較函數：C++标準庫還提供了一些比較函數，如std::equal、std::lexicographical_compare等，用于比較容器和對象之間的大小關系。例如：

std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2 = {1, 2, 3};

if (std::equal(vec1.begin(), vec1.end(), vec2.begin())) {
    // vec1和vec2相等
}

if (std::lexicographical_compare(vec1.begin(), vec1.end(), vec2.begin(), vec2.end())) {
    // vec1小于vec2
}

通過比較操作，我們可以判斷容器和對象之間的大小關系，進而進行相應的處理。

符：

#include <iostream>
#include <string>
#include <algorithm>

int main() {
    std::string str = "Hello, World!";
    
    // 使用算法通路字元
    char c = *std::find(str.begin(), str.end(), 'W'); // 使用find算法查找字元
    std::cout << "Character found: " << c << std::endl;
    
    return 0;
}

以上示例展示了如何使用索引、疊代器和算法來通路字元串或字元序列中的單個字元。

在C++标準庫中，可以使用多種方法來生成C-String（以null結尾的字元數組）和字元數組。

使用字元串字面值生成C-String：
const char* cString = "Hello World";
使用字元數組生成C-String：
char charArray[] = {'H', 'e', 'l', 'l', 'o', '\0'}; const char* cString = charArray;
使用字元串對象生成C-String：
std::string str = "Hello World"; const char* cString = str.c_str();
使用字元數組生成字元數組：
char charArray[] = {'H', 'e', 'l', 'l', 'o'}; char charArray2[6]; std::copy(std::begin(charArray), std::end(charArray), std::begin(charArray2));

在上述示例中，我們使用了不同的方法來生成C-String和字元數組。注意在生成C-String時，我們需要確定字元串以null字元（'\0'）結尾，以便正确表示字元串的結束。

在C++标準庫中，有多種操作可以對字元串進行修改。

修改字元：
使用索引修改字元：
std::string str = "Hello World"; str[0] = 'h'; // 将第一個字元改為小寫
使用疊代器修改字元：
std::string str = "Hello World"; std::string::iterator it = str.begin(); *it = 'h'; // 将第一個字元改為小寫
插入字元：
使用insert函數在指定位置插入字元：std::string str = "Hello"; str.insert(5, " World"); // 在第5個位置插入字元串 " World"
删除字元：
使用erase函數删除指定位置的字元：
std::string str = "Hello World"; str.erase(5); // 删除第5個字元
使用erase函數删除指定範圍的字元：
std::string str = "Hello World"; str.erase(6, 5); // 删除從第6個字元開始的5個字元
替換字元：
使用replace函數替換指定位置的字元：
std::string str = "Hello World"; str.replace(0, 5, "Hi"); // 将前5個字元替換為 "Hi"
使用replace函數替換指定範圍的字元：
std::string str = "Hello World"; str.replace(6, 5, "Universe"); // 将從第6個字元開始的5個字元替換為 "Universe"

在C++标準庫中，有多種方法可以進行字元串的查找和定位。

find()函數：用于在字元串中查找指定的子字元串，并傳回第一次出現的位置。
std::string str = "Hello World"; size_t found = str.find("World"); // 傳回6，表示子字元串"World"在字元串中的位置
rfind()函數：用于在字元串中從後往前查找指定的子字元串，并傳回最後一次出現的位置。
std::string str = "Hello World"; size_t found = str.rfind("o"); // 傳回7，表示子字元串"o"最後一次出現的位置
find_first_of()函數：用于在字元串中查找任意一個指定的字元，并傳回第一次出現的位置。
std::string str = "Hello World"; size_t found = str.find_first_of("o"); // 傳回4，表示字元"o"第一次出現的位置
find_last_of()函數：用于在字元串中從後往前查找任意一個指定的字元，并傳回最後一次出現的位置。
std::string str = "Hello World"; size_t found = str.find_last_of("o"); // 傳回7，表示字元"o"最後一次出現的位置
find_first_not_of()函數：用于在字元串中查找第一個不屬于指定字元集的字元，并傳回其位置。
std::string str = "Hello World"; size_t found = str.find_first_not_of("Helo "); // 傳回5，表示第一個不屬于字元集"Helo "的字元位置
find_last_not_of()函數：用于在字元串中從後往前查找第一個不屬于指定字元集的字元，并傳回其位置。
std::string str = "Hello World"; size_t found = str.find_last_not_of("dlroW"); // 傳回8，表示最後一個不屬于字元集"dlroW"的字元位置

在C++标準庫中，有多種方法可以處理子字元串和字元串的連接配接。

子字元串：
substr()函數：用于從一個字元串中提取子字元串。std::string str = "Hello World"; std::string sub = str.substr(6, 5); // 從位置6開始提取長度為5的子字元串
字元串連接配接：
使用"+"運算符：可以将兩個字元串連接配接起來。
std::string str1 = "Hello"; std::string str2 = "World"; std::string result = str1 + " " + str2; // 連接配接兩個字元串
使用append()函數：将一個字元串追加到另一個字元串的末尾。
std::string str1 = "Hello"; std::string str2 = "World"; str1.append(" "); // 在str1的末尾追加一個空格 str1.append(str2); // 将str2追加到str1的末尾

準輸出裝置（通常是螢幕）輸出資料。
int num = 10; std::cout << "The number is: " << num << std::endl; // 輸出 "The number is: 10"
cerr：用于向标準錯誤裝置（通常是螢幕）輸出錯誤資訊。
std::cerr << "Error: Invalid input!" << std::endl; // 輸出錯誤資訊
clog：用于向标準錯誤裝置（通常是螢幕）輸出一般資訊。
std::clog << "Processing..." << std::endl; // 輸出一般資訊

這些函數可以用于處理各種輸入和輸出操作，從控制台讀取使用者輸入，向控制台輸出結果，以及處理檔案的輸入輸出等。

在C++标準庫中，有多種方法可以進行數值轉換。

字元串轉換為數值：
stoi()函數：用于将字元串轉換為整數。
std::string str = "12345"; int num = std::stoi(str); // 将字元串轉換為整數
stof()函數：用于将字元串轉換為浮點數。
std::string str = "3.14"; float num = std::stof(str); // 将字元串轉換為浮點數
數值轉換為字元串：
to_string()函數：用于将數值轉換為字元串。
int num = 12345; std::string str = std::to_string(num); // 将整數轉換為字元串
to_string()函數：用于将浮點數轉換為字元串。
float num = 3.14; std::string str = std::to_string(num); // 将浮點數轉換為字

在C++标準庫中，可以使用生成器（Generator）來生成疊代器（Iterator）。

生成器是一種可以生成序列的函數或類，而疊代器是一種用于周遊序列的對象。

C++标準庫提供了多種生成器，如下所示：

iota()函數：用于生成序列中的連續整數。
#include <iostream> #include <vector> #include <numeric> int main() { std::vector<int> numbers(10); std::iota(numbers.begin(), numbers.end(), 1); // 生成從1到10的整數序列 for (auto num : numbers) { std::cout << num << " "; } return 0; }
輸出結果：
1 2 3 4 5 6 7 8 9 10
generate()函數：用于使用自定義函數生成序列中的元素。
#include <iostream> #include <vector> #include <algorithm> int main() { std::vector<int> numbers(10); int value = 0; std::generate(numbers.begin(), numbers.end(), [&]() { return value++; }); // 生成從0到9的整數序列 for (auto num : numbers) { std::cout << num << " "; } return 0; }
輸出結果：
0 1 2 3 4 5 6 7 8 9

這些生成器可以友善地生成序列，并通過疊代器進行周遊和操作。

在C++标準庫中，Allocator是一個用于管理記憶體配置設定和釋放的模闆類。它提供了一種通用的方式來配置設定和釋放記憶體，可以與其他容器類一起使用，以控制它們的記憶體配置設定行為。

Allocator的主要作用是将記憶體配置設定和釋放的細節與容器的實作分離開來，進而提高代碼的可重用性和靈活性。

以下是Allocator的一些常見用法示例：

使用預設的Allocator配置設定記憶體：
std::vector<int> vec; vec.push_back(10); // 使用預設的Allocator配置設定記憶體
自定義Allocator：
template <typename T> class MyAllocator { public: using value_type = T; T* allocate(std::size_t n) { return static_cast<T*>(std::malloc(n * sizeof(T))); } void deallocate(T* p, std::size_t n) { std::free(p); } }; std::vector<int, MyAllocator<int>> vec; vec.push_back(10); // 使用自定義的Allocator配置設定記憶體
使用Allocator進行記憶體配置設定和釋放：
std::allocator<int> alloc; int* p = alloc.allocate(5); // 配置設定5個int類型的記憶體空間 for (int i = 0; i < 5; ++i) { alloc.construct(p + i, i); // 在配置設定的記憶體空間中構造對象 } for (int i = 0; i < 5; ++i) { std::cout << p[i] << " "; // 輸出：0 1 2 3 4 } for (int i = 0; i < 5; ++i) { alloc.destroy(p + i); // 銷毀對象 } alloc.deallocate(p, 5); // 釋放記憶體空間

C++标準庫 第十三章 字元串--上半節

C++标準庫第十三章字元串--上半節