一个简单实现的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[];
     m_pdata[] = '\0';
     cout << "默认构造函数" << endl;
 }

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

 CMyString::CMyString(const CMyString & inString)
 {
     int len = strlen(inString.m_pdata);
     m_pdata = new char[len +];
     strncpy(m_pdata, inString.m_pdata, len);
     m_pdata[len] = '\0';
     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 + ];
         strncpy(m_pdata, str, len);
         m_pdata[len] = '\0';
     }
     else
     {
         //创建一个空的data，占一个字节空间
         m_pdata = new char[];
         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) > );
 }

 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) <= );
 }

 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[] = 'e';

     cout << myString1 << "\t" << myString2 << "\t" << myString3 << endl;
     //由于myString1带了const修饰，因此是不可修改的，调用不可修改的重载[]运算符
     cout << myString1[] << 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 ;
 }

VS2015测试结果：

CentOS

编译

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

测试结果