成员函数（访问权限定义为public)： •默认构造函数：初始化成一个空串 Stringu); •带参数的构造函数：根据参数内容初始化字符串 String(constchar * content); •拷贝构造函数：初始化宇符串 String(constString& cstr); •析构函数：释放堆空间 ~string(); •重载赋值运算符 = （只能作为类成员函数重载） String & operator=(constString & cstr); String& operator=(constchar* cstr); •重载下标运算符1，实现获取字符串中某个指定位置的字符（只能作为 类成员函数重载） char& operator[](int index); •重载类型转换运算符char* ，实现将字符串类强制转换成字符指针（只能 作为类成员函数重载） operator char" ( ); 要求：将类的定义与类成员两数的实现分开。 全局运算符重载函数（以类的友员函数形式重载） •重载加法运算符＋，实现两个字符串的拼接 Stringoperatort(constString & cstr1, constString & cstr2); •重载加法运算符＋，实现字符串和字符指针的拼接 Stringoperatort(constString& cstr1, constchar* cstr2); Stringoperator + (constchar * cstrl, constString & cstr2); •重载白增运算符++，实现将字符串中的小写字母转换成大写字母 SString& operatort + (String & cstr);//前置自增 Stringoperatort + (String & cstr, int); 1 / 后置自增 注意：在类中对运算符重载函数进行友元函数声明！！

以下是字符串类的定义和类成员函数的实现：

class String {
private:
    char* str;  // 存放字符串的字符数组
    int length; // 字符串的长度

public:
    String();                      // 默认构造函数
    String(const char* content);   // 带参数的构造函数
    String(const String& cstr);    // 拷贝构造函数
    ~String();                     // 析构函数
    String& operator=(const String& cstr); // 重载赋值运算符
    String& operator=(const char* cstr);
    char& operator[](int index);   // 重载下标运算符
    operator char*();              // 重载类型转换运算符
    friend String operator+(const String& cstr1, const String& cstr2); // 友元函数重载加法运算符
    friend String operator+(const String& cstr1, const char* cstr2);
    friend String operator+(const char* cstr1, const String& cstr2);
    friend String& operator++(String& cstr); // 友元函数重载前置自增运算符
    friend String operator++(String& cstr, int); // 友元函数重载后置自增运算符
};

String::String() {
    length = 0;
    str = new char[1];
    str[0] = '\0';
}

String::String(const char* content) {
    length = strlen(content);
    str = new char[length + 1];
    strcpy(str, content);
}

String::String(const String& cstr) {
    length = cstr.length;
    str = new char[length + 1];
    strcpy(str, cstr.str);
}

String::~String() {
    delete[] str;
}

String& String::operator=(const String& cstr) {
    if (this != &cstr) {
        delete[] str;
        length = cstr.length;
        str = new char[length + 1];
        strcpy(str, cstr.str);
    }
    return *this;
}

String& String::operator=(const char* cstr) {
    delete[] str;
    length = strlen(cstr);
    str = new char[length + 1];
    strcpy(str, cstr);
    return *this;
}

char& String::operator[](int index) {
    return str[index];
}

String::operator char*() {
    return str;
}

String operator+(const String& cstr1, const String& cstr2) {
    String result;
    result.length = cstr1.length + cstr2.length;
    result.str = new char[result.length + 1];
    strcpy(result.str, cstr1.str);
    strcat(result.str, cstr2.str);
    return result;
}

String operator+(const String& cstr1, const char* cstr2) {
    String result;
    result.length = cstr1.length + strlen(cstr2);
    result.str = new char[result.length + 1];
    strcpy(result.str, cstr1.str);
    strcat(result.str, cstr2);
    return result;
}

String operator+(const char* cstr1, const String& cstr2) {
    String result;
    result.length = strlen(cstr1) + cstr2.length;
    result.str = new char[result.length + 1];
    strcpy(result.str, cstr1);
    strcat(result.str, cstr2.str);
    return result;
}

String& operator++(String& cstr) {
    for (int i = 0; i < cstr.length; i++) {
        if (cstr.str[i] >= 'a' && cstr.str[i] <= 'z') {
            cstr.str[i] -= 32;
        }
    }
    return cstr;
}

String operator++(String& cstr, int) {
    String temp(cstr);
    ++cstr;
    return temp;
}