一个简单实现的string类

为了复习c++知识，简单的实现一个string类，类名为CMyString

环境说明：windows 7 64位 和 CentOS Linux release 7.6.1810 (Core) 

开发工具：Visual Studio 2015 和 g++ (GCC) 4.8.5 20150623 (Red Hat 4.8.5-36)

CMyString类的头文件CMyString.h

#include <iostream>

#ifndef __C_MY_STRING__
#define __C_MY_STRING__

class CMyString
{
public:
    //默认构造函数
    CMyString();
    //带参数的构造函数
    CMyString(const char* str);
    //拷贝构造函数
    CMyString(const CMyString&);
    //析构函数
    ~CMyString();

    //重载赋值运算符
    CMyString& operator=(const CMyString&);
    CMyString& operator=(const char*);
    //重载[]运算符（可修改）
    char& operator[](const int);
    //重载[]运算符（不可修改）
    const char& operator[](const int) const;
    //重载==运算符
    bool operator==(const CMyString&) const;
    //重载!=运算符
    bool operator!=(const CMyString&) const;
    //重载>运算符
    bool operator>(const CMyString&) const;
    //重载<运算符
    bool operator<(const CMyString&) const;
    //重载>=运算符
    bool operator>=(const CMyString&) const;
    //重载>=运算符
    bool operator<=(const CMyString&) const;
    //重载<<运算符
    friend std::ostream& operator<<(std::ostream&, const CMyString &);
private:
    char* m_pdata;
};

#endif // !__C_MY_STRING__

CMyString类的实现文件CMyString.cpp

#include "CMyString.h"
#include <cstring>
using namespace std;

CMyString::CMyString()
{
    //创建一个空的data，占一个字节空间
    m_pdata = new char[1];
    m_pdata[0] = '';
    cout << "默认构造函数" << endl;
}

CMyString::CMyString(const char * str)
{
    if (str)
    {
        int len = strlen(str);
        m_pdata = new char[len+1];
        strncpy(m_pdata, str, len);
        m_pdata[len] = '';
    }
    else
    {
        //创建一个空的data，占一个字节空间
        m_pdata = new char[1];
        m_pdata[0] = '';
    }
    cout << "带参数的构造函数" << endl;
}

CMyString::CMyString(const CMyString & inString)
{
    int len = strlen(inString.m_pdata);
    m_pdata = new char[len +1];
    strncpy(m_pdata, inString.m_pdata, len);
    m_pdata[len] = '';
    cout << "拷贝构造函数" << endl;
}

CMyString::~CMyString()
{
    delete[] m_pdata;
    m_pdata = nullptr;
    cout << "析构函数" << endl;
}

CMyString & CMyString::operator=(const CMyString & instring)
{
    cout << "重载赋值运算符1" << endl;
    //如果是同一个对象，不做处理直接返回
    if (this == &instring)
    {
        return *this;
    }

    //使用入参通过拷贝构造函数创建一个临时对象
    CMyString tmpString(instring);
    //修改data指针,当函数结束时，tmpString对象过期，将自动调用析构函数，把原来当前对象的data地址释放掉
    char* tmpData = tmpString.m_pdata;
    tmpString.m_pdata = m_pdata;
    m_pdata = tmpData;
    return *this;
}

CMyString & CMyString::operator=(const char * str)
{
    cout << "重载赋值运算符2" << endl;
    delete m_pdata;
    if (str)
    {
        int len = strlen(str);
        m_pdata = new char[len + 1];
        strncpy(m_pdata, str, len);
        m_pdata[len] = '';
    }
    else
    {
        //创建一个空的data，占一个字节空间
        m_pdata = new char[1];
        m_pdata[0] = '';
    }
    return *this;
}

char & CMyString::operator[](const int index)
{
    cout << "重载[]运算符（可修改）" << endl;
    return m_pdata[index];
}

const char& CMyString::operator[](const int index) const
{
    cout << "重载[]运算符（不可修改）" << endl;
    return m_pdata[index];
}

bool CMyString::operator==(const CMyString & inString) const
{
    cout << "重载==运算符" << endl;
    return !strcmp(m_pdata, inString.m_pdata);
}

bool CMyString::operator!=(const CMyString & inString) const
{
    cout << "重载!=运算符" << endl;
    return strcmp(m_pdata, inString.m_pdata);
}

bool CMyString::operator>(const CMyString & inString) const
{
    cout << "重载>运算符" << endl;
    return (strcmp(m_pdata, inString.m_pdata) > 0);
}

bool CMyString::operator<(const CMyString & inString) const
{
    cout << "重载<运算符" << endl;
    return (strcmp(m_pdata, inString.m_pdata) < 0);
}

bool CMyString::operator>=(const CMyString & inString) const
{
    cout << "重载>=运算符" << endl;
    return (strcmp(m_pdata, inString.m_pdata) >= 0);
}

bool CMyString::operator<=(const CMyString & inString) const
{
    cout << "重载<=运算符" << endl;
    return (strcmp(m_pdata, inString.m_pdata) <= 0);
}

ostream & operator<<(ostream & os, const CMyString & instring)
{
    os << instring.m_pdata;
    return os;
}

CMystring类的测试文件testCMyString.cpp

#include <iostream>
#include "CMyString.h"

using namespace std;
int main()
{
    //带参数的构造函数
    const CMyString myString1("abc");
    //默认构造函数
    CMyString myString2;
    //重载赋值运算符2
    myString2 = "def";
    //默认构造函数
    CMyString myString3;
    //重载赋值运算符1，（这个类的内部实现是先调用拷贝构造函数生成一个临时变量，再使用临时变量通过把内容给到myString3，再把临时变量析构）
    myString3 = myString2;
    //拷贝构造函数
    CMyString myString4(myString2);
    myString3[2] = 'e';

    cout << myString1 << "	" << myString2 << "	" << myString3 << endl;
    //由于myString1带了const修饰，因此是不可修改的，调用不可修改的重载[]运算符
    cout << myString1[2] << endl;
    cout << (myString1 != myString2) << endl;
    cout << (myString1 == myString2) << endl;
    cout << (myString1 < myString2) << endl;
    cout << (myString1 <= myString2) << endl;
    cout << (myString1 > myString2) << endl;
    cout << (myString1 >= myString2) << endl;
    return 0;
}

VS2015测试结果：

  

CentOS 

编译

g++ -o testCMyString -std=c++0x ./*.cpp

测试结果