模拟实现string类

在 C++ 中，标准库提供了 std::string 类来处理字符串操作，但是我们也可以自己实现一个简单的字符串类，这样可以更好地理解字符串的内部工作原理和实现细节。在本文中，我们将深入探讨自定义的 String 类，并逐个讲解每一个接口的细节。

自定义 String 类概述

首先，让我们看一下自定义的 String 类的基本结构：

#include <iostream>
#include <cstring>

class String {
private:
    char* buffer;   // 字符串缓冲区指针
    size_t length;  // 字符串长度
    size_t capacity; // 缓冲区容量

public:
    // 构造函数
    String() : buffer(nullptr), length(0), capacity(0) {}

    // 带参构造函数
    String(const char* str);

    // 拷贝构造函数
    String(const String& other);

    // 析构函数
    ~String();

    // 存取字符
    char& operator[](size_t pos);
    const char& operator[](size_t pos) const;

    // 获取迭代器
    char* begin();
    char* end();
    const char* begin() const;
    const char* end() const;

    // 获取字符串长度和容量
    size_t size() const;
    size_t capacity() const;

    // 修改字符串长度
    void resize(size_t n);
    // 分配内存，可能不改变长度
    void reserve(size_t n);
    // 清除字符串内容
    void clear();

    // 添加字符串
    String& append(const String& str);
    String& append(const char* s);

    // 在指定位置插入字符串
    String& insert(size_t pos, const String& str);

    // 从指定位置删除指定长度的字符
    String& erase(size_t pos, size_t len);

    // 查找指定子字符串的位置
    size_t find(const String& str, size_t pos = 0) const;
    size_t find(const char* s, size_t pos = 0) const;

    // 比较字符串
    int compare(const String& str) const;
};

现在让我们逐个讲解每一个接口的细节。

构造函数

    String() : buffer(nullptr), length(0), capacity(0) {}

    String(const char* str) {
        length = strlen(str);
        capacity = length + 1;//尾部有\n
        buffer = new char[capacity];
        strcpy(buffer, str);
    }

这个构造函数接受一个 C 风格的字符串作为参数，它计算字符串的长度，并为字符串分配内存。注意，我们在字符串的末尾多分配了一个字符的空间，用于存储字符串的结束符 '\0'。

拷贝构造函数

    // 拷贝构造函数
    String(const String& other) {
        length = other.length;
        capacity = other.capacity;
        buffer = new char[capacity];
        strcpy(buffer, other.buffer);
    }

这个拷贝构造函数用于创建一个新的字符串对象，其内容和另一个字符串对象完全相同。

析构函数

    // 析构函数
    ~String() {
        delete[] buffer;
    }

析构函数用于释放字符串对象占用的内存。在这里，我们使用 delete[] 释放 buffer 指针指向的内存块。

存取字符

// 存取字符
char& operator[](size_t pos) {
    return buffer[pos];
}

const char& operator[](size_t pos) const {
    return buffer[pos];
}
char& at(size_t pos) {
    if (pos >= length) {
        throw std::out_of_range("Index out of range");
    }
    return buffer[pos]; }
const char& at(size_t pos) const {
    if (pos >= length) {
    throw std::out_of_range("Index out of range");
    }
    return buffer[pos];
}

这两个操作符重载函数用于存取字符串中指定位置的字符。第一个版本用于非常量对象，允许修改字符串中的字符；第二个版本用于常量对象，不允许修改字符串中的字符。

迭代器

// 迭代器
char* begin() {
    return buffer;
}

char* end() {
    return buffer + length;
}

const char* begin() const {
    return buffer;
}

const char* end() const {
    return buffer + length;
}

这四个函数用于获取字符串的起始位置和结束位置的迭代器。非常量版本用于修改字符串中的内容，而常量版本用于遍历字符串中的内容。

获取长度和容量

// 容量
size_t size() const {
    return length;
}

size_t capacity() const {
    return capacity;
}

size 函数返回字符串的长度，即存储的字符数量，而 capacity 函数返回字符串的容量，即当前分配的内存大小。

修改长度和分配内存

//改变长度
void resize(size_t n) {
    if (n < length) {
        buffer[n] = '\0';
        length = n;
    }
    else if (n > length) {
        reserve(n);
        for (size_t i = length; i < n; ++i) {
            buffer[i] = '\0';
        }
        length = n;
    }
}
//分配新内存
void reserve(size_t n) {
    if (n > capacity) {
        char* temp = new char[n];
        strcpy(temp, buffer);
        delete[] buffer;
        buffer = temp;
        capacity = n;
    }
}

resize 函数用于修改字符串的长度，可以使字符串变长或变短，但不改变分配的内存大小。reserve 函数用于请求至少能容纳 n 个字符的内存空间，但不改变字符串的长度。

清除字符串内容

//清除
void clear() {
    length = 0;
    buffer[0] = '\0';
}

clear 函数用于清除字符串中的所有字符，将字符串长度设为 0。

添加字符串

    String& append(const String& str) {
        reserve(length + str.length);
        strcat(buffer, str.buffer);
        length += str.length;
        return *this;
    }

    String& append(const char* s) {
        size_t len = strlen(s);
        reserve(length + len);
        strcat(buffer, s);
        length += len;
        return *this;
    }

这两个函数用于将另一个字符串或者 C 风格字符串添加到当前字符串的末尾。

插入和删除字符串

String& insert(size_t pos, const String& str) {
    if (pos > length) {
        throw std::out_of_range("Index out of range");
    }
    reserve(length + str.length);
    //将从位置 pos 开始到字符串末尾的内容向右移动 str.length 个位置，
    // 为插入字符串 str 腾出空间
    memmove(buffer + pos + str.length, buffer + pos, length - pos + 1);
    memcpy(buffer + pos, str.buffer, str.length);
    length += str.length;
    return *this;
}
String& erase(size_t pos, size_t len) {
    if (pos >= length) {
        return *this;
    }
    size_t numToErase = std::min(len, length - pos);
    memmove(buffer + pos, buffer + pos + numToErase, length - pos - numToErase + 1);
    length -= numToErase;
    return *this;
}

insert 函数用于在指定位置插入另一个字符串，erase 函数用于从指定位置开始删除指定长度的字符。

查找子字符串

size_t find(const String& str, size_t pos = 0) const {
    if (pos > length) {
        return std::string::npos;
    }
    const char* result = strstr(buffer + pos, str.buffer);
    if (result == nullptr) {
        return std::string::npos;
    }
    return result - buffer;
}

size_t find(const char* s, size_t pos = 0) const {
    if (pos > length) {
        return std::string::npos;
    }
    const char* result = strstr(buffer + pos, s);
    if (result == nullptr) {
        return std::string::npos;
    }
    return result - buffer;
}

这两个函数用于在字符串中查找指定的子字符串，返回子字符串第一次出现的位置。

比较字符串

    int compare(const String& str) const {
        return strcmp(buffer, str.buffer);
    }

compare 函数用于比较两个字符串的内容，返回一个整数值，表示两个字符串的大小关系。

结语

通过深入理解自定义的 String 类，我们更加清晰地了解了字符串的内部工作原理和实现细节，这有助于我们更好地理解和使用标准库提供的 std::string 类，并且能够更加灵活地处理字符串操作。