c++string运算符重载

C++中的string类已经重载了许多运算符，例如+、+=、==、!=、<、<=、>、>=等。我们也可以自己定义运算符重载来实现一些特定的功能。

例如，我们可以重载+运算符来实现两个字符串的拼接：

string operator+(const string& str1, const string& str2) {
    string result = str1;
    result += str2;
    return result;
}

这里我们定义了一个全局函数，接受两个const string&类型的参数，返回一个string类型的结果。在函数内部，我们先将第一个字符串赋值给结果字符串，然后再使用+=运算符将第二个字符串拼接到结果字符串后面。

相关问题

c++中string类运算符重载加法

C++中`string`类已经重载了`+`运算符，因此可以直接使用`+`进行字符串的拼接。例如：

#include <iostream>
#include <string>

using namespace std;

int main() {
    string str1 = "Hello, ";
    string str2 = "world!";
    string str3 = str1 + str2;
    cout << str3 << endl; // 输出：Hello, world!
    return 0;
}

如果想要手动实现`+`运算符重载，可以使用以下代码：

#include <iostream>
#include <cstring>

using namespace std;

class MyString {
private:
    char* m_data;
public:
    MyString(const char* str = nullptr) {
        if (str) {
            m_data = new char[strlen(str) + 1];
            strcpy(m_data, str);
        } else {
            m_data = new char[1];
            *m_data = '\0';
        }
    }

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

    ~MyString() {
        delete[] m_data;
    }

    MyString operator+(const MyString& other) const {
        MyString newStr;
        newStr.m_data = new char[strlen(m_data) + strlen(other.m_data) + 1];
        strcpy(newStr.m_data, m_data);
        strcat(newStr.m_data, other.m_data);
        return newStr;
    }

    friend ostream& operator<<(ostream& os, const MyString& str) {
        os << str.m_data;
        return os;
    }
};

int main() {
    MyString str1("Hello, ");
    MyString str2("world!");
    MyString str3 = str1 + str2;
    cout << str3 << endl; // 输出：Hello, world!
    return 0;
}

注意：以上代码只是一种实现方式，实际应用中应该使用`string`类自带的`+`运算符重载，因为它已经经过了严格的测试和优化。

c++输入输出运算符重载

C++中的输入输出运算符重载是一种特殊的函数重载，其目的是为了让自定义的类类型也能像基本数据类型一样使用输入输出运算符来进行输入输出操作。

重载运算符的语法格式为：

istream& operator>>(istream& is, MyClass& obj) {
    // 读取输入，并将结果存储在 obj 中
    return is;
}

ostream& operator<<(ostream& os, const MyClass& obj) {
    // 将 obj 输出到 os 中
    return os;
}

其中，`operator>>` 和 `operator<<` 分别表示输入和输出运算符，`istream` 和 `ostream` 是输入输出流类，`MyClass` 是自定义的类类型。

在重载输入运算符时，需要从输入流中读取数据，并将其存储在类的成员变量中；在重载输出运算符时，需要将类的成员变量输出到输出流中。

例如，如果我们有一个自定义的类 `Person`，其成员变量包括姓名和年龄，我们可以通过重载输入输出运算符来实现输入输出操作：

class Person {
public:
    string name;
    int age;
};

istream& operator>>(istream& is, Person& p) {
    is >> p.name >> p.age;
    return is;
}

ostream& operator<<(ostream& os, const Person& p) {
    os << p.name << " " << p.age;
    return os;
}

这样，我们就可以使用 `>>` 和 `<<` 运算符来进行输入输出操作：

Person p;
cin >> p;
cout << p;

注意，输入运算符的第二个参数必须是一个非常量引用，因为需要修改对象的状态；输出运算符的第二个参数可以是一个常量引用，因为不需要修改对象的状态。