C++ 字符串运算符重载代码示例

本文提供 C++ 字符串类中常见运算符重载的代码示例，包括加法、比较、赋值、下标和流插入运算符。示例代码清晰易懂，并附带详细的注释，帮助你理解 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;
}

总结

本文介绍了 C++ 字符串类中常见的运算符重载方法，并提供了相应的代码示例。通过这些示例，你可以更好地理解 C++ 字符串类中运算符重载的实现方法，并将其应用于自己的项目中。