基于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要求。

好的，我会根据你的要求回答这个问题。以下是一个基于char* 设计的字符串类MyString的实现，具有构造函数、析构函数、复制构造函数和其他相关函数：

#include <cstring>

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;
    void append(const MyString& s);
    void append(const char* s);
    void assign(const MyString& s);
    void assign(const char* s);
    MyString substr(int index, int n) const;
    void erase(int index, int n);

private:
    char* m_data;
    int m_length;

    // 私有函数
    void init(const char* cString);
};

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

MyString::MyString(const char* cString) {
    init(cString);
}

MyString::MyString(const MyString& other) {
    init(other.m_data);
}

MyString::~MyString() {
    delete[] m_data;
}

char MyString::at(int index) const {
    if (index >= 0 && index < m_length) {
        return m_data[index];
    } else {
        return '\0';
    }
}

int MyString::length() const {
    return m_length;
}

void MyString::clear() {
    m_data[0] = '\0';
    m_length = 0;
}

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

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

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

void MyString::copy(char s[], int index, int n) {
    if (index >= 0 && index < m_length) {
        strncpy(s, m_data + index, n);
        s[n] = '\0';
    } else {
        s[0] = '\0';
    }
}

char* MyString::data() const {
    return m_data;
}

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

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

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

void MyString::append(const MyString& s) {
    char* newData = new char[m_length + s.m_length + 1];
    strcpy(newData, m_data);
    strcat(newData, s.m_data);
    delete[] m_data;
    m_data = newData;
    m_length += s.m_length;
}

void MyString::append(const char* s) {
    MyString str(s);
    append(str);
}

void MyString::assign(const MyString& s) {
    if (this != &s) {
        delete[] m_data;
        init(s.m_data);
    }
}

void MyString::assign(const char* s) {
    MyString str(s);
    assign(str);
}

MyString MyString::substr(int index, int n) const {
    if (index >= 0 && index < m_length) {
        if (n > m_length - index) {
            n = m_length - index;
        }
        char* newData = new char[n + 1];
        strncpy(newData, m_data + index, n);
        newData[n] = '\0';
        MyString result(newData);
        delete[] newData;
        return result;
    } else {
        return MyString();
    }
}

void MyString::erase(int index, int n) {
    if (index >= 0 && index < m_length) {
        if (n > m_length - index) {
            n = m_length - index;
        }
        memmove(m_data + index, m_data + index + n, m_length - index - n + 1);
        m_length -= n;
    }
}

void MyString::init(const char* cString) {
    if (cString == nullptr) {
        m_data = new char[1];
        m_data[0] = '\0';
        m_length = 0;
    } else {
        m_length = strlen(cString);
        m_data = new char[m_length + 1];
        strcpy(m_data, cString);
    }
}