string类的部分功能实现（stl)

#pragma once
#include
#include

namespace Gan_string1
{
class string
{
typedef char* iterator; // 定义迭代器类型

public:
    // 构造函数，可以接受一个 C 风格字符串作为参数，默认为空字符串
    string(const char* str = "")
    {
        _size = strlen(str);
        _capacity = _size;
        _str = new char[_capacity + 1];
        strcpy_s(_str, _size + 1, str);
    }

    // 拷贝构造函数，使用传入的 string 对象进行初始化
    string(const string& s)
        : _str(nullptr),
        _size(0),
        _capacity(0)
    {
        string tmp(s._str);
        this->swap(tmp);
    }

    // 拷贝赋值运算符重载，利用传入的临时对象进行交换
    string& operator=(string s)
    {
        this->swap(s);
        return *this;
    }

    // 析构函数，释放动态分配的内存
    ~string()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }

    // 返回字符串的起始迭代器
    iterator begin()
    {
        return _str;
    }

    // 返回字符串的结束迭代器
    iterator end()
    {
        return _str + _size;
    }

    // 返回字符串的大小
    size_t size() const
    {
        return _size;
    }

    // 返回字符串的容量
    size_t capacity() const
    {
        return _capacity;
    }

    // 保证字符串的容量至少为指定的值
    void Reserve(size_t capacity)
    {
        if (capacity > _capacity)
        {
            char* str = new char[capacity + 1];
            strcpy_s(str, strlen(_str) + 1, _str);
            delete[] _str;
            _str = str;
            _capacity = capacity;
        }
    }

    // 在字符串末尾添加一个字符
    void push_back(char ch)
    {
        if (_size == _capacity)
        {
            Reserve(_capacity * 2);
        }
        _str[_size++] = ch;
        _str[_size] = '\0';
    }

    // 在字符串末尾添加一个 C 风格字符串
    void append(const char* str)
    {
        size_t len = strlen(str);
        if (_size + len >= _capacity)
        {
            Reserve(_size + len);
        }
        for (size_t i = _size; i < _size + len; ++i)
        {
            _str[i] = str[i - _size];
        }
        _size += len;
        _str[_size] = '\0';
    }

    // 在指定位置插入一个字符
    string& insert(size_t pos, char c)
    {
        assert(pos >= 0 && pos <= _size);
        if (_size == _capacity)
        {
            Reserve(_capacity * 2);
        }
        for (int i = _size; i > pos; --i)
        {
            _str[i] = _str[i - 1];
        }
        _str[pos] = c;
        ++_size;
        _str[_size] = '\0';
        return *this;
    }

    // 在指定位置插入一个 C 风格字符串
    string& insert(size_t pos, const char* str)
    {
        size_t len = strlen(str);
        if (_size + len >= _capacity)
        {
            Reserve(_size + len);
        }
        for (int i = _size; i >= (int)pos; --i)
        {
            _str[i + len] = _str[i];
        }
        for (size_t i = 0; i < len; ++i)
        {
            _str[pos + i] = str[i];
        }
        _size += len;
        return *this;
    }

    // 从字符串中删除指定位置开始指定长度的字符
    string& erase(size_t pos, size_t len = 0)
    {
        size_t count = std::min(len, _size - pos);
        for (size_t i = pos; i < _size - count; ++i)
        {
            _str[i] = _str[i + count];
        }
        _size -= count;
        _str[_size] = '\0';
        return *this;
    }

    // 调整字符串的大小为 n，并用字符 ch 填充剩余部分
    void resize(size_t n, char ch = '\0')
    {
        if (n > _size)
        {
            if (n > _capacity)
            {
                Reserve(n);
            }
            memset(_str + _size, ch, n - _size);
        }
        _size = n;
        _str[n] = '\0';
    }

    // 清空字符串
    void clear()
    {
        _size = 0;
        _str[_size] = '\0';
    }

    // 返回字符串的 C 风格字符数组
    const char* c_str() const
    {
        return _str;
    }

    // 判断字符串是否为空
    bool empty() const
    {
        return _size == 0;
    }

    // 重载 += 运算符，将字符追加到字符串末尾
    string& operator+=(char ch)
    {
        push_back(ch);
        return *this;
    }

    // 重载 += 运算符，将 C 风格字符串追加到字符串末尾
    string& operator+=(const char* str)
    {
        append(str);
        return *this;
    }

    // 重载 + 运算符，将字符追加到字符串末尾
    string& operator+(char ch)
    {
        push_back(ch);
        return *this;
    }

    // 重载 [] 运算符，返回指定位置的字符（常量版本）
    const char& operator[](size_t i) const
    {
        assert(i >= 0 && i < _size);
        return _str[i];
    }

    // 重载 [] 运算符，返回指定位置的字符（非常量版本）
    char& operator[](size_t i)
    {
        assert(i >= 0 && i < _size);
        return _str[i];
    }

    // 重载 < 运算符，按字典序比较字符串大小
    bool operator<(const string& s) const
    {
        if (_size < s._size)
        {
            return true;
        }
        else if (_size > s._size)
        {
            return false;
        }
        else
        {
            for (size_t i = 0; i < _size; ++i)
            {
                if (_str[i] < s._str[i])
                {
                    return true;
                }
                else if (_str[i] > s._str[i])
                {
                    return false;
                }
            }
            return false;
        }
    }

    // 重载 == 运算符，判断两个字符串是否相等
    bool operator==(const string& s) const
    {
        if (_size != s._size)
        {
            return false;
        }
        for (size_t i = 0; i < _size; ++i)
        {
            if (_str[i] != s._str[i])
            {
                return false;
            }
        }
        return true;
    }

    // 重载 > 运算符，判断当前字符串是否大于另一个字符串
    bool operator>(const string& s) const
    {
        return (s < *this && !(*this == s));
    }

    // 重载 <= 运算符，判断当前字符串是否小于等于另一个字符串
    bool operator<=(const string& s) const
    {
        return !(*this > s);
    }

    // 重载 >= 运算符，判断当前字符串是否大于等于另一个字符串
    bool operator>=(const string& s) const
    {
        return !(*this < s);
    }

    // 重载 != 运算符，判断两个字符串是否不相等
    bool operator!=(const string& s) const
    {
        return !(*this == s);
    }

    // 友元函数，重载输出流运算符，用于输出字符串
    friend std::ostream& operator<<(std::ostream& out, const string& s);

    // 友元函数，重载输入流运算符，用于从输入流读取字符串
    friend std::istream& operator>>(std::istream& in, string& s);

private:
    char* _str; // 字符串的动态内存空间
    size_t _size; // 字符串的长度
    size_t _capacity; // 字符串的容量
};

// 重载输出流运算符，用于输出字符串
std::ostream& operator<<(std::ostream& out, const string& s)
{
    for (size_t i = 0; i < s._size; ++i)
    {
        out << s[i];
    }
    return out;
}

// 重载输入流运算符，用于从输入流读取字符串
std::istream& operator>>(std::istream& in, string& s)
{
    char buffer[1024];
    in.getline(buffer, sizeof(buffer));
    delete[] s._str;
    s._str = new char[strlen(buffer) + 1];
    strcpy_s(s._str, strlen(buffer) + 1, buffer);
    s._size = strlen(s._str);
    s._capacity = s._size;
    return in;
}

// 测试函数，用于测试字符串类的各种功能
void test01()
{
    string s1("wori");
    cout << s1 << endl;

    s1.append("shabiwanyi");
    cout << s1 << endl;

    s1.resize(50, 'w');
    s1 += "wocao";
    cout << s1 << endl;

    s1.clear();
    cout << s1 << endl;

    string s2("aocao");
    string s3("bacao");
    cout << s2.find('c') << endl;
    cout << s2.find("ao") << endl;
    cout << (s2 > s3) << endl;

    string s4("wirl");
    s4.erase(1, 3);
    s4.insert(1, 'c');
    cout << s4 << endl;
}

}