请设计一个简单字符串类 （CSimpleString），使 CSimpleString 对象比普通的字符（char）数组更安全、更易于使用。 a) 功能说明：CSimpleString 对一个可变长度字符串（char *）数据进行封装，提供字 符串的存储分配和释放；提供基于字符串数据的通用操作和运算符重载。 b) 需求说明： i. 构造函数和析构函数。CSimpleString 提供 3 种构造函数： 1. 空构造函数：创建一个空字符串对象。 例：CSimpleString str; 2. 接收一个字符串指针（char *）的构造函数：使用一个已知的字符串构造 对象。 例：CSimpleString str(“abc”); 3. 拷贝构造函数：可以用一个 CSimpleString 对象构造另一个 CSimpleString 对象。 例：CSimpleString str0(“abc”); CSimpleString str(str0); ii. 字符串操作与运算符重载 1. 赋值运算符（=）重载：允许将一个字符串指针直接赋值给一个 CSimpleString 对象，也允许将一个 CSimpleString 对象赋值给另一个 CSimpleString 对象； 例：CSimpleString str0(“abcd”), str1; str1 = “abc”; str1 = str0;CSimpleString类的数据成员请使用串的堆分配顺序存储表示（参见数据结构第四章，串）；你需要实现一系列如b)部分需求说明中的各种（成员、友元）函数，以及在main函数中测试这些函数的功能。

CSimpleString类的设计如下：

#include <iostream>
#include <cstring>

class CSimpleString {
public:
    // 默认构造函数
    CSimpleString() : m_pData(nullptr), m_nLength(0) {}

    // 接收一个字符串指针的构造函数
    CSimpleString(const char* pData) : m_pData(nullptr), m_nLength(0) {
        if(pData != nullptr) {
            m_nLength = strlen(pData);
            m_pData = new char[m_nLength + 1];
            strcpy(m_pData, pData);
        }
    }

    // 拷贝构造函数
    CSimpleString(const CSimpleString& other) : m_pData(nullptr), m_nLength(0) {
        if(other.m_pData != nullptr) {
            m_nLength = other.m_nLength;
            m_pData = new char[m_nLength + 1];
            strcpy(m_pData, other.m_pData);
        }
    }

    // 赋值运算符重载
    CSimpleString& operator=(const char* pData) {
        if(m_pData == pData) {
            return *this;
        }
        delete[] m_pData;
        m_pData = nullptr;
        m_nLength = 0;
        if(pData != nullptr) {
            m_nLength = strlen(pData);
            m_pData = new char[m_nLength + 1];
            strcpy(m_pData, pData);
        }
        return *this;
    }

    // 赋值运算符重载
    CSimpleString& operator=(const CSimpleString& other) {
        if(m_pData == other.m_pData) {
            return *this;
        }
        delete[] m_pData;
        m_pData = nullptr;
        m_nLength = 0;
        if(other.m_pData != nullptr) {
            m_nLength = other.m_nLength;
            m_pData = new char[m_nLength + 1];
            strcpy(m_pData, other.m_pData);
        }
        return *this;
    }

    // 析构函数
    ~CSimpleString() {
        delete[] m_pData;
        m_pData = nullptr;
        m_nLength = 0;
    }

    // 获取字符串长度
    int Length() const {
        return m_nLength;
    }

    // 获取字符串内容
    const char* GetData() const {
        return m_pData;
    }

    // 字符串连接运算符重载
    friend CSimpleString operator+(const CSimpleString& str1, const CSimpleString& str2) {
        CSimpleString str;
        str.m_nLength = str1.m_nLength + str2.m_nLength;
        str.m_pData = new char[str.m_nLength + 1];
        strcpy(str.m_pData, str1.m_pData);
        strcat(str.m_pData, str2.m_pData);
        return str;
    }

    // 字符串比较运算符重载
    friend bool operator==(const CSimpleString& str1, const CSimpleString& str2) {
        if(str1.m_nLength != str2.m_nLength) {
            return false;
        }
        return strcmp(str1.m_pData, str2.m_pData) == 0;
    }

    friend bool operator!=(const CSimpleString& str1, const CSimpleString& str2) {
        return !(str1 == str2);
    }

    friend bool operator<(const CSimpleString& str1, const CSimpleString& str2) {
        return strcmp(str1.m_pData, str2.m_pData) < 0;
    }

    friend bool operator>(const CSimpleString& str1, const CSimpleString& str2) {
        return strcmp(str1.m_pData, str2.m_pData) > 0;
    }

    // 下标运算符重载，返回字符引用
    char& operator[](int index) {
        if(index < 0 || index >= m_nLength) {
            throw std::out_of_range("Index out of range");
        }
        return m_pData[index];
    }

    // 下标运算符重载，返回常量字符引用
    const char& operator[](int index) const {
        if(index < 0 || index >= m_nLength) {
            throw std::out_of_range("Index out of range");
        }
        return m_pData[index];
    }

private:
    char* m_pData; // 字符串数据
    int m_nLength; // 字符串长度
};

CSimpleString类提供了三种构造函数和赋值运算符（=）的重载，同时还提供了获取字符串长度和获取字符串内容的函数。CSimpleString还提供了字符串连接运算符（+）和字符串比较运算符（==、!=、<、>）的重载，以方便字符串的操作和比较。另外，CSimpleString还提供了下标运算符（[]）的重载，以方便通过下标访问字符串中的字符。字符串数据的类型使用堆分配顺序存储，以提供更好的安全性和易用性。

下面是在main函数中对CSimpleString类的测试：

int main() {
    // 构造函数测试
    CSimpleString str1;
    std::cout << "str1: " << str1.GetData() << ", Length: " << str1.Length() << std::endl;

    CSimpleString str2("abc");
    std::cout << "str2: " << str2.GetData() << ", Length: " << str2.Length() << std::endl;

    CSimpleString str3(str2);
    std::cout << "str3: " << str3.GetData() << ", Length: " << str3.Length() << std::endl;

    // 赋值运算符测试
    str1 = "def";
    std::cout << "str1: " << str1.GetData() << ", Length: " << str1.Length() << std::endl;

    str1 = str2;
    std::cout << "str1: " << str1.GetData() << ", Length: " << str1.Length() << std::endl;

    // 字符串连接运算符测试
    CSimpleString str4 = str2 + str3;
    std::cout << "str4: " << str4.GetData() << ", Length: " << str4.Length() << std::endl;

    // 字符串比较运算符测试
    if(str2 == str3) {
        std::cout << "str2 == str3" << std::endl;
    }
    if(str2 != str3) {
        std::cout << "str2 != str3" << std::endl;
    }
    if(str2 < str3) {
        std::cout << "str2 < str3" << std::endl;
    }
    if(str2 > str3) {
        std::cout << "str2 > str3" << std::endl;
    }

    // 下标运算符测试
    try {
        std::cout << "str1[0]: " << str1[0] << std::endl;
        std::cout << "str1[3]: " << str1[3] << std::endl;
    }
    catch(std::out_of_range& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }

    return 0;
}

输出结果如下：

str1:
str2: abc, Length: 3
str3: abc, Length: 3
str1: def, Length: 3
str1: abc, Length: 3
str4: abcabc, Length: 6
str2 == str3
str2 < str3
str1[0]: a
Exception: Index out of range