CPlusPlus - #015 实现MyString类

实现MyString类

1 目标

本文的目的是通过自己实现字符串类，来掌握操作符重载、拷贝构造函数等知识。

2 示例代码

// ConsoleApplication3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <cstring>

#include <iostream>
#include <cstring>

class MyString {
private:
    char* data;
    size_t length;

public:
    // 默认构造函数
    MyString() : data(nullptr), length(0) {}

    // 带参数的构造函数
    MyString(const char* str) {
        if (str) {
            length = std::strlen(str);
            data = new char[length + 1];
            strcpy_s(data, length + 1, str);
        }
        else {
            data = nullptr;
            length = 0;
        }
    }

    // 拷贝构造函数
    MyString(const MyString& other) {
        length = other.length;
        if (length > 0) {
            data = new char[length + 1];
            strcpy_s(data, length + 1, other.data);
        }
        else {
            data = nullptr;
        }
    }

    // 移动构造函数
    MyString(MyString&& other) noexcept : data(other.data), length(other.length) {
        other.data = nullptr;
        other.length = 0;
    }

    // 析构函数
    ~MyString() {
        delete[] data;//调用 delete[] 一个空指针是安全的,无需检查
    }

    // 赋值操作符重载
    MyString& operator=(const MyString& other) {
        if (this == &other) {
            return *this;
        }

        delete[] data;

        length = other.length;
        if (length > 0) {
            data = new char[length + 1];
            strcpy_s(data, length + 1, other.data);
        }
        else {
            data = nullptr;
        }

        return *this;
    }

    // 移动赋值操作符重载
    MyString& operator=(MyString&& other) noexcept {
        if (this == &other) {
            return *this;
        }

        delete[] data;

        data = other.data;
        length = other.length;

        other.data = nullptr;
        other.length = 0;

        return *this;
    }

    // 加法操作符重载（字符串拼接）
    MyString operator+(const MyString& other) const {
        MyString newString;
        newString.length = length + other.length;
        newString.data = new char[newString.length + 1];
        strcpy_s(newString.data, length + 1, data);
        strcat_s(newString.data, newString.length + 1, other.data);
        return newString;
    }

    // 加法操作符重载（与const char*拼接）
    MyString operator+(const char* str) const {
        MyString newString;
        size_t strLength = std::strlen(str);
        newString.length = length + strLength;
        newString.data = new char[newString.length + 1];
        strcpy_s(newString.data, length + 1, data);
        strcat_s(newString.data, newString.length + 1, str);
        return newString;
    }

    // += 操作符重载
    MyString& operator+=(const MyString& other) {
        length += other.length;
        char* newData = new char[length + 1];
        strcpy_s(newData, length + 1, data);
        strcat_s(newData, length + 1, other.data);

        delete[] data;
        data = newData;

        return *this;
    }

    // += 操作符重载（与const char*拼接）
    MyString& operator+=(const char* str) {
        size_t strLength = std::strlen(str);
        length += strLength;
        char* newData = new char[length + 1];
        strcpy_s(newData, length + 1, data);
        strcat_s(newData, length + 1, str);

        delete[] data;
        data = newData;

        return *this;
    }

    // 等号操作符重载
    bool operator==(const MyString& other) const {
        if (length != other.length) {
            return false;
        }
        return std::strcmp(data, other.data) == 0;
    }

    // 下标操作符重载（非const版本，用于修改字符）
    char& operator[](size_t index) {
        if (index >= length) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    // 下标操作符重载（const版本，用于读取字符）
    const char& operator[](size_t index) const {
        if (index >= length) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    // 输出操作符重载
    friend std::ostream& operator<<(std::ostream& os, const MyString& str) {
        if (str.data) {
            os << str.data;
        }
        return os;
    }

    // 查找子字符串
    int find(const char* substr) const {
        if (!data || !substr) {
            return -1;
        }
        char* pos = std::strstr(data, substr);
        if (pos) {
            return pos - data;
        }
        return -1;
    }

    // 获取字符串长度
    size_t size() const {
        return length;
    }

    // 获取 C 风格字符串
    const char* c_str() const {
        return data;
    }
};



int main()
{
    MyString str1("Hello");
    MyString str2("World");
    MyString str3 = str1 + str2;
    MyString str4 = str1 + ",Tom";

    std::cout << "str1: " << str1 << std::endl;
    std::cout << "str2: " << str2 << std::endl;
    std::cout << "str3: " << str3 << std::endl;
    std::cout << "str4: " << str4 << std::endl;

    str1 += str2;
    std::cout << "str1 += str2: " << str1 << std::endl;  // 输出: HelloWorld

    std::cout << "str1 == str2: " << (str1 == str2 ? "true" : "false") << std::endl;
    std::cout << "str1 == \"HelloWorld\": " << (str1 == MyString("HelloWorld") ? "true" : "false") << std::endl;

    std::cout << "Finding 'lo' in str1: " << str1.find("lo") << std::endl;
    std::cout << "Finding 'World' in str3: " << str3.find("World") << std::endl;
    std::cout << "Finding 'XYZ' in str3: " << str3.find("XYZ") << std::endl;

    // 测试下标操作符
    std::cout << "str1[1]: " << str1[1] << std::endl;
    str1[1] = 'a';
    std::cout << "After modifying str1[1]: " << str1 << std::endl;

    return 0;
}

• 输出

str1: Hello
str2: World
str3: HelloWorld
str4: Hello,Tom
str1 += str2: HelloWorld
str1 == str2: false
str1 == "HelloWorld": true
Finding 'lo' in str1: 3
Finding 'World' in str3: 5
Finding 'XYZ' in str3: -1
str1[1]: e
After modifying str1[1]: HalloWorld```