基于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;

好的，以下是基于 char* 设计的 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;

    // 比较两个字符串，返回值为负数、0、正数表示当前字符串小于、等于、大于另一个字符串
    int compare(const MyString& s) const;

    // 比较当前字符串的子串和另一个字符串，返回值为负数、0、正数表示当前字符串小于、等于、大于另一个字符串
    int compare(int index, int n, const MyString& s) const;

    // 将当前字符串的子串复制到指定数组中
    void copy(char s[], int index , int n);

    // 获取当前字符串的 char* 形式
    char* data() const;

    // 查找指定字符在当前字符串中第一次出现的位置，若不存在返回 -1
    int find(char ch) const;

    // 从指定下标开始查找指定字符在当前字符串中第一次出现的位置，若不存在返回 -1
    int find(char ch, int index) const;

    // 从指定下标开始查找指定字符串在当前字符串中第一次出现的位置，若不存在返回 -1
    int find(const MyString& s, int index) const;

private:
    char* m_data; // 字符串的实际存储空间
    int m_length; // 字符串的长度
};

下面是 MyString 类的实现：

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

MyString::MyString(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);
    }
}

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

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

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

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

void MyString::clear() {
    delete[] m_data;
    m_data = new char[1];
    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 -1;
    }
    if (n < 0 || n > m_length - index) {
        return -1;
    }
    char* subStr = new char[n + 1];
    strncpy(subStr, m_data + index, n);
    subStr[n] = '\0';
    int result = strcmp(subStr, s.m_data);
    delete[] subStr;
    return result;
}

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

char* MyString::data() const {
    char* result = new char[m_length + 1];
    strcpy(result, m_data);
    return result;
}

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

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

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