namespace zzh {
class string {
private:
    char* _str;        // 存儲(chǔ)字符串的字符數(shù)組
    size_t _size;      // 當(dāng)前字符串長(zhǎng)度
    size_t _capacity;  // 已分配的容量
public:
    static const size_t npos;  // 表示"不存在的位置"
    // 各類成員函數(shù)...
};
}

// 1. 從C風(fēng)格字符串構(gòu)造
string::string(const char* str)
{
    _size = strlen(str);
    _str = new char[_size + 1];
    _capacity = _size;
    memcpy(_str, str, _size + 1);
}

// 2. 拷貝構(gòu)造函數(shù)
string::string(const string& s)
{
    _size = s._size;
    _capacity = s._capacity;
    _str = new char[_capacity + 1];
    memcpy(_str, s._str, _size + 1);
}

// 3. 析構(gòu)函數(shù)
string::~string()
{
    delete[] _str;
    _str = nullptr;
    _size = 0;
    _capacity = 0;
}

string& string::operator=(const string& s)
{
    if (this != &s)
    {
        char* tmp = new char[s._capacity + 1];
        memcpy(tmp, s._str, s._size + 1);
        delete[] _str;  // 注意：原代碼此處順序有誤，已修正
        _str = tmp;
        _size = s._size;
        _capacity = s._capacity;
    }
    return *this;
}

string::iterator string::begin() { return _str; }
string::iterator string::end() { return _str + _size; }

// 預(yù)分配內(nèi)存
void string::reserve(size_t n)
{
    if (n > _capacity)
    {
        char* tmp = new char[n + 1];
        memcpy(tmp, _str, _size + 1);
        delete[] _str;
        _str = tmp;
        _capacity = n;
    }
}

// 追加字符
void string::push_back(char c)
{
    if (_size >= _capacity)
    {
        size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
        reserve(newcapacity);
    }
    _str[_size++] = c;  // 注意：原代碼此處錯(cuò)誤地寫入了固定字符'c'
    _str[_size] = '\0';
}

// 追加C風(fēng)格字符串
void string::append(const char* str)
{
    size_t len = strlen(str);
    if (_size + len > _capacity)
    {
        size_t newcapacity = 2 * _capacity > _size + len ? 2 * _capacity : _size + len;
        reserve(newcapacity);
    }
    memcpy(_str + _size, str, len);  // 注意：原代碼此處多復(fù)制了一個(gè)終止符
    _size += len;
    _str[_size] = '\0';  // 手動(dòng)添加終止符
}

// 查找字符
size_t string::find(char c, size_t pos = 0) const
{
    for (size_t i = pos; i < _size; i++)
    {
        if (_str[i] == c)
            return i;
    }
    return npos;
}

// 插入字符
string& string::insert(size_t pos, char c)
{
    assert(pos <= _size);
    if (_size >= _capacity)
    {
        size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
        reserve(newcapacity);
    }
    // 從后向前移動(dòng)元素
    for (size_t i = _size; i > pos; i--)
        _str[i] = _str[i - 1];
    _str[pos] = c;
    _size++;
    return *this;
}

// 比較運(yùn)算符
bool string::operator<(const string& s)
{
    size_t i1 = 0, i2 = 0;
    while (i1 < _size && i2 < s._size)
    {
        if (_str[i1] < s._str[i2])
            return true;
        else if (_str[i1] > s._str[i2])
            return false;
        i1++; i2++;
    }
    return i1 < s._size;  // 注意：原代碼此處邏輯有誤，已修正
}

// 索引運(yùn)算符
char& string::operator[](size_t index)
{
    assert(index < _size);
    return _str[index];
}