定义一个字符串类 String 数据成员（访问权限定义为protected）： 指向存放字符串内容的字符指针（char *str） 成员函数（访问权限定义为public）： 默认构造函数：初始化成一个空串 String( ); 带参数的构造函数：根据参数内容初始化字符串 String(const char *content); 拷贝构造函数：初始化字符串 String(const String &cstr); 析构函数：释放堆空间 ~String( ); 设置字符串内容 void set(const char *content); 获取字符串内容（定义为const成员函数）void get(char *&dest) const; 获取字符串长度（定义为const成员函数）int length() const; 打印字符串内容（定义为const成员函数）void print() const; 重载赋值运算符= String& operator=(const String &cstr); 重载下标运算符[ ]，实现获取字符串中某个指定位置的字符 char& operator[](int index); 重载加法运算符+，实现两个字符串的拼接 String operator+(const String &cstr); 重载加法运算符+，实现字符串和字符指针的拼接 String operator+(const char *cstr); 重载加法运算符+，实现字符串和单个字符的拼接 String operator+(char ch); 重载负号运算符-，实现字符串中字符的逆序排列 String operator-( ); 重载自增运算符++，实现将字符串中的小写字母转换成大写字母 String& operator++(); // 前置自增 String operator++(int); // 后置自增 重载自减运算符--，实现将字符串中的大写字母转换成小写字母 String& operator--(); // 前置自减 String operator--(int); // 后置自减 要求：将类的定义与类成员函数的实现分开。

String.h 文件：

#ifndef STRING_H
#define STRING_H

class String {
protected:
    char *str; // 存放字符串内容的字符指针

public:
    String(); // 默认构造函数：初始化成一个空串
    String(const char *content); // 带参数的构造函数：根据参数内容初始化字符串
    String(const String &cstr); // 拷贝构造函数：初始化字符串
    ~String(); // 析构函数：释放堆空间

    void set(const char *content); // 设置字符串内容
    void get(char *&dest) const; // 获取字符串内容（定义为const成员函数）
    int length() const; // 获取字符串长度（定义为const成员函数）
    void print() const; // 打印字符串内容（定义为const成员函数）

    String& operator=(const String &cstr); // 重载赋值运算符=
    char& operator[](int index); // 重载下标运算符[]
    String operator+(const String &cstr); // 重载加法运算符+，实现两个字符串的拼接
    String operator+(const char *cstr); // 重载加法运算符+，实现字符串和字符指针的拼接
    String operator+(char ch); // 重载加法运算符+，实现字符串和单个字符的拼接
    String operator-(); // 重载负号运算符-，实现字符串中字符的逆序排列
    String& operator++(); // 重载自增运算符++，实现将字符串中的小写字母转换成大写字母
    String operator++(int); // 重载自增运算符++，实现将字符串中的小写字母转换成大写字母
    String& operator--(); // 重载自减运算符--，实现将字符串中的大写字母转换成小写字母
    String operator--(int); // 重载自减运算符--，实现将字符串中的大写字母转换成小写字母
};

#endif // STRING_H

String.cpp 文件：

#include <cstring>
#include <iostream>
#include "String.h"

using namespace std;

// 默认构造函数：初始化成一个空串
String::String() {
    str = new char[1];
    str[0] = '\0';
}

// 带参数的构造函数：根据参数内容初始化字符串
String::String(const char *content) {
    int len = strlen(content);
    str = new char[len + 1];
    strcpy(str, content);
}

// 拷贝构造函数：初始化字符串
String::String(const String &cstr) {
    int len = strlen(cstr.str);
    str = new char[len + 1];
    strcpy(str, cstr.str);
}

// 析构函数：释放堆空间
String::~String() {
    delete[] str;
}

// 设置字符串内容
void String::set(const char *content) {
    int len = strlen(content);
    delete[] str;
    str = new char[len + 1];
    strcpy(str, content);
}

// 获取字符串内容（定义为const成员函数）
void String::get(char *&dest) const {
    int len = strlen(str);
    dest = new char[len + 1];
    strcpy(dest, str);
}

// 获取字符串长度（定义为const成员函数）
int String::length() const {
    return strlen(str);
}

// 打印字符串内容（定义为const成员函数）
void String::print() const {
    cout << str << endl;
}

// 重载赋值运算符=
String& String::operator=(const String &cstr) {
    if (this == &cstr) {
        return *this;
    }
    delete[] str;
    int len = strlen(cstr.str);
    str = new char[len + 1];
    strcpy(str, cstr.str);
    return *this;
}

// 重载下标运算符[]
char& String::operator[](int index) {
    return str[index];
}

// 重载加法运算符+，实现两个字符串的拼接
String String::operator+(const String &cstr) {
    int len1 = strlen(str);
    int len2 = strlen(cstr.str);
    char *temp = new char[len1 + len2 + 1];
    strcpy(temp, str);
    strcat(temp, cstr.str);
    String result(temp);
    delete[] temp;
    return result;
}

// 重载加法运算符+，实现字符串和字符指针的拼接
String String::operator+(const char *cstr) {
    int len1 = strlen(str);
    int len2 = strlen(cstr);
    char *temp = new char[len1 + len2 + 1];
    strcpy(temp, str);
    strcat(temp, cstr);
    String result(temp);
    delete[] temp;
    return result;
}

// 重载加法运算符+，实现字符串和单个字符的拼接
String String::operator+(char ch) {
    int len1 = strlen(str);
    char temp[2] = { ch, '\0' };
    String result(str);
    result.set(strcat(temp, str));
    return result;
}

// 重载负号运算符-，实现字符串中字符的逆序排列
String String::operator-() {
    int len = strlen(str);
    char *temp = new char[len + 1];
    for (int i = 0; i < len; i++) {
        temp[i] = str[len - 1 - i];
    }
    temp[len] = '\0';
    String result(temp);
    delete[] temp;
    return result;
}

// 重载自增运算符++，实现将字符串中的小写字母转换成大写字母
String& String::operator++() {
    int len = strlen(str);
    for (int i = 0; i < len; i++) {
        if (str[i] >= 'a' && str[i] <= 'z') {
            str[i] -= 32;
        }
    }
    return *this;
}

// 重载自增运算符++，实现将字符串中的小写字母转换成大写字母
String String::operator++(int) {
    String result(*this);
    int len = strlen(str);
    for (int i = 0; i < len; i++) {
        if (str[i] >= 'a' && str[i] <= 'z') {
            str[i] -= 32;
        }
    }
    return result;
}

// 重载自减运算符--，实现将字符串中的大写字母转换成小写字母
String& String::operator--() {
    int len = strlen(str);
    for (int i = 0; i < len; i++) {
        if (str[i] >= 'A' && str[i] <= 'Z') {
            str[i] += 32;
        }
    }
    return *this;
}

// 重载自减运算符--，实现将字符串中的大写字母转换成小写字母
String String::operator--(int) {
    String result(*this);
    int len = strlen(str);
    for (int i = 0; i < len; i++) {
        if (str[i] >= 'A' && str[i] <= 'Z') {
            str[i] += 32;
        }
    }
    return result;
}