基于char* 设计一个字符串类MyString，具有构造函数、析构函数、复制构造函数。具体如下： MyString(); MyString(const char* cString); char at(int index) const; int length() const; void clear(); bool empty() const; int compare(const MyString& s) const; int compare(int index, int n, const MyString& s) const; void copy(char s[], int index , int n); char* data() const; int find(char ch) const ; int find(char ch ,int index) const; int find(const MyString& s, int index) const; 另外，还有append、assign、substr、 erase函数，详见11.14和11.15要求。

好的，我会为你解答这个问题。

以下是 MyString 类的设计：

class MyString {
public:
    // 构造函数
    MyString();
    MyString(const char* cString);
    // 复制构造函数
    MyString(const MyString& other);
    // 析构函数
    ~MyString();

    // 获取指定位置的字符
    char at(int index) const;
    // 获取字符串的长度
    int length() const;
    // 清空字符串
    void clear();
    // 判断字符串是否为空
    bool empty() const;
    // 比较两个字符串
    int compare(const MyString& s) const;
    int compare(int index, int n, const MyString& s) const;
    // 复制子串到另一个字符数组
    void copy(char s[], int index , int n);
    // 获取字符串的字符数组
    char* data() const;
    // 在字符串中查找指定字符或子串
    int find(char ch) const;
    int find(char ch, int index) const;
    int find(const MyString& s, int index) const;

    // 在字符串末尾添加指定字符或字符串
    MyString& append(const MyString& s);
    MyString& append(const char* cString);
    MyString& append(const char* cString, int n);
    // 将指定字符串赋值给当前字符串
    MyString& assign(const MyString& s);
    MyString& assign(const char* cString);
    MyString& assign(const char* cString, int n);
    // 获取子串
    MyString substr(int index, int n) const;
    // 删除指定位置开始的 n 个字符
    MyString& erase(int index, int n);

private:
    char* m_data;
    int m_length;
};

下面是 MyString 类的实现：

#include <cstring>
#include <algorithm>

class MyString {
public:
    MyString() {
        m_data = new char[1];
        *m_data = '\0';
        m_length = 0;
    }

    MyString(const char* cString) {
        m_length = strlen(cString);
        m_data = new char[m_length + 1];
        strcpy(m_data, cString);
    }

    MyString(const MyString& other) {
        m_length = other.m_length;
        m_data = new char[m_length + 1];
        strcpy(m_data, other.m_data);
    }

    ~MyString() {
        delete[] m_data;
    }

    char at(int index) const {
        return index < 0 || index >= m_length ? '\0' : m_data[index];
    }

    int length() const {
        return m_length;
    }

    void clear() {
        MyString().swap(*this);
    }

    bool empty() const {
        return m_length == 0;
    }

    int compare(const MyString& s) const {
        return strcmp(m_data, s.m_data);
    }

    int compare(int index, int n, const MyString& s) const {
        if (index < 0 || index >= m_length) {
            return -1;
        }
        int count = std::min(n, m_length - index);
        return strncmp(m_data + index, s.m_data, count);
    }

    void copy(char s[], int index, int n) {
        if (index < 0 || index >= m_length) {
            return;
        }
        int count = std::min(n, m_length - index);
        strncpy(s, m_data + index, count);
        s[count] = '\0';
    }

    char* data() const {
        return m_data;
    }

    int find(char ch) const {
        char* p = strchr(m_data, ch);
        return p ? p - m_data : -1;
    }

    int find(char ch, int index) const {
        if (index < 0 || index >= m_length) {
            return -1;
        }
        char* p = strchr(m_data + index, ch);
        return p ? p - m_data : -1;
    }

    int find(const MyString& s, int index) const {
        if (index < 0 || index >= m_length) {
            return -1;
        }
        char* p = strstr(m_data + index, s.m_data);
        return p ? p - m_data : -1;
    }

    MyString& append(const MyString& s) {
        int newLength = m_length + s.m_length;
        char* newData = new char[newLength + 1];
        strcpy(newData, m_data);
        strcpy(newData + m_length, s.m_data);
        delete[] m_data;
        m_data = newData;
        m_length = newLength;
        return *this;
    }

    MyString& append(const char* cString) {
        return append(MyString(cString));
    }

    MyString& append(const char* cString, int n) {
        return append(MyString(cString, n));
    }

    MyString& assign(const MyString& s) {
        if (this != &s) {
            MyString(s).swap(*this);
        }
        return *this;
    }

    MyString& assign(const char* cString) {
        return assign(MyString(cString));
    }

    MyString& assign(const char* cString, int n) {
        return assign(MyString(cString, n));
    }

    MyString substr(int index, int n) const {
        if (index < 0 || index >= m_length) {
            return MyString();
        }
        int count = std::min(n, m_length - index);
        return MyString(m_data + index, count);
    }

    MyString& erase(int index, int n) {
        if (index < 0 || index >= m_length) {
            return *this;
        }
        int count = std::min(n, m_length - index);
        memmove(m_data + index, m_data + index + count, m_length - index - count + 1);
        m_length -= count;
        return *this;
    }

private:
    char* m_data;
    int m_length;

    MyString(const char* cString, int n) {
        m_length = n;
        m_data = new char[m_length + 1];
        strncpy(m_data, cString, m_length);
        m_data[m_length] = '\0';
    }

    void swap(MyString& other) {
        std::swap(m_data, other.m_data);
        std::swap(m_length, other.m_length);
    }
};

这样，我们就实现了一个基于 char* 的字符串类 MyString，其中包含了构造函数、析构函数、复制构造函数以及各种字符串操作函数，可以方便地对字符串进行操作。