一个简单实现的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

 1 #include <iostream>
 2 
 3 #ifndef __C_MY_STRING__
 4 #define __C_MY_STRING__
 5 
 6 class CMyString
 7 {
 8 public:
 9     //默认构造函数
10     CMyString();
11     //带参数的构造函数
12     CMyString(const char* str);
13     //拷贝构造函数
14     CMyString(const CMyString&);
15     //析构函数
16     ~CMyString();
17 
18     //重载赋值运算符
19     CMyString& operator=(const CMyString&);
20     CMyString& operator=(const char*);
21     //重载[]运算符（可修改）
22     char& operator[](const int);
23     //重载[]运算符（不可修改）
24     const char& operator[](const int) const;
25     //重载==运算符
26     bool operator==(const CMyString&) const;
27     //重载!=运算符
28     bool operator!=(const CMyString&) const;
29     //重载>运算符
30     bool operator>(const CMyString&) const;
31     //重载<运算符
32     bool operator<(const CMyString&) const;
33     //重载>=运算符
34     bool operator>=(const CMyString&) const;
35     //重载>=运算符
36     bool operator<=(const CMyString&) const;
37     //重载<<运算符
38     friend std::ostream& operator<<(std::ostream&, const CMyString &);
39 private:
40     char* m_pdata;
41 };
42 
43 #endif // !__C_MY_STRING__

CMyString类的实现文件CMyString.cpp

  1 #include "CMyString.h"
  2 #include <cstring>
  3 using namespace std;
  4 
  5 CMyString::CMyString()
  6 {
  7     //创建一个空的data，占一个字节空间
  8     m_pdata = new char[1];
  9     m_pdata[0] = '';
 10     cout << "默认构造函数" << endl;
 11 }
 12 
 13 CMyString::CMyString(const char * str)
 14 {
 15     if (str)
 16     {
 17         int len = strlen(str);
 18         m_pdata = new char[len+1];
 19         strncpy(m_pdata, str, len);
 20         m_pdata[len] = '';
 21     }
 22     else
 23     {
 24         //创建一个空的data，占一个字节空间
 25         m_pdata = new char[1];
 26         m_pdata[0] = '';
 27     }
 28     cout << "带参数的构造函数" << endl;
 29 }
 30 
 31 CMyString::CMyString(const CMyString & inString)
 32 {
 33     int len = strlen(inString.m_pdata);
 34     m_pdata = new char[len +1];
 35     strncpy(m_pdata, inString.m_pdata, len);
 36     m_pdata[len] = '';
 37     cout << "拷贝构造函数" << endl;
 38 }
 39 
 40 CMyString::~CMyString()
 41 {
 42     delete[] m_pdata;
 43     m_pdata = nullptr;
 44     cout << "析构函数" << endl;
 45 }
 46 
 47 CMyString & CMyString::operator=(const CMyString & instring)
 48 {
 49     cout << "重载赋值运算符1" << endl;
 50     //如果是同一个对象，不做处理直接返回
 51     if (this == &instring)
 52     {
 53         return *this;
 54     }
 55 
 56     //使用入参通过拷贝构造函数创建一个临时对象
 57     CMyString tmpString(instring);
 58     //修改data指针,当函数结束时，tmpString对象过期，将自动调用析构函数，把原来当前对象的data地址释放掉
 59     char* tmpData = tmpString.m_pdata;
 60     tmpString.m_pdata = m_pdata;
 61     m_pdata = tmpData;
 62     return *this;
 63 }
 64 
 65 CMyString & CMyString::operator=(const char * str)
 66 {
 67     cout << "重载赋值运算符2" << endl;
 68     delete m_pdata;
 69     if (str)
 70     {
 71         int len = strlen(str);
 72         m_pdata = new char[len + 1];
 73         strncpy(m_pdata, str, len);
 74         m_pdata[len] = '';
 75     }
 76     else
 77     {
 78         //创建一个空的data，占一个字节空间
 79         m_pdata = new char[1];
 80         m_pdata[0] = '';
 81     }
 82     return *this;
 83 }
 84 
 85 char & CMyString::operator[](const int index)
 86 {
 87     cout << "重载[]运算符（可修改）" << endl;
 88     return m_pdata[index];
 89 }
 90 
 91 const char& CMyString::operator[](const int index) const
 92 {
 93     cout << "重载[]运算符（不可修改）" << endl;
 94     return m_pdata[index];
 95 }
 96 
 97 bool CMyString::operator==(const CMyString & inString) const
 98 {
 99     cout << "重载==运算符" << endl;
100     return !strcmp(m_pdata, inString.m_pdata);
101 }
102 
103 bool CMyString::operator!=(const CMyString & inString) const
104 {
105     cout << "重载!=运算符" << endl;
106     return strcmp(m_pdata, inString.m_pdata);
107 }
108 
109 bool CMyString::operator>(const CMyString & inString) const
110 {
111     cout << "重载>运算符" << endl;
112     return (strcmp(m_pdata, inString.m_pdata) > 0);
113 }
114 
115 bool CMyString::operator<(const CMyString & inString) const
116 {
117     cout << "重载<运算符" << endl;
118     return (strcmp(m_pdata, inString.m_pdata) < 0);
119 }
120 
121 bool CMyString::operator>=(const CMyString & inString) const
122 {
123     cout << "重载>=运算符" << endl;
124     return (strcmp(m_pdata, inString.m_pdata) >= 0);
125 }
126 
127 bool CMyString::operator<=(const CMyString & inString) const
128 {
129     cout << "重载<=运算符" << endl;
130     return (strcmp(m_pdata, inString.m_pdata) <= 0);
131 }
132 
133 ostream & operator<<(ostream & os, const CMyString & instring)
134 {
135     os << instring.m_pdata;
136     return os;
137 }

CMystring类的测试文件testCMyString.cpp

 1 #include <iostream>
 2 #include "CMyString.h"
 3 
 4 using namespace std;
 5 int main()
 6 {
 7     //带参数的构造函数
 8     const CMyString myString1("abc");
 9     //默认构造函数
10     CMyString myString2;
11     //重载赋值运算符2
12     myString2 = "def";
13     //默认构造函数
14     CMyString myString3;
15     //重载赋值运算符1，（这个类的内部实现是先调用拷贝构造函数生成一个临时变量，再使用临时变量通过把内容给到myString3，再把临时变量析构）
16     myString3 = myString2;
17     //拷贝构造函数
18     CMyString myString4(myString2);
19     myString3[2] = 'e';
20 
21     cout << myString1 << "	" << myString2 << "	" << myString3 << endl;
22     //由于myString1带了const修饰，因此是不可修改的，调用不可修改的重载[]运算符
23     cout << myString1[2] << endl;
24     cout << (myString1 != myString2) << endl;
25     cout << (myString1 == myString2) << endl;
26     cout << (myString1 < myString2) << endl;
27     cout << (myString1 <= myString2) << endl;
28     cout << (myString1 > myString2) << endl;
29     cout << (myString1 >= myString2) << endl;
30     return 0;
31 }

VS2015测试结果：

  

CentOS 

编译

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

测试结果

 

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/huangwenhao/p/11122282.html