String operator+ (const char* c, const String& s)

这是一个重载了加号运算符的函数，它允许在一个字符串常量和一个String对象之间进行拼接操作。具体来说，这个函数的定义是将一个字符串常量c和一个String对象s拼接起来，返回一个新的String对象，新的String对象中包含了c和s两个字符串的内容。

例如，如果我们有一个String对象s1，它的值为"Hello"，我们想要将一个字符串常量"c++"拼接到s1的后面，我们可以这样做：

String s1("Hello");
String s2 = "c++";
String s3 = s2 + s1;

这样，s3的值就是"c++Hello"。在这个例子中，我们使用了重载了加号运算符的函数String operator+ (const char* c, const String& s)，将字符串常量"c++"和String对象s1拼接起来得到了s3。

相关问题

定义一个字符串类 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;   // 获取字符串内容
    int length() 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);                    // 重载自减运算符（后置）
};

#endif

String.cpp 文件：

#include <iostream>
#include <cstring>
#include "String.h"
using namespace std;

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

String::String(const char *content) {
    if (content == nullptr) {
        str = new char[1];
        str[0] = '\0';
    } else {
        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) {
    if (content == nullptr) {
        delete[] str;
        str = new char[1];
        str[0] = '\0';
    } else {
        int len = strlen(content);
        if (len != strlen(str)) {
            delete[] str;
            str = new char[len + 1];
        }
        strcpy(str, content);
    }
}

void String::get(char *&dest) const {
    int len = strlen(str);
    dest = new char[len + 1];
    strcpy(dest, str);
}

int String::length() const {
    return strlen(str);
}

void String::print() const {
    cout << str << endl;
}

String& String::operator=(const String &cstr) {
    if (this != &cstr) {
        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 *new_str = new char[len1 + len2 + 1];
    strcpy(new_str, str);
    strcat(new_str, cstr.str);
    String result(new_str);
    delete[] new_str;
    return result;
}

String String::operator+(const char *cstr) {
    String temp(cstr);
    return (*this + temp);
}

String String::operator+(char ch) {
    char cstr[2] = {ch, '\0'};
    String temp(cstr);
    return (*this + temp);
}

String String::operator-( ) {
    int len = strlen(str);
    char *new_str = new char[len + 1];
    for (int i = 0; i < len; i++) {
        new_str[i] = str[len - i - 1];
    }
    new_str[len] = '\0';
    String result(new_str);
    delete[] new_str;
    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] += 'A' - 'a';
        }
    }
    return *this;
}

String String::operator++(int) {
    String temp(*this);
    ++(*this);
    return temp;
}

String& String::operator--() {
    int len = strlen(str);
    for (int i = 0; i < len; i++) {
        if (str[i] >= 'A' && str[i] <= 'Z') {
            str[i] += 'a' - 'A';
        }
    }
    return *this;
}

String String::operator--(int) {
    String temp(*this);
    --(*this);
    return temp;
}

成员函数（访问权限定义为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;
}