C++学习笔记总结练习： 字符串类MyString的实现

MyString是一个自定义的字符串类，它封装了一些常见的字符串操作和功能。下面是一个简单的MyString类的实现示例：

#include <iostream>
#include <cstring>

class MyString {
private:
    char* m_data; // 用于存储字符串的字符数组
    int m_length; // 字符串的长度

public:
    // 默认构造函数
    MyString() {
        m_data = nullptr;
        m_length = 0;
    }

    // 带参构造函数
    MyString(const char* str) {
        m_length = strlen(str);
        m_data = new char[m_length + 1]; // +1 用于存储字符串结束符'\0'
        strcpy(m_data, str);
    }

    // 拷贝构造函数
    MyString(const MyString& other) {
        m_length = other.m_length;
        m_data = new char[m_length + 1];
        strcpy(m_data, other.m_data);
    }

    // 析构函数
    ~MyString() {
        delete[] m_data;
    }

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

    // 获取字符串内容
    const char* c_str() const {
        return m_data;
    }

    // 重载赋值运算符
    MyString& operator=(const MyString& other) {
        if (this != &other) {
            delete[] m_data;
            m_length = other.m_length;
            m_data = new char[m_length + 1];
            strcpy(m_data, other.m_data);
        }
        return *this;
    }

    // 重载加法运算符
    MyString operator+(const MyString& other) const {
        MyString newString;
        newString.m_length = m_length + other.m_length;
        newString.m_data = new char[newString.m_length + 1];
        strcpy(newString.m_data, m_data);
        strcat(newString.m_data, other.m_data);
        return newString;
    }
};

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

    std::cout << "str1: " << str1.c_str() << std::endl;
    std::cout << "str2: " << str2.c_str() << std::endl;
    std::cout << "str3: " << str3.c_str() << std::endl;

    return 0;
}

在上面的示例中，MyString类封装了一个字符数组m_data来存储字符串的内容，以及一个整数m_length来记录字符串的长度。它提供了默认构造函数、带参构造函数、拷贝构造函数和析构函数来管理字符串的内存。

MyString类还提供了一些成员函数，如length()用于获取字符串的长度，c_str()用于获取字符串的内容，以及重载的赋值运算符和加法运算符，使得可以方便地进行字符串的赋值和拼接操作。

在main函数中，我们创建了两个MyString对象str1和str2，并使用重载的加法运算符将它们拼接成一个新的字符串str3。最后，我们输出了这三个字符串的内容。

4 实例——MyString的实现

/* 
* C++ string 类的实现
* 1. 构造函数和析构函数
* 2. 字符串长度
* 3. 重载=运算符
* 4. 重载+=运算符
* 5. 重载<< >> 运算符
* 6. 重载比较运算符
* 7. 重载[]下标运算符
*/

#include <iostream>
#include <cstring>
using namespace std;

class MyString
{
private:
    char * str;
    int length;
public:
    // 长度
    int size ()const {
        return length;
    };
    char* getstr()const{
        return str;
    }
    // 默认构造函数
    MyString();
    // 字符串构造函数
    MyString(const char*);
    // 复制构造函数
    MyString(const MyString& b);

    // 重载等号运算符
    MyString& operator=(const MyString &b);
    // 重载+=运算符
    MyString& operator+=(const MyString &b);
    // 重载比较运算符
    bool operator<(const MyString &b);
    // 重载下标运算符
    char& operator[](const int &index) const ;
    // 重载输入输出操作
    friend ostream& operator<<(ostream& ,const MyString &b);
    ~MyString();
};

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

MyString::MyString(const char* b){
    if(b){
        length = strlen(b);
        str = new char[length+1];
        strcpy(str,b);
    }
    else{
        MyString();
    }
}
MyString::MyString(const MyString&b){
    length = b.size();
    if(length>0)
    str = new char[length+1];
    else
    MyString();
}

MyString& MyString::operator=(const MyString &b){
    if(&b == this){
        return *this;
    }
    delete[] str;
    length = b.size();
    str = new char[length + 1];
    strcpy(str,b.getstr());
    return *this;
}

MyString& MyString::operator+=(const MyString&b){
    if(b.size()==0){
        return *this;
    }
    char* temp = new char[length+b.length+1];
    strcpy(temp,str);
    strcat(temp,b.getstr());
    delete[] str;
    str = temp;
    return *this;
}

char& MyString::operator[](const int &index)const {
    if(index>length)return str[length];
    return str[index];
}

bool MyString::operator<(const MyString &b){
    for(int i=0;i<length;i++){
        if(i>b.size())return false;
        if(b[i]>str[i])return true;
        if(b[i]<str[i])return false;
    }
    return true;
}

MyString::~MyString()
{
    delete[] str;
}

// 外部定义一个函数，内部声明为友元
ostream& operator<<(ostream &out,const MyString&b){
    out<<b.getstr();
    return out;
}


int main()
{
    // 测试函数
    MyString s1,s2="123",s3,s4="456";
    s3=s2;
    s1=s2;
    s1+=s1;
    cout<<s1<<endl;
    cout<<s2<<endl;
    cout<<s3<<endl;
    cout<<(s3<s4)<<endl;
    cout<<endl;
    return 0;
}