9-03 C++ Mystring 改写(2)

最新推荐文章于 2024-10-17 21:05:59 发布
ahang_n
最新推荐文章于 2024-10-17 21:05:59 发布
阅读量202
点赞数 3
文章标签： c++ 算法开发语言
本文链接：https://blog.csdn.net/ahang_n/article/details/141729687
版权
  1 #include <iostream>
  2 #include <cstring>
  3 #include <cstdio>
  4 
  5 class MYstring
  6 {
  7     public:
  8 
  9         //无参构造函数
 10         MYstring()
 11         {
 12             std::cout << "无参构造函数" << std::endl;
 13             ptr = nullptr ;
 14             len = 0;
 15         }
 16 
 17         //有参构造函数
 18         MYstring(const char *s)
 19         {
 20 
 21             std::cout << "有参构造函数" << std::endl;
 22             len = strlen(s);
 23             ptr = (new char[len+1]);
 24             strcpy(ptr,s);
 25         }
 26 
 27         //析构函数
 28         ~MYstring()
 29         {
 30 
 31             std::cout << "析构造函数" << std::endl;
 32             if(nullptr != ptr)
 33             {
 34                 delete []ptr;
 35             }
 36 
 37         }
 38 
 39         //拷贝构造函数
 40         MYstring(const MYstring &str):len(str.len),ptr(new char[len+1])
 41         {
 42             std::cout << "拷贝构造函数" << std::endl;                                                                                                                                                       
 43             strcpy(ptr,str.ptr);
 44         }
 45 
 46         //拷贝赋值函数
 47         MYstring& operator=(const MYstring &N)
 48         {
 49             if(nullptr != this)
 50             {
 51                 len = N.len;
 52                 if(nullptr != ptr)
 53                 {
 54                     delete []ptr;
 55                     ptr = new char[len+1];
 56                 }
 57                 strcpy(ptr,N.ptr);
 58             }
 59             std::cout << "拷贝赋值函数" << std::endl;
 60             return *this;
 61         }
 62         //string+(连接两个字符串对象)
 63         MYstring operator+(const MYstring &R)
 64         {
 65             MYstring N;
 66             N.len = len + R.len;
 67             N.ptr = new char[N.len+1];
 68 
 69             strcpy(N.ptr,ptr);
 70 
 71             strcat(N.ptr,R.ptr);
 72             return N;
 73         }
 74         //string!=(测试运算符左侧的字符串对象是否不等于右侧的字符串对象)
 75         bool operator!=(const MYstring &R)const
 76         {
 77                 if(strcmp(ptr,R.ptr)==0)
 78                 {
 79                     return false;
 80                 }else
 81                 {
 82                     return true;
 83                 }
 84 
 85         }
 86         //string==(测试运算符左侧的字符串对象是否等于右侧的字符串对象)
 87         bool operator==(const MYstring &R)const
 88         {
 89                 if(strcmp(ptr,R.ptr)==0)
 90                 {
 91                     return true;
 92                 }else
 93                 {
 94                     return false;
 95                 }
 96         }
 97         //string<(测试运算符左侧的字符串对象是否小于右侧的字符串对象)
 98         bool operator<(const MYstring &R)const
 99         {
100 
101                 if(strcmp(ptr,R.ptr)<0)
102                 {
103                     return true;
104                 }else
105                 {
106                     return false;
107                 }
108         }
109 
110         //string<=(测试运算符左侧的字符串对象是否小于或等于右侧的字符串对象)
111         bool operator<=(const MYstring &R)const
112         {
113 
114             if(strcmp(ptr,R.ptr)<=0)
115             {
116                 return true;
117             }else
118             {
119                 return false;
120             }
121         }
122 
123         //string>(测试运算符左侧的字符串对象是否大于右侧的字符串对象)
124         bool operator>(const MYstring &R)const
125         {
126 
127                 if(strcmp(ptr,R.ptr)>0)
128                 {
129                     return true;
130                 }else
131                 {
132                     return false;
133                 }
134         }
135 
136         //string>=(测试运算符左侧的字符串对象是否大于或等于右侧的字符串对象)
137         bool operator>=(const MYstring &R)const
138         {
139 
140             if(strcmp(ptr,R.ptr)>=0)
141             {
142                 return true;
143             }else
144             {
145                 return false;
146             }
147         }
148 
149         //show打印ptr的字符串
150         void show()
151         {
152             std::cout << ptr << "\tlen=" << len << std::endl;
153         }
154 
155         //data
156         const char *data()
157         {
158 
159             return ptr;
160         }
161 
162         //size
163         size_t size()
164         {
165             return len;
166         }
167 
168         //empty
169         bool empty()
170         {
171             if(len == 0)
172             {
173                 return true;
174             }else
175             {
176                 return false;
177             }
178         }
179 
180         //at
181         char at(size_t index)
182         {
183             char ch = *(ptr+index-1);
184             if(0>index || index >=len)
185             {
186                 std::cout << "out_of_range" << std::endl;
187             }else
188             {
189                 return ch;
190             }
191         }
192         //string<<(一个模板函数，用于向输出流插入字符串)
193         friend std::ostream& operator<<(std::ostream &L ,const MYstring &R);
194 
195         //string>>(一个模板函数，用于从输入流提取字符串)
196         friend std::istream& operator>>(std::istream &L , MYstring &R);
197     private:
198          char *ptr;
199          int len;
200 
201 
202 };
203 
204 
205 //string<<(一个模板函数，用于向输出流插入字符串)
206 std::ostream& operator<<(std::ostream &L ,const MYstring &R)
207 {
208     L<< R.ptr << "\tlen=" << R.len;
209     return L;
210 }
211 
212 //string>>(一个模板函数，用于从输入流提取字符串)
213 std::istream& operator>>(std::istream &L , MYstring &R)
214 {
215     std::cout << "请输入>>>" << std::endl;
216 
217 
218     char ptr[64]={0};
219     L >> ptr;
220     R.len = strlen(ptr);
221     if(R.ptr!=nullptr || R.ptr==nullptr)
222     {
223         delete []R.ptr;
224         R.ptr = new char[R.len+1];
225     }
226     strcpy(R.ptr,ptr);
227     return L;
228 }
229 
230 int main(int argc, const char *argv[])
231 {
232     //+
233     MYstring T1("qwer");
234     MYstring T2("qwer");
235     MYstring T4("qwer");
236     MYstring T5("awer");
237 
238     MYstring T3 = T1+T2;
239     T3.show();
240 
241     //!=
242     std::cout << "!=: "<< std::boolalpha << (T1!=T2) << std::endl;
243 
244     //==
245     std::cout << "==: "<< std::boolalpha << (T4==T2) << std::endl;
246 
247     //<
248     std::cout << "<: "<< std::boolalpha << (T4<T5) << std::endl;
249 
250     //<=
251     std::cout << "<=: "<< std::boolalpha << (T4<=T2) << std::endl;
252 
253     //<<
254     std::cout << T3 << std::endl;
255 
256     //>
257     std::cout << ">: "<< std::boolalpha << (T5>T4) << std::endl;
258 
259     //>=
260     std::cout << ">=: "<< std::boolalpha << (T4>=T2) << std::endl;
261 
262     //>>
263     MYstring T7;
264     std::cin >> T7;
265     T7.show();
266 
267     std::cout << T1.data() << std::endl;//data()函数返回指向自己的第一个字符的指针
268 
269     std::cout << T1.size() << std::endl;//size()函数返回字符串中现在拥有的字符数
270 
271     std::cout << std::boolalpha << T1.empty() << std::endl;//如果字符串为空则empty()返回真(true)，否则返回假(false)
272 
273     std::cout << T1.at(3) << std::endl;//at(J)函数返回一个引用，指向在index位置的字符.
274                                                            //如果index不在字符串范围内, at()将报告"out of range"错误，
275                                                            //并抛出out_of_range异常
276 
277 
278 
279     return 0;
280 }