c++字符串各个运算符重载代码

以下是一些常见的字符串运算符重载代码：

1. 字符串加法运算符重载：

#include <iostream>
#include <cstring>

class String {
public:
    String() {}
    String(const char* s) : m_data(new char[strlen(s) + 1]) {
        strcpy(m_data, s);
        m_size = strlen(s);
    }
    String(const String& other) : m_data(new char[other.m_size + 1]), m_size(other.m_size) {
        strcpy(m_data, other.m_data);
    }
    ~String() {
        delete[] m_data;
    }

    String operator+(const String& other) const {
        char* new_data = new char[m_size + other.m_size + 1];
        strcpy(new_data, m_data);
        strcat(new_data, other.m_data);
        String new_string(new_data);
        delete[] new_data;
        return new_string;
    }

    const char* c_str() const {
        return m_data;
    }

private:
    char* m_data = nullptr;
    int m_size = 0;
};

int main() {
    String s1("Hello ");
    String s2("world!");
    String s3 = s1 + s2;
    std::cout << s3.c_str() << std::endl; // 输出 "Hello world!"
    return 0;
}

2. 字符串比较运算符重载：

#include <iostream>
#include <cstring>

class String {
public:
    String() {}
    String(const char* s) : m_data(new char[strlen(s) + 1]) {
        strcpy(m_data, s);
        m_size = strlen(s);
    }
    String(const String& other) : m_data(new char[other.m_size + 1]), m_size(other.m_size) {
        strcpy(m_data, other.m_data);
    }
    ~String() {
        delete[] m_data;
    }

    bool operator==(const String& other) const {
        return strcmp(m_data, other.m_data) == 0;
    }

    bool operator!=(const String& other) const {
        return !(*this == other);
    }

    bool operator<(const String& other) const {
        return strcmp(m_data, other.m_data) < 0;
    }

    bool operator>(const String& other) const {
        return strcmp(m_data, other.m_data) > 0;
    }

    bool operator<=(const String& other) const {
        return strcmp(m_data, other.m_data) <= 0;
    }

    bool operator>=(const String& other) const {
        return strcmp(m_data, other.m_data) >= 0;
    }

    const char* c_str() const {
        return m_data;
    }

private:
    char* m_data = nullptr;
    int m_size = 0;
};

int main() {
    String s1("Hello");
    String s2("World");
    if (s1 == s2) {
        std::cout << "s1 == s2" << std::endl;
    }
    if (s1 != s2) {
        std::cout << "s1 != s2" << std::endl;
    }
    if (s1 < s2) {
        std::cout << "s1 < s2" << std::endl;
    }
    if (s1 > s2) {
        std::cout << "s1 > s2" << std::endl;
    }
    if (s1 <= s2) {
        std::cout << "s1 <= s2" << std::endl;
    }
    if (s1 >= s2) {
        std::cout << "s1 >= s2" << std::endl;
    }
    return 0;
}

3. 字符串赋值运算符重载：

#include <iostream>
#include <cstring>

class String {
public:
    String() {}
    String(const char* s) : m_data(new char[strlen(s) + 1]) {
        strcpy(m_data, s);
        m_size = strlen(s);
    }
    String(const String& other) : m_data(new char[other.m_size + 1]), m_size(other.m_size) {
        strcpy(m_data, other.m_data);
    }
    ~String() {
        delete[] m_data;
    }

    String& operator=(const String& other) {
        if (this != &other) {
            delete[] m_data;
            m_data = new char[other.m_size + 1];
            strcpy(m_data, other.m_data);
            m_size = other.m_size;
        }
        return *this;
    }

    const char* c_str() const {
        return m_data;
    }

private:
    char* m_data = nullptr;
    int m_size = 0;
};

int main() {
    String s1("Hello");
    String s2("World");
    s1 = s2;
    std::cout << s1.c_str() << std::endl; // 输出 "World"
    return 0;
}

4. 字符串下标运算符重载：

#include <iostream>
#include <cstring>

class String {
public:
    String() {}
    String(const char* s) : m_data(new char[strlen(s) + 1]) {
        strcpy(m_data, s);
        m_size = strlen(s);
    }
    String(const String& other) : m_data(new char[other.m_size + 1]), m_size(other.m_size) {
        strcpy(m_data, other.m_data);
    }
    ~String() {
        delete[] m_data;
    }

    char& operator[](int i) {
        return m_data[i];
    }

    const char& operator[](int i) const {
        return m_data[i];
    }

    const char* c_str() const {
        return m_data;
    }

private:
    char* m_data = nullptr;
    int m_size = 0;
};

int main() {
    String s("Hello");
    std::cout << s[0] << std::endl; // 输出 'H'
    s[0] = 'h';
    std::cout << s.c_str() << std::endl; // 输出 "hello"
    return 0;
}

5. 字符串流插入运算符重载：

#include <iostream>
#include <sstream>
#include <cstring>

class String {
public:
    String() {}
    String(const char* s) : m_data(new char[strlen(s) + 1]) {
        strcpy(m_data, s);
        m_size = strlen(s);
    }
    String(const String& other) : m_data(new char[other.m_size + 1]), m_size(other.m_size) {
        strcpy(m_data, other.m_data);
    }
    ~String() {
        delete[] m_data;
    }

    friend std::ostream& operator<<(std::ostream& os, const String& s) {
        return os << s.m_data;
    }

    friend std::istream& operator>>(std::istream& is, String& s) {
        std::string str;
        is >> str;
        s = str.c_str();
        return is;
    }

    const char* c_str() const {
        return m_data;
    }

private:
    char* m_data = nullptr;
    int m_size = 0;
};

int main() {
    String s;
    std::stringstream ss("Hello");
    ss >> s;
    std::cout << s << std::endl; // 输出 "Hello"
    return 0;
}
``