-
【C++】string类模拟实现下篇(附完整源码）
1. resize
下面我们来实现一下
resize():resize可以扩容加初始化，我们可以自己指定要初始化的字符，不指定默认填\0。
这里我们实现时需要分几种情况：
第一种情况n < _size():
这里需要要删除数据，只保留前n个，直接把第n个位置置成\0就行了：
第二种情况是n>_size且n在_size和_capacity之间：
第三种情况是n > _capacity:
==这两种情况可以一起实现：
在这里当n > _capacity时reserve()函数会自己扩容
我们来测试一下：
2. 流插入<<和流提取>>重载
2.1 流插入<<重载
在之前的文章中我们提到，我们自己重载的如果想像正常cout打印那样，要把流插入<< 和 流提取>>重载到类外面，避免this指针抢占第一个参数。
注意：这里我们不能使用
out<。
而我们打印string对象是看对应的size 的，size是多大，就打印多少下面我们来测试一下：
2.2 流提取 <<
首先我们先来看一下这样写可不可以：
我们来测试一下：
这里是存在一定错误的。in遇到缓冲区里的空格或者换行的时候，它会认为这是你输入多个值的一个区分，会自动忽略掉它们，不会去提取，所以这里就读不到空格和换行，那循环就不会结束。这里我们用
get接口来解决：
get是istream类的一个成员函数，它一次读取一个字符，就可以提取到空格和换行。我们再来测试一下：
但是如果遇到这种情况呢：
这里还存在一个问题，当string对象原来就有数据，需要把之前的清掉。这里我们实现一个clear接口。再来测试一下：
这里还有最后一个问题：
如果我们输入一个特别长的字符串，那这个地方在不断+=字符的过程中可能会频繁扩容，那我们有没有什么办法可以解决一下呢？
这里开了一个数组，每次先把字符一个个放到数组中，满了的话就+=到s里（以字符串的形式），然后把i置成0，后面继续放数组里。这样做扩容就不会那么频繁了我们再来测试一下：
3. 常见关系运算符重载
我们知道库里string重载了很多关系运算符：
这里我们重点实现几个常的。首先我们来复现
<,我们先考虑使用strcmp来复现:
我们测试一下：
貌似这里没啥问题，那我们再看一种情况：
这里我在字符当中添加了
“\0”程序出错了所以上述代码是有问题的。这里我们用memcpy去解决。
我们再来测试一下：
写好了一个对于其他的我们只要复现就好了：
4. 赋值重载
4.1浅拷贝的默认赋值重载
赋值重载作为类的6个默认成员函数之一，我们不写编译器也会默认生成。但是默认生成的赋值重载也是浅拷贝。
所以：
和拷贝构造一样，如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要自己实现。4.2 深拷贝赋值重载实现
对于赋值重载是有几种情况的：
那这里分情况处理其实有点麻烦所以我们干脆不管哪种情况，我们都直接释放旧空间，然后开新空间拷贝数据：
下面我们来测试一下：
4.3 赋值重载现代写法
这里我们来用一种更加简单的方法实现：
什么意思呢？
举个例子：
这里我们借用拷贝构造拷贝s3,然后再借用swap函数交换s1和tmp。这里还有更简单的写法：
==在这里tmp就是一个临时变量，然后调用swap交换。5. 写时拷贝(了解）
写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1；
当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象是资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。6.源码
6.1 string.h
#includeusing namespace std; namespace w { class string { public : typedef char* iterator; typedef const char* const_iterator; iterator begin() { return _str; } iterator end() { return _str + _size; } const_iterator begin() const { return _str; } const_iterator end() const { return _str + _size; } string(const char* str = "") :_str(new char[strlen(str)+1]) ,_size(strlen(str)) ,_capacity(strlen(str)) { memcpy(_str, str, _size+1); } string(const string& s) { _str = new char[s._capacity + 1]; strcpy(_str, s._str); _size = s._size; _capacity = s._capacity; } void swap(string& s) { std::swap(_str, s._str); std::swap(_size, s._size); std::swap(_capacity, s._capacity); } // string& operator=(const string& s) // { // if (this != &s) // { // char* tmp = new char[s._capacity + 1]; // memcpy(tmp, s._str, s._size+1); // delete[] _str; // _str = tmp; // _size = s._size; // _capacity = s._capacity; // } // return *this; // } // string& operator=(const string& s) // { // if (this != &s) // { // string tmp(s); // std::swap(_str, tmp._str); // std::swap(_size, tmp._size); // std::swap(_capacity, tmp._capacity); // } // return *this; // } string& operator=(string tmp) { swap(tmp); return *this; } ~string() { delete[] _str; _str = nullptr; _size = _capacity = 0; } const char* c_str() const { return _str; } size_t size() const { return _size; } char& operator[](size_t pos) { assert(pos < _size); return _str[pos]; } const char& operator[](size_t pos) const { assert(pos < _size); return _str[pos]; } void reserve(size_t n) { if (n > _capacity) { char* tmp = new char[n + 1]; memcpy(tmp, _str, _size+1); delete[] _str; _str = tmp; _capacity = n; } } void resize(size_t n, char ch = '\0') { if (n < _size) { _size = n; _str[_size] = '\0'; } else { reserve(n); for (size_t i = _size; i < n; i++) { _str[i] = ch; } _size = n; _str[_size] = '\0'; } } void push_back(char ch) { if (_size == _capacity) { // 2倍扩容 reserve(_capacity == 0 ? 4 : _capacity * 2); } _str[_size] = ch; ++_size; _str[_size] = '\0'; } void append(const char* str) { size_t len = strlen(str); if (_size + len > _capacity) { // 至少扩容到_size + len reserve(_size+len); } memcpy(_str + _size, str, len+1); _size += len; } string& operator+=(char ch) { push_back(ch); return *this; } string& operator+=(const char* str) { append(str); return *this; } void insert(size_t pos, size_t n, char ch) { assert(pos <= _size); if (_size +n > _capacity) { // 至少扩容到_size + len reserve(_size + n); } // 添加注释最好 size_t end = _size; while (end >= pos && end != npos) { _str[end + n] = _str[end]; --end; } for (size_t i = 0; i < n; i++) { _str[pos + i] = ch; } _size += n; } void insert(size_t pos, const char* str) { assert(pos <= _size); size_t len = strlen(str); if (_size + len > _capacity) { // 至少扩容到_size + len reserve(_size + len); } // 添加注释最好 size_t end = _size; while (end >= pos && end != npos) { _str[end + len] = _str[end]; --end; } for (size_t i = 0; i < len; i++) { _str[pos + i] = str[i]; } _size += len; } string& erase(size_t pos, size_t len = npos) { assert(pos <= _size); if (len == npos || pos + len >= _size) { _str[pos] = '\0'; _size = pos; _str[_size] = '\0'; } else { size_t end = pos + len; while (end <= _size) { _str[pos++] = _str[end++]; } _size -= len; } return *this; } size_t find(char ch, size_t pos = 0) { assert(pos < _size); for (size_t i = pos; i < _size; i++) { if (_str[i] == ch) { return i; } } return npos; } size_t find(const char* str , size_t pos = 0) { assert(pos < _size); const char* ptr = strstr(_str + pos, str); if (ptr) { return ptr - _str; } else { return npos; } } string substr(size_t pos = 0, size_t len = npos) { assert(pos < _size); size_t n = len; if (len == npos || pos + len > _size) { n = _size - pos; } string tmp; tmp.reserve(n); for (size_t i = pos; i < pos + n; i++) { tmp += _str[i]; } return tmp; } void clear() { _str[0] = '\0'; _size = 0; } bool operator<(const string& s) const { int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size); return ret == 0 ? _size < s._size : ret < 0; } bool operator==(const string& s) const { return _size == s._size && memcmp(_str, s._str, _size) == 0; } bool operator<=(const string& s) const { return *this < s || *this == s; } bool operator>(const string& s) const { return !(*this <= s); } bool operator>=(const string& s) const { return !(*this < s); } bool operator!=(const string& s) const { return !(*this == s); } private : char* _str; size_t _size; size_t _capacity; public: const static size_t npos; }; const size_t string::npos = -1; ostream& operator<<(ostream& out, const string& s) { for (auto ch : s) { out << ch; } return out; } istream& operator>>(istream& in, string& s) { s.clear(); char ch = in.get(); while (ch == ' ' || ch == '\n') { ch = in.get(); } char buff[128]; int i = 0; while (ch != ' ' && ch != '\n') { buff[i++] = ch; if (i == 127) { buff[i] = '\0'; s += buff; i = 0; } ch = in.get(); } if (i != 0) { buff[i] = '\0'; s += buff; } return in; } } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
- 280
- 281
- 282
- 283
- 284
- 285
- 286
- 287
- 288
- 289
- 290
- 291
- 292
- 293
- 294
- 295
- 296
- 297
- 298
- 299
- 300
- 301
- 302
- 303
- 304
- 305
- 306
- 307
- 308
- 309
- 310
- 311
- 312
- 313
- 314
- 315
- 316
- 317
- 318
- 319
- 320
- 321
- 322
- 323
- 324
- 325
- 326
- 327
- 328
- 329
- 330
- 331
- 332
- 333
- 334
- 335
- 336
- 337
- 338
- 339
- 340
- 341
- 342
- 343
- 344
- 345
- 346
- 347
- 348
- 349
- 350
- 351
- 352
- 353
- 354
- 355
- 356
- 357
- 358
- 359
- 360
- 361
- 362
- 363
- 364
- 365
- 366
- 367
- 368
- 369
- 370
- 371
- 372
- 373
- 374
- 375
- 376
- 377
- 378
- 379
- 380
- 381
- 382
- 383
- 384
- 385
- 386
- 387
- 388
- 389
- 390
- 391
- 392
- 393
- 394
- 395
- 396
- 397
- 398
- 399
- 400
- 401
- 402
- 403
- 404
- 405
- 406
- 407
- 408
- 409
- 410
- 411
- 412
- 413
- 414
- 415
6.2 test.cpp
#include "Mystring.h" void test_string1() { w ::string s1("hello world"); cout << s1.c_str() << endl; for (size_t i = 0; i < s1.size(); i++) { cout << s1[i] << " "; } cout << endl; w ::string::iterator it = s1.begin(); while (it != s1.end()) { cout << *it << " "; ++it; } cout <<endl; for (auto ch : s1) { cout << ch <<" "; } cout <<endl; } void test_string2() { w::string s1("hello world"); cout << s1.c_str() << endl; s1.push_back(' '); s1.push_back('#'); s1.append("hello"); cout << s1.c_str() << endl; w::string s2("hello world"); cout << s2.c_str() << endl; s2 += ' '; s2 += '#'; s2 += "hello code"; cout << s2.c_str() << endl; } void test_string3() { w::string s1("helloworld"); cout << s1.c_str() << endl; s1.insert(5, 3, '#'); cout << s1.c_str() << endl; s1.insert(0, 3, '#'); cout << s1.c_str() << endl; w::string s2("helloworld"); s2.insert(5, "%%%%%"); cout << s2.c_str() << endl; } void test_string4() { w::string s1("helloworld"); cout << s1.c_str() << endl; s1.erase(5, 3); cout << s1.c_str() << endl; s1.erase(5, 30); cout << s1.c_str() << endl; s1.erase(2); cout << s1.c_str() << endl; } void test_string5() { w::string s1("helloworld"); cout << s1.find('w',2) << endl; } void test_string6() { w::string s1("hello world"); w::string s2(s1); cout << s1.c_str() << endl; cout << s2.c_str() << endl; } void test_string7() { w::string s("hello world"); s.resize(8); cout << s.c_str() << endl; cout << s << endl; s.resize(13, 'x'); cout << s.c_str() << endl; cout << s << endl; s.resize(20, 'y'); cout << s.c_str() << endl; cout << s << endl; } void test_string8() { w::string s("hello world"); cin >> s; cout << s << endl; } void test_string9() { //string s1("bb"); //string s2("aaa"); //cout << (s1 < s2) << endl; w::string s1("hello"); s1 += '\0'; s1 += "1"; w::string s2("hello"); s2 += '\0'; s2 += "2"; cout << (s1 < s2) << endl; } void test_string10() { w::string s1("hello"); w::string s2(s1); cout << s1 << endl; cout << s2 << endl; w::string s3("xxxxxxxxxxxxx"); s1 = s3; cout << s1 << endl; cout << s3 << endl; } int main() { test_string10(); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
-
相关阅读:
单向链表·初识【c语言】
Qt登录界面
CMMI是什么意思
初阶数据结构学习记录——여덟 二叉树
SOCKS55代理 VS Http代理,如何选择？
stm32f4xx-GPIO
数据结构（六）单向循环链表
Mongodb 副本集名称重命名
JS，函数语法+示例，非常详细！！！
腾讯云服务器初始化
- 原文地址：https://blog.csdn.net/weixin_69423932/article/details/132906636
