C++?String部分成員怎么實現

C++ String部分成員怎么實現

引言

C++標準庫中的std::string類是一個非常強大的工具，用于處理字符串。它提供了豐富的成員函數和操作符，使得字符串的處理變得簡單而高效。本文將深入探討std::string類中部分成員函數的實現原理，幫助讀者更好地理解和使用這個類。

1. std::string的基本結構

在深入探討成員函數的實現之前，我們先了解一下std::string的基本結構。std::string是一個模板類，定義在<string>頭文件中。它的基本結構如下：

template<class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
class basic_string {
    // 成員變量和成員函數
};

typedef basic_string<char> string;

std::string實際上是basic_string<char>的別名。basic_string模板類有三個模板參數：

• CharT：字符類型，通常為char。
• Traits：字符特性類，通常為std::char_traits<CharT>。
• Allocator：內存分配器，通常為std::allocator<CharT>。

2. std::string的構造函數

std::string提供了多個構造函數，用于從不同的數據源創建字符串對象。以下是幾個常見的構造函數及其實現原理。

2.1 默認構造函數

默認構造函數創建一個空的字符串對象。

basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) {}

這個構造函數簡單地調用了一個接受分配器參數的構造函數，傳遞了一個默認的分配器對象。

2.2 從C風格字符串構造

這個構造函數從C風格字符串（即以\0結尾的字符數組）創建一個std::string對象。

basic_string(const CharT* s, const Allocator& alloc = Allocator())
    : basic_string(s, Traits::length(s), alloc) {}

這個構造函數調用了另一個構造函數，傳遞了C風格字符串、字符串長度和分配器對象。Traits::length(s)用于計算C風格字符串的長度。

2.3 從字符數組構造

這個構造函數從字符數組創建一個std::string對象。

basic_string(const CharT* s, size_type count, const Allocator& alloc = Allocator())
    : alloc_(alloc) {
    data_ = alloc_.allocate(count + 1);
    Traits::copy(data_, s, count);
    data_[count] = CharT();
    size_ = count;
    capacity_ = count;
}

這個構造函數首先分配足夠的內存來存儲字符數組和終止符\0，然后使用Traits::copy將字符數組復制到分配的內存中，最后設置字符串的大小和容量。

3. std::string的析構函數

std::string的析構函數負責釋放字符串對象占用的內存。

~basic_string() {
    if (data_) {
        alloc_.deallocate(data_, capacity_ + 1);
    }
}

析構函數首先檢查data_指針是否為空，如果不為空，則調用分配器的deallocate函數釋放內存。

4. std::string的賦值操作符

std::string提供了多個賦值操作符，用于從不同的數據源賦值給字符串對象。

4.1 從C風格字符串賦值

這個賦值操作符從C風格字符串賦值給std::string對象。

basic_string& operator=(const CharT* s) {
    return assign(s, Traits::length(s));
}

這個操作符調用了assign函數，傳遞了C風格字符串和字符串長度。

4.2 從字符數組賦值

這個賦值操作符從字符數組賦值給std::string對象。

basic_string& operator=(const CharT* s, size_type count) {
    return assign(s, count);
}

這個操作符調用了assign函數，傳遞了字符數組和字符數量。

5. std::string的assign函數

assign函數用于將字符串對象的內容替換為指定的內容。以下是幾個常見的assign函數及其實現原理。

5.1 從C風格字符串賦值

basic_string& assign(const CharT* s, size_type count) {
    if (count > capacity_) {
        reserve(count);
    }
    Traits::copy(data_, s, count);
    data_[count] = CharT();
    size_ = count;
    return *this;
}

這個assign函數首先檢查是否需要重新分配內存，然后使用Traits::copy將字符數組復制到字符串對象的內存中，最后設置字符串的大小。

5.2 從字符數組賦值

basic_string& assign(const CharT* s, size_type count) {
    if (count > capacity_) {
        reserve(count);
    }
    Traits::copy(data_, s, count);
    data_[count] = CharT();
    size_ = count;
    return *this;
}

這個assign函數的實現與上一個類似，只是參數類型不同。

6. std::string的append函數

append函數用于在字符串的末尾追加內容。以下是幾個常見的append函數及其實現原理。

6.1 追加C風格字符串

basic_string& append(const CharT* s, size_type count) {
    if (size_ + count > capacity_) {
        reserve(size_ + count);
    }
    Traits::copy(data_ + size_, s, count);
    size_ += count;
    data_[size_] = CharT();
    return *this;
}

這個append函數首先檢查是否需要重新分配內存，然后使用Traits::copy將字符數組復制到字符串對象的末尾，最后更新字符串的大小。

6.2 追加字符數組

basic_string& append(const CharT* s, size_type count) {
    if (size_ + count > capacity_) {
        reserve(size_ + count);
    }
    Traits::copy(data_ + size_, s, count);
    size_ += count;
    data_[size_] = CharT();
    return *this;
}

這個append函數的實現與上一個類似，只是參數類型不同。

7. std::string的reserve函數

reserve函數用于預留足夠的內存以存儲指定數量的字符。

void reserve(size_type new_cap) {
    if (new_cap > capacity_) {
        CharT* new_data = alloc_.allocate(new_cap + 1);
        Traits::copy(new_data, data_, size_);
        new_data[size_] = CharT();
        if (data_) {
            alloc_.deallocate(data_, capacity_ + 1);
        }
        data_ = new_data;
        capacity_ = new_cap;
    }
}

這個reserve函數首先檢查是否需要重新分配內存，然后分配新的內存，復制原有數據到新內存中，最后釋放舊內存并更新容量。

8. std::string的resize函數

resize函數用于調整字符串的大小。

void resize(size_type count, CharT ch = CharT()) {
    if (count > size_) {
        if (count > capacity_) {
            reserve(count);
        }
        Traits::assign(data_ + size_, count - size_, ch);
        size_ = count;
        data_[size_] = CharT();
    } else if (count < size_) {
        size_ = count;
        data_[size_] = CharT();
    }
}

這個resize函數首先檢查是否需要擴展或縮小字符串，然后根據需要分配內存或截斷字符串，最后更新字符串的大小。

9. std::string的clear函數

clear函數用于清空字符串的內容。

void clear() noexcept {
    size_ = 0;
    data_[0] = CharT();
}

這個clear函數簡單地將字符串的大小設置為0，并在字符串的開頭放置一個終止符\0。

10. std::string的empty函數

empty函數用于檢查字符串是否為空。

bool empty() const noexcept {
    return size_ == 0;
}

這個empty函數簡單地檢查字符串的大小是否為0。

11. std::string的size和length函數

size和length函數用于獲取字符串的大小。

size_type size() const noexcept {
    return size_;
}

size_type length() const noexcept {
    return size_;
}

這兩個函數都返回字符串的大小。

12. std::string的capacity函數

capacity函數用于獲取字符串的容量。

size_type capacity() const noexcept {
    return capacity_;
}

這個函數返回字符串的容量。

13. std::string的c_str函數

c_str函數用于獲取字符串的C風格表示。

const CharT* c_str() const noexcept {
    return data_;
}

這個函數返回字符串的內部字符數組指針。

14. std::string的data函數

data函數用于獲取字符串的字符數組指針。

const CharT* data() const noexcept {
    return data_;
}

這個函數返回字符串的內部字符數組指針。

15. std::string的operator[]函數

operator[]函數用于訪問字符串中的字符。

CharT& operator[](size_type pos) {
    return data_[pos];
}

const CharT& operator[](size_type pos) const {
    return data_[pos];
}

這個函數返回字符串中指定位置的字符引用。

16. std::string的at函數

at函數用于訪問字符串中的字符，并進行邊界檢查。

CharT& at(size_type pos) {
    if (pos >= size_) {
        throw std::out_of_range("std::string::at");
    }
    return data_[pos];
}

const CharT& at(size_type pos) const {
    if (pos >= size_) {
        throw std::out_of_range("std::string::at");
    }
    return data_[pos];
}

這個函數在訪問字符之前檢查位置是否越界，如果越界則拋出std::out_of_range異常。

17. std::string的front和back函數

front和back函數用于訪問字符串的第一個和最后一個字符。

CharT& front() {
    return data_[0];
}

const CharT& front() const {
    return data_[0];
}

CharT& back() {
    return data_[size_ - 1];
}

const CharT& back() const {
    return data_[size_ - 1];
}

這兩個函數分別返回字符串的第一個和最后一個字符的引用。

18. std::string的push_back函數

push_back函數用于在字符串的末尾追加一個字符。

void push_back(CharT ch) {
    if (size_ == capacity_) {
        reserve(capacity_ * 2);
    }
    data_[size_] = ch;
    size_++;
    data_[size_] = CharT();
}

這個函數首先檢查是否需要重新分配內存，然后在字符串的末尾追加字符，并更新字符串的大小。

19. std::string的pop_back函數

pop_back函數用于刪除字符串的最后一個字符。

void pop_back() {
    if (size_ > 0) {
        size_--;
        data_[size_] = CharT();
    }
}

這個函數首先檢查字符串是否為空，然后刪除最后一個字符，并更新字符串的大小。

20. std::string的insert函數

insert函數用于在字符串的指定位置插入內容。以下是幾個常見的insert函數及其實現原理。

20.1 在指定位置插入字符

basic_string& insert(size_type index, size_type count, CharT ch) {
    if (index > size_) {
        throw std::out_of_range("std::string::insert");
    }
    if (size_ + count > capacity_) {
        reserve(size_ + count);
    }
    Traits::move(data_ + index + count, data_ + index, size_ - index);
    Traits::assign(data_ + index, count, ch);
    size_ += count;
    data_[size_] = CharT();
    return *this;
}

這個insert函數首先檢查插入位置是否越界，然后檢查是否需要重新分配內存，接著移動插入位置后的字符，最后插入指定數量的字符，并更新字符串的大小。

20.2 在指定位置插入C風格字符串

basic_string& insert(size_type index, const CharT* s, size_type count) {
    if (index > size_) {
        throw std::out_of_range("std::string::insert");
    }
    if (size_ + count > capacity_) {
        reserve(size_ + count);
    }
    Traits::move(data_ + index + count, data_ + index, size_ - index);
    Traits::copy(data_ + index, s, count);
    size_ += count;
    data_[size_] = CharT();
    return *this;
}

這個insert函數的實現與上一個類似，只是插入的內容是C風格字符串。

21. std::string的erase函數

erase函數用于刪除字符串中的部分內容。以下是幾個常見的erase函數及其實現原理。

21.1 刪除指定位置的字符

basic_string& erase(size_type index = 0, size_type count = npos) {
    if (index > size_) {
        throw std::out_of_range("std::string::erase");
    }
    if (count == npos || index + count > size_) {
        count = size_ - index;
    }
    Traits::move(data_ + index, data_ + index + count, size_ - index - count);
    size_ -= count;
    data_[size_] = CharT();
    return *this;
}

這個erase函數首先檢查刪除位置是否越界，然后計算實際刪除的字符數量，接著移動刪除位置后的字符，最后更新字符串的大小。

21.2 刪除指定位置的字符

iterator erase(const_iterator position) {
    size_type index = position - begin();
    erase(index, 1);
    return begin() + index;
}

這個erase函數首先計算刪除位置的索引，然后調用上一個erase函數刪除指定位置的字符，最后返回刪除后的迭代器。

22. std::string的replace函數

replace函數用于替換字符串中的部分內容。以下是幾個常見的replace函數及其實現原理。

22.1 替換指定位置的字符

basic_string& replace(size_type pos, size_type count, const CharT* s, size_type count2) {
    if (pos > size_) {
        throw std::out_of_range("std::string::replace");
    }
    if (count == npos || pos + count > size_) {
        count = size_ - pos;
    }
    size_type new_size = size_ - count + count2;
    if (new_size > capacity_) {
        reserve(new_size);
    }
    Traits::move(data_ + pos + count2, data_ + pos + count, size_ - pos - count);
    Traits::copy(data_ + pos, s, count2);
    size_ = new_size;
    data_[size_] = CharT();
    return *this;
}

這個replace函數首先檢查替換位置是否越界，然后計算實際替換的字符數量，接著移動替換位置后的字符，最后復制新的內容到替換位置，并更新字符串的大小。

22.2 替換指定位置的字符

basic_string& replace(size_type pos, size_type count, const CharT* s) {
    return replace(pos, count, s, Traits::length(s));
}

這個replace函數調用了上一個replace函數，傳遞了C風格字符串和字符串長度。

23. std::string的substr函數

substr函數用于獲取字符串的子串。

basic_string substr(size_type pos = 0, size_type count = npos) const {
    if (pos > size_) {
        throw std::out_of_range("std::string::substr");
    }
    if (count == npos || pos + count > size_) {
        count = size_ - pos;
    }
    return basic_string(data_ + pos, count);
}

這個substr函數首先檢查子串的起始位置是否越界，然后計算子串的長度，最后創建一個新的std::string對象并返回。

24. std::string的find函數

find函數用于在字符串中查找子串或字符。以下是幾個常見的find函數及其實現原理。

24.1 查找子串

size_type find(const CharT* s, size_type pos = 0) const {
    return find(s, pos, Traits::length(s));
}

size_type find(const CharT* s, size_type pos, size_type count) const {
    if (pos > size_) {
        return npos;
    }
    if (count == 0) {
        return pos;
    }
    for (size_type i = pos; i <= size_ - count; ++i) {
        if (Traits::compare(data_ + i, s, count) == 0) {
            return i;
        }
    }
    return npos;
}

這個find函數首先檢查查找位置是否越界，然后遍歷字符串，使用Traits::compare比較子串，如果找到匹配的子串則返回其位置，否則返回npos。

24.2 查找字符

size_type find(CharT ch, size_type pos = 0) const {
    if (pos > size_) {
        return npos;
    }
    for (size_type i = pos; i < size_; ++i) {
        if (Traits::eq(data_[i], ch)) {
            return i;
        }
    }
    return npos;
}

這個find函數首先檢查查找位置是否越界，然后遍歷字符串，使用Traits::eq比較字符，如果找到匹配的字符則返回其位置，否則返回npos。

25. std::string的rfind函數

rfind函數用于在字符串中從后向前查找子串或字符。以下是幾個常見的