• ＜string类模拟实现＞——《C++初阶》

    为实现祖国统一而奋斗！为实现社会主义现代化而奋斗！为实现中华民族复兴而奋斗！
                                                                         ——By  一名社会主义建设积极分子     

    目录

    一、实现概括：

    1.先实现一个简单的string，只考虑资源管理深浅拷贝问题（暂不考虑增删查改）

          对于浅拷贝的两个问题：

    2. string完善的增、删、查、改、使用的string 

    完整源码及注释：

    后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！                                     ——By 作者：新晓·故知 

    一、实现概括：

    模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。根据string的底层原理，实现模拟string使其与库里的string（即std::string）具有相似的功能。由于库里的string类的功能较多，这里只模拟实现了较为常用的功能，

    例如：iterator(模拟的string迭代器）、push_back、insert、reserve、resize、find、erase、c_str、ostream重载、istream重载、赋值运算符重载、[ ]重载、append以及比较运算符的重载等，甚至深拷贝构造函数的现代写法（资本写法）、赋值运算符重载的现代写法（资本写法）等。std::string中的功能较多，学习使用可登录cplusplus官网，参见string文档。

    1.先实现一个简单的string，只考虑资源管理深浅拷贝问题（暂不考虑增删查改）

    （1）string.h

    （2）test.cpp:

     

    深拷贝：

    深拷贝：使得值相同，空间大小相同，但空间地址不同

     

    对于浅拷贝的两个问题：

    1.多次析构同一空间：引用计数，即最后一个拷贝构造的对象是否资源

    2.一个对象修改会影响其他对象：做深拷贝，写时拷贝

    2. string完善的增、删、查、改、使用的string 

     string.h:

     test.cpp:

    完整源码及注释：

    （1）string.h:

    1. #pragma once
    2. #define _CRT_SECURE_NO_WARNINGS
    3.  
    4. #include
    5. #include
    6. #include
    7. using namespace std;
    8. //模拟实现string
    9.  
    10. //1.先实现一个简单的string，只考虑资源管理深浅拷贝问题
    11. //自定义命名空间，防止与库中的冲突
    12. //namespace my
    13. //{
    14. //	//先实现一个简单的string，只考虑资源管理深浅拷贝问题
    15. //	//暂不考虑增删查改
    16. //	class string
    17. //	{
    18. //	public:
    19. //		//构造函数
    20. //		string(const char* str)
    21. //			:_str(new char[strlen(str) + 1])  
    22. //		{
    23. //			//不能直接 _str=str; 因为会权限放大
    24. //			strcpy(_str, str);  //也拷贝了\0
    25. //		}
    26. //		//深拷贝函数 s2(s1)
    27. //		string(const string& s)
    28. //			:_str(new char[strlen(s._str) + 1])
    29. //		{
    30. //			strcpy(_str, s._str);
    31. //		}
    32. //		~string()
    33. //		{
    34. //			if (_str)
    35. //			{
    36. //				delete[] _str;
    37. //			}
    38. //		}
    39. //		//s1=s3  ——>s1.operator=(&s1,s3)
    40. //		//赋值重载函数
    41. //		string& operator = (const string& s)
    42. //		{
    43. //			if (this != &s)  //解决s1=s1，自己释放自己的空间
    44. //			{
    45. //				//先删除，再开辟赋值
    46. //				//如果new开辟失败，那s1作为原始数据被删除
    47. //				/*delete[] _str;
    48. //				_str = new char[strlen(s._str) + 1];
    49. //				strcpy(_str, s._str);*/
    50. //				//先保存，再开辟赋值
    51. //				char* tmp = new char[strlen(s._str) + 1];
    52. //				strcpy(tmp, s._str);
    53. //				delete[] _str;
    54. //				_str = tmp;
    55. //			}
    56. //		    return *this;
    57. //		}
    58. //		//c_str是string中的一个函数，具体详见string文档
    59. //		//获取等效的字符串
    60. //		const char* c_str() const
    61. //		{
    62. //			return _str;
    63. //		}
    64. //		//重载[]
    65. //		char& operator[](size_t pos)
    66. //		{
    67. //			assert(pos < strlen(_str));
    68. //			return _str[pos];
    69. //		}
    70. //		//计算字符串大小
    71. //		size_t size()
    72. //		{
    73. //			return strlen(_str);
    74. //		}
    75. //          
    76. //	private:
    77. //		char* _str;
    78. //
    79. //	};
    80. //}
    81.  
    82. //
    83. 2.string完善的增删查改和使用的string
    84. //namespace my
    85. //{
    86. //	class string
    87. //	{
    88. //	public:
    89. //		构造函数
    90. //		//string(const char* str)
    91. //		//	:_size(strlen(str))
    92. //		//	,_capacity(_size)
    93. //		//{
    94. //		//	//要注意初始化顺序，取决于类的声明顺序
    95. //		//	_str = new char[_capacity + 1];
    96. //		//	//不能直接 _str=str; 因为会权限放大
    97. //		//	strcpy(_str, str);  //也拷贝了\0
    98. //		//}
    99. //		默认构造函数(无参使用的）
    100. //		//string()
    101. //		//	:_size(0)
    102. //		//	,_capacity(0)
    103. //		//{
    104. //		//	_str = new char[1];  //将_str初始化为空字符串，string库就是这种做法
    105. //		//	_str[0] = '0';
    106. //		//}
    107. //		
    108. //		//默认构造函数（全缺省版）
    109. //		string(const char* str="") // ""、"\0"均可以，'\0'是字符
    110. //			:_size(strlen(str))
    111. //			, _capacity(_size)
    112. //		{
    113. //			//要注意初始化顺序，取决于类的声明顺序
    114. //			_str = new char[_capacity + 1];
    115. //			//不能直接 _str=str; 因为会权限放大
    116. //			strcpy(_str, str);  //也拷贝了\0
    117. //		}
    118. //		深拷贝函数版本1 s2(s1)
    119. //		//string(const string& s)
    120. //		//	:_str(new char[strlen(s._str) + 1])
    121. //		//{
    122. //		//	strcpy(_str, s._str);
    123. //		//}
    124. //	    //深拷贝函数版本2 s2(s1)
    125. //		string(const string& s)
    126. //			:_size(strlen(s._str))
    127. //			,_capacity(_size)
    128. //		{
    129. //			_str=new char[_capacity + 1];
    130. //			strcpy(_str, s._str);
    131. //		}
    132. //		
    133. //		//析构函数
    134. //		~string()
    135. //		{
    136. //			if (_str)
    137. //			{
    138. //				delete[] _str;
    139. //			}
    140. //		}
    141. //		//s1=s3  ——>s1.operator=(&s1,s3)
    142. //		//赋值重载函数
    143. //		string& operator = (const string& s)
    144. //		{
    145. //			if (this != &s)  //解决s1=s1，自己释放自己的空间
    146. //			{
    147. //				//先保存，再开辟赋值
    148. //				char* tmp = new char[s._capacity + 1];
    149. //				strcpy(tmp, s._str);
    150. //				delete[] _str;
    151. //				_str = tmp;
    152. //				_size = s._size;
    153. //				_capacity = s._capacity;
    154. //			}
    155. //			return *this;
    156. //		}
    157. //		//c_str是string中的一个函数，具体详见string文档
    158. //		//获取等效的字符串
    159. //		const char* c_str() const
    160. //		{
    161. //			return _str;
    162. //		}
    163. //		//重载[]
    164. //		char& operator[](size_t pos)
    165. //		{
    166. //			assert(pos < _size);
    167. //			return _str[pos];
    168. //		}
    169. //		//重载[] const 提供两个版本的重载[] ,普通对象和const对象都可以调用
    170. //		const char& operator[](size_t pos) const
    171. //		{
    172. //			assert(pos < _size);
    173. //			return _str[pos];
    174. //		}
    175. //		//计算字符串大小
    176. //		//size_t size(const string* this)
    177. //		size_t size() const
    178. //		{
    179. //			return _size;
    180. //		}
    181. //
    182. //		size_t capacity() const
    183. //		{
    184. //			return _capacity;
    185. //		}
    186. //		尾插数据
    187. //		//void push_back(char ch)
    188. //		//{
    189. //		//	if (_size == _capacity) //其实为_capacity开辟的多一个为\0存储的空间，但那个不参与比较
    190. //		//	{
    191. //		//		char* tmp = new char[_capacity * 2 + 1];
    192. //		//		strcpy(tmp, _str);
    193. //		//		delete[] _str;
    194. //		//		_str = tmp;
    195. //		//		_capacity *= 2;
    196. //		//	}
    197. //		//	_str[_size] = ch;
    198. //		//	++_size;
    199. //		//	_str[_size] = '\0';
    200. //		//}
    201. //		
    202. //		//尾插也可以使用+=(附用push_back)
    203. //		string& operator+=(char ch) 
    204. //		{
    205. //			push_back(ch);
    206. //			return *this;
    207. //		}
    208. //		//预留扩容
    209. //		void reserve(size_t n)
    210. //		{
    211. //			if (n > _capacity)
    212. //			{
    213. //				char* tmp = new char[n + 1];
    214. //				strcpy(tmp, _str);
    215. //				delete[] _str;
    216. //				_str = tmp;
    217. //				_capacity = n;
    218. //			}
    219. //		}
    220. //		//尾插数据——附用reserve
    221. //		void push_back(char ch)
    222. //		{
    223. //			//if (_size == _capacity) //其实为_capacity开辟的多一个为\0存储的空间，但那个不参与比较
    224. //			//{
    225. //			//	//reserve( _capacity * 2);若_capacity为0，则出现bug
    226. //			//	reserve(_capacity==0 ? 4 : _capacity * 2);
    227. //			//}
    228. //			//_str[_size] = ch;
    229. //			//++_size;
    230. //			//_str[_size] = '\0';
    231. //			
    232. //			//附用insert
    233. //			insert(_size, ch);
    234. //		}
    235. //		//追加到字符
    236. //		void append(const char*str)
    237. //		{
    238. //			/*size_t len = _size + strlen(str);
    239. //			if (len > _capacity)
    240. //			{
    241. //				reserve(len);
    242. //			}
    243. //			strcpy(_str + _size, str);
    244. //			_size = len;*/
    245. //			//附用insert
    246. //			insert(_size, str);
    247. //		}
    248. //		//尾插也可以使用+=(附用append)
    249. //		string& operator+=(const char* str) 
    250. //		{
    251. //			append(str);
    252. //			return *this;
    253. //		}
    254. //		//扩空间+初始化
    255. //		//删除部分数据，保留前n个
    256. //		void resize(size_t n, char ch = '\0')
    257. //		{
    258. //			//考虑到内存对齐，可能开辟的空间与n有些许微小出入
    259. //			if (n < _size)
    260. //			{
    261. //				_size = n;
    262. //				_str[_size] = '\0';
    263. //			}
    264. //			else
    265. //			{
    266. //				if (n > _capacity)
    267. //				{
    268. //					reserve(n);
    269. //				}
    270. //				for (size_t i = _size; i < n; ++i)
    271. //				{
    272. //					_str[i] = ch;
    273. //				}
    274. //				_size = n;
    275. //				_str[_size] = '\0';
    276. //			}
    277. //		}
    278. //		
    279. //		//迭代器
    280. //		typedef char* iterator;
    281. //		typedef const char* const_iterator;
    282. //
    283. //		iterator begin()
    284. //		{
    285. //			return _str;
    286. //		}
    287. //		iterator end()
    288. //		{
    289. //			return _str + _size;
    290. //		}
    291. //		const_iterator begin() const
    292. //		{
    293. //			return _str;
    294. //		}
    295. //		const_iterator end() const
    296. //		{
    297. //			return _str + _size;
    298. //		}
    299. //		//头插数据
    300. //		//持续头插，不如尾插逆置
    301. //		//插入字符
    302. //		string& insert(size_t pos, char ch)
    303. //		{
    304. //			assert(pos <= _size); //pos = _size相当于尾插
    305. //			if (_size == _capacity)
    306. //			{
    307. //				reserve(_capacity == 0 ? 4 : _capacity * 2);
    308. //			}
    309. //			//size_t end = _size; 
    310. //			//while (end >= pos)  //--end会造成负数，而--end是size_t类型
    311. //			//{
    312. //			//	_str[end + 1] = _str[end];
    313. //			//	--end;
    314. //			//}
    315. //			解决1：强转类型
    316. //			//int end = _size;
    317. //			//while (end >=(int) pos)  //--end会造成负数，而--end是size_t类型
    318. //			//{
    319. //			//	_str[end + 1] = _str[end];
    320. //			//	--end;
    321. //			//}
    322. //			//解决2：修改end位置
    323. //			size_t end = _size+1;
    324. //			while (end > pos)  //end等于0就停止
    325. //			{
    326. //				_str[end ] = _str[end-1];
    327. //				--end;
    328. //			}
    329. //			_str[pos] = ch;
    330. //			_size ++;
    331. //			return *this;
    332. //		}
    333. //		//插入字符串
    334. //		string& insert(size_t pos,const char* str)
    335. //		{
    336. //			assert(pos <= _size);
    337. //			size_t len=strlen(str);
    338. //			if (_size + len > _capacity)
    339. //			{
    340. //				reserve(_size + len);
    341. //			}
    342. //			size_t end = _size + len;
    343. //			while (end > pos + len - 1) //或者while (end >= pos + len) ,但pos、len均为0就有问题
    344. //			{
    345. //				_str[end] = _str[end - len];
    346. //				--end;
    347. //			}
    348. //			strncpy(_str + pos, str, len);  //不能使用strcpy
    349. //			_size += len;
    350. //			return *this;
    351. //		}
    352. //		//删除
    353. //		string& erase(size_t pos, size_t len=npos)
    354. //		{
    355. //			assert(pos < _size);
    356. //			if (len == npos || pos + len >= _size)
    357. //			{
    358. //				_str[pos] = '\0';
    359. //				_size = pos;
    360. //			}
    361. //			else
    362. //			{
    363. //				size_t begin = pos + len;
    364. //				while (begin <= _size)
    365. //				{
    366. //					_str[begin - len] = _str[begin];
    367. //					++begin;
    368. //				}
    369. //				_size -= len;
    370. //			}
    371. //			return *this;
    372. //		}
    373. //		//查找字符
    374. //		//The position of the first character of the first match.
    375. //		//If no matches were found, the function returns string::npos.
    376. //		size_t find(char ch,size_t pos=0)
    377. //		{
    378. //			for (; pos < _size; ++pos)
    379. //			{
    380. //				if (_str[pos] == ch)
    381. //				{
    382. //					return pos;
    383. //				}
    384. //			}
    385. //			return npos;
    386. //		}
    387. //		//查找字符串
    388. //		size_t find(const char*str, size_t pos = 0)
    389. //		{
    390. //			const char* p = strstr(_str + pos, str); //strstr暴力算法
    391. //			if (p == nullptr)
    392. //			{
    393. //				return npos;
    394. //			}
    395. //			else
    396. //			{
    397. //				return p - _str;
    398. //			}
    399. //		}
    400. //		void clear()
    401. //		{
    402. //			_str[0] = '\0';
    403. //			_size = 0;
    404. //		}
    405. //	private:
    406. //		char* _str;
    407. //		size_t _size;     //有效字符个数，不包含\0
    408. //		size_t _capacity; //实际存储的有效字符的空间
    409. //		const static size_t npos;
    410. //
    411. //	};
    412. //	//定义
    413. //	const size_t string::npos = -1;
    414. //	//这里不是成员函数，不在类里
    415. //	//运算符<重载
    416. //	bool operator<(const string& s1, const string& s2)
    417. //	{
    418. //		return strcmp(s1.c_str(), s2.c_str()) < 0;
    419. //	}
    420. //	//运算符==重载
    421. //	bool operator==(const string& s1, const string& s2)
    422. //	{
    423. //		return strcmp(s1.c_str(), s2.c_str()) == 0;
    424. //	}
    425. //	//运算符<=重载
    426. //	bool operator<=(const string& s1, const string& s2)
    427. //	{
    428. //		return s1 < s2 || s1 == s2;
    429. //	}
    430. //	//运算符>重载 (附用<=实现)
    431. //	bool operator>(const string& s1, const string& s2)
    432. //	{
    433. //		return !(s1 <= s2);
    434. //	}
    435. //	//运算符>=重载 (附用<实现)
    436. //	bool operator>=(const string& s1, const string& s2)
    437. //	{
    438. //		return !(s1 < s2);
    439. //	}
    440. //	//运算符!=重载 (附用==实现)
    441. //	bool operator!=(const string& s1, const string& s2)
    442. //	{
    443. //		return !(s1 == s2);
    444. //	}
    445. //	//流运算符重载
    446. //	ostream& operator<<(ostream& out, const string& s)
    447. //	{
    448. //		//out << s.c_str(); //无法打印不可见字符\0
    449. //		for (auto ch : s)
    450. //		{
    451. //			out << ch;
    452. //		}
    453. //		return out;
    454. //	}
    455. //	istream& operator>>(istream& in,  string& s)
    456. //	{
    457. //		//s.clear();
    458. //		//char ch;
    459. //		in >> ch;
    460. //		//ch = in.get();
    461. //		//while (ch != ' ' && ch != '\n')
    462. //		//{
    463. //		//	s += ch;
    464. //		//	//in >> ch;
    465. //		//	ch = in.get();
    466. //		//}
    467. //		//return in;
    468. //		//优化
    469. //		s.clear();
    470. //		char ch;
    471. //		ch = in.get();
    472. //		char buff[128] = { '\0' };
    473. //		size_t i = 0;
    474. //		while (ch != ' ' && ch != '\n')
    475. //		{
    476. //			buff[i++] = ch;
    477. //			if (i == 127)
    478. //			{
    479. //				s += buff;
    480. //				memset(buff, '\0', 128);
    481. //				i = 0;
    482. //			}
    483. //			ch = in.get();
    484. //		}
    485. //		s += buff;
    486. //		return in;
    487. //	}
    488. //	//getline
    489. //
    490. //}
    491.  
    492. //3.string完善的增删查改和使用的string(现代写法）
    493. namespace my
    494. {
    495. 	class string
    496. 	{
    497. 	public:
    498. 		构造函数
    499. 		//string(const char* str)
    500. 		//	:_size(strlen(str))
    501. 		//	,_capacity(_size)
    502. 		//{
    503. 		//	//要注意初始化顺序，取决于类的声明顺序
    504. 		//	_str = new char[_capacity + 1];
    505. 		//	//不能直接 _str=str; 因为会权限放大
    506. 		//	strcpy(_str, str);  //也拷贝了\0
    507. 		//}
    508. 		默认构造函数(无参使用的）
    509. 		//string()
    510. 		//	:_size(0)
    511. 		//	,_capacity(0)
    512. 		//{
    513. 		//	_str = new char[1];  //将_str初始化为空字符串，string库就是这种做法
    514. 		//	_str[0] = '0';
    515. 		//}
    516.  
    517. 		//默认构造函数（全缺省版）
    518. 		string(const char* str = "") // ""、"\0"均可以，'\0'是字符
    519. 			:_size(strlen(str))
    520. 			, _capacity(_size)
    521. 		{
    522. 			//要注意初始化顺序，取决于类的声明顺序
    523. 			_str = new char[_capacity + 1];
    524. 			//不能直接 _str=str; 因为会权限放大
    525. 			strcpy(_str, str);  //也拷贝了\0
    526. 		}
    527. 		深拷贝函数版本1 s2(s1)
    528. 		//string(const string& s)
    529. 		//	:_str(new char[strlen(s._str) + 1])
    530. 		//{
    531. 		//	strcpy(_str, s._str);
    532. 		//}
    533. 		深拷贝函数版本2 s2(s1) //传统写法:本分实现，自劳
    534. 		//string(const string& s)
    535. 		//	:_size(strlen(s._str))
    536. 		//	, _capacity(_size)
    537. 		//{
    538. 		//	_str = new char[_capacity + 1];
    539. 		//	strcpy(_str, s._str);
    540. 		//}
    541. 		//深拷贝函数版本3 s2(s1) //现代写法:剥削行为，借他人之手，行私利，但简单
    542. 		//tmp去调用构造函数:s1->s2:构造函数->拷贝构造函数->构造函数->swap
    543. 		//tmp->s2
    544. 		void swap(string& s)
    545. 		{
    546. 			//库里的swap,可交换任意类型
    547. 			std::swap(_str, s._str);
    548. 			std::swap(_size, s._size);
    549. 			std::swap(_capacity, s._capacity);
    550. 		}
    551. 		string(const string& s)
    552. 			:_str(nullptr)
    553. 			, _size(0)
    554. 			, _capacity(0)
    555. 		{
    556. 			string tmp(s._str); //tmp是局部对象，出作用域会调用析构函数
    557. 			/*swap(_str, tmp._str);
    558. 			swap(_size, tmp._size);
    559. 			swap(_capacity, tmp._capacity);*/
    560. 			swap(tmp);
    561. 		}
    562.  
    563. 		//析构函数
    564. 		~string()
    565. 		{
    566. 			if (_str)
    567. 			{
    568. 				delete[] _str;
    569. 			}
    570. 		}
    571. 		//s1=s3  ——>s1.operator=(&s1,s3)
    572. 		赋值重载函数--版本1 传统写法
    573. 		//string& operator = (const string& s)
    574. 		//{
    575. 		//	if (this != &s)  //解决s1=s1，自己释放自己的空间
    576. 		//	{
    577. 		//		//先保存，再开辟赋值
    578. 		//		char* tmp = new char[s._capacity + 1];
    579. 		//		strcpy(tmp, s._str);
    580. 		//		delete[] _str;
    581. 		//		_str = tmp;
    582. 		//		_size = s._size;
    583. 		//		_capacity = s._capacity;
    584. 		//	}
    585. 		//	return *this;
    586. 		//}
    587. 		赋值重载函数--版本2 现代写法
    588. 		//string& operator = (const string& s)
    589. 		//{
    590. 		//	if (this != &s)  //解决s1=s1，自己释放自己的空间
    591. 		//	{
    592. 		//		string tmp(s._str);
    593. 		//		swap(tmp);
    594. 		//	}
    595. 		//	return *this;
    596. 		//}
    597. 		赋值重载函数--版本3 现代写法
    598. 		string& operator = (string s) //传值传参，引用返回
    599. 		{
    600. 			swap(s);
    601. 			return *this;
    602. 		}
    603. 		//c_str是string中的一个函数，具体详见string文档
    604. 		//获取等效的字符串
    605. 		const char* c_str() const
    606. 		{
    607. 			return _str;
    608. 		}
    609. 		//重载[]
    610. 		char& operator[](size_t pos)
    611. 		{
    612. 			assert(pos < _size);
    613. 			return _str[pos];
    614. 		}
    615. 		//重载[] const 提供两个版本的重载[] ,普通对象和const对象都可以调用
    616. 		const char& operator[](size_t pos) const
    617. 		{
    618. 			assert(pos < _size);
    619. 			return _str[pos];
    620. 		}
    621. 		//计算字符串大小
    622. 		//size_t size(const string* this)
    623. 		size_t size() const
    624. 		{
    625. 			return _size;
    626. 		}
    627.  
    628. 		size_t capacity() const
    629. 		{
    630. 			return _capacity;
    631. 		}
    632. 		尾插数据
    633. 		//void push_back(char ch)
    634. 		//{
    635. 		//	if (_size == _capacity) //其实为_capacity开辟的多一个为\0存储的空间，但那个不参与比较
    636. 		//	{
    637. 		//		char* tmp = new char[_capacity * 2 + 1];
    638. 		//		strcpy(tmp, _str);
    639. 		//		delete[] _str;
    640. 		//		_str = tmp;
    641. 		//		_capacity *= 2;
    642. 		//	}
    643. 		//	_str[_size] = ch;
    644. 		//	++_size;
    645. 		//	_str[_size] = '\0';
    646. 		//}
    647.  
    648. 		//尾插也可以使用+=(附用push_back)
    649. 		string& operator+=(char ch)
    650. 		{
    651. 			push_back(ch);
    652. 			return *this;
    653. 		}
    654. 		//预留扩容
    655. 		void reserve(size_t n)
    656. 		{
    657. 			if (n > _capacity)
    658. 			{
    659. 				char* tmp = new char[n + 1];
    660. 				strcpy(tmp, _str);
    661. 				delete[] _str;
    662. 				_str = tmp;
    663. 				_capacity = n;
    664. 			}
    665. 		}
    666. 		//尾插数据——附用reserve
    667. 		void push_back(char ch)
    668. 		{
    669. 			//if (_size == _capacity) //其实为_capacity开辟的多一个为\0存储的空间，但那个不参与比较
    670. 			//{
    671. 			//	//reserve( _capacity * 2);若_capacity为0，则出现bug
    672. 			//	reserve(_capacity==0 ? 4 : _capacity * 2);
    673. 			//}
    674. 			//_str[_size] = ch;
    675. 			//++_size;
    676. 			//_str[_size] = '\0';
    677.  
    678. 			//附用insert
    679. 			insert(_size, ch);
    680. 		}
    681. 		//追加到字符
    682. 		void append(const char* str)
    683. 		{
    684. 			/*size_t len = _size + strlen(str);
    685. 			if (len > _capacity)
    686. 			{
    687. 				reserve(len);
    688. 			}
    689. 			strcpy(_str + _size, str);
    690. 			_size = len;*/
    691. 			//附用insert
    692. 			insert(_size, str);
    693. 		}
    694. 		//尾插也可以使用+=(附用append)
    695. 		string& operator+=(const char* str)
    696. 		{
    697. 			append(str);
    698. 			return *this;
    699. 		}
    700. 		//扩空间+初始化
    701. 		//删除部分数据，保留前n个
    702. 		void resize(size_t n, char ch = '\0')
    703. 		{
    704. 			//考虑到内存对齐，可能开辟的空间与n有些许微小出入
    705. 			if (n < _size)
    706. 			{
    707. 				_size = n;
    708. 				_str[_size] = '\0';
    709. 			}
    710. 			else
    711. 			{
    712. 				if (n > _capacity)
    713. 				{
    714. 					reserve(n);
    715. 				}
    716. 				for (size_t i = _size; i < n; ++i)
    717. 				{
    718. 					_str[i] = ch;
    719. 				}
    720. 				_size = n;
    721. 				_str[_size] = '\0';
    722. 			}
    723. 		}
    724.  
    725. 		//迭代器
    726. 		typedef char* iterator;
    727. 		typedef const char* const_iterator;
    728.  
    729. 		iterator begin()
    730. 		{
    731. 			return _str;
    732. 		}
    733. 		iterator end()
    734. 		{
    735. 			return _str + _size;
    736. 		}
    737. 		const_iterator begin() const
    738. 		{
    739. 			return _str;
    740. 		}
    741. 		const_iterator end() const
    742. 		{
    743. 			return _str + _size;
    744. 		}
    745. 		//头插数据
    746. 		//持续头插，不如尾插逆置
    747. 		//插入字符
    748. 		string& insert(size_t pos, char ch)
    749. 		{
    750. 			assert(pos <= _size); //pos = _size相当于尾插
    751. 			if (_size == _capacity)
    752. 			{
    753. 				reserve(_capacity == 0 ? 4 : _capacity * 2);
    754. 			}
    755. 			//size_t end = _size; 
    756. 			//while (end >= pos)  //--end会造成负数，而--end是size_t类型
    757. 			//{
    758. 			//	_str[end + 1] = _str[end];
    759. 			//	--end;
    760. 			//}
    761. 			解决1：强转类型
    762. 			//int end = _size;
    763. 			//while (end >=(int) pos)  //--end会造成负数，而--end是size_t类型
    764. 			//{
    765. 			//	_str[end + 1] = _str[end];
    766. 			//	--end;
    767. 			//}
    768. 			//解决2：修改end位置
    769. 			size_t end = _size + 1;
    770. 			while (end > pos)  //end等于0就停止
    771. 			{
    772. 				_str[end] = _str[end - 1];
    773. 				--end;
    774. 			}
    775. 			_str[pos] = ch;
    776. 			_size++;
    777. 			return *this;
    778. 		}
    779. 		//插入字符串
    780. 		string& insert(size_t pos, const char* str)
    781. 		{
    782. 			assert(pos <= _size);
    783. 			size_t len = strlen(str);
    784. 			if (_size + len > _capacity)
    785. 			{
    786. 				reserve(_size + len);
    787. 			}
    788. 			size_t end = _size + len;
    789. 			while (end > pos + len - 1) //或者while (end >= pos + len) ,但pos、len均为0就有问题
    790. 			{
    791. 				_str[end] = _str[end - len];
    792. 				--end;
    793. 			}
    794. 			strncpy(_str + pos, str, len);  //不能使用strcpy
    795. 			_size += len;
    796. 			return *this;
    797. 		}
    798. 		//删除
    799. 		string& erase(size_t pos, size_t len = npos)
    800. 		{
    801. 			assert(pos < _size);
    802. 			if (len == npos || pos + len >= _size)
    803. 			{
    804. 				_str[pos] = '\0';
    805. 				_size = pos;
    806. 			}
    807. 			else
    808. 			{
    809. 				size_t begin = pos + len;
    810. 				while (begin <= _size)
    811. 				{
    812. 					_str[begin - len] = _str[begin];
    813. 					++begin;
    814. 				}
    815. 				_size -= len;
    816. 			}
    817. 			return *this;
    818. 		}
    819. 		//查找字符
    820. 		//The position of the first character of the first match.
    821. 		//If no matches were found, the function returns string::npos.
    822. 		size_t find(char ch, size_t pos = 0)
    823. 		{
    824. 			for (; pos < _size; ++pos)
    825. 			{
    826. 				if (_str[pos] == ch)
    827. 				{
    828. 					return pos;
    829. 				}
    830. 			}
    831. 			return npos;
    832. 		}
    833. 		//查找字符串
    834. 		size_t find(const char* str, size_t pos = 0)
    835. 		{
    836. 			const char* p = strstr(_str + pos, str); //strstr暴力算法
    837. 			if (p == nullptr)
    838. 			{
    839. 				return npos;
    840. 			}
    841. 			else
    842. 			{
    843. 				return p - _str;
    844. 			}
    845. 		}
    846. 		void clear()
    847. 		{
    848. 			_str[0] = '\0';
    849. 			_size = 0;
    850. 		}
    851. 	private:
    852. 		char* _str;
    853. 		size_t _size;     //有效字符个数，不包含\0
    854. 		size_t _capacity; //实际存储的有效字符的空间
    855. 		const static size_t npos;
    856.  
    857. 	};
    858. 	//定义
    859. 	const size_t string::npos = -1;
    860. 	//这里不是成员函数，不在类里
    861. 	//运算符<重载
    862. 	bool operator<(const string& s1, const string& s2)
    863. 	{
    864. 		return strcmp(s1.c_str(), s2.c_str()) < 0;
    865. 	}
    866. 	//运算符==重载
    867. 	bool operator==(const string& s1, const string& s2)
    868. 	{
    869. 		return strcmp(s1.c_str(), s2.c_str()) == 0;
    870. 	}
    871. 	//运算符<=重载
    872. 	bool operator<=(const string& s1, const string& s2)
    873. 	{
    874. 		return s1 < s2 || s1 == s2;
    875. 	}
    876. 	//运算符>重载 (附用<=实现)
    877. 	bool operator>(const string& s1, const string& s2)
    878. 	{
    879. 		return !(s1 <= s2);
    880. 	}
    881. 	//运算符>=重载 (附用<实现)
    882. 	bool operator>=(const string& s1, const string& s2)
    883. 	{
    884. 		return !(s1 < s2);
    885. 	}
    886. 	//运算符!=重载 (附用==实现)
    887. 	bool operator!=(const string& s1, const string& s2)
    888. 	{
    889. 		return !(s1 == s2);
    890. 	}
    891. 	//流运算符重载
    892. 	ostream& operator<<(ostream& out, const string& s)
    893. 	{
    894. 		//out << s.c_str(); //无法打印不可见字符\0
    895. 		for (auto ch : s)
    896. 		{
    897. 			out << ch;
    898. 		}
    899. 		return out;
    900. 	}
    901. 	istream& operator>>(istream& in, string& s)
    902. 	{
    903. 		//s.clear();
    904. 		//char ch;
    905. 		in >> ch;
    906. 		//ch = in.get();
    907. 		//while (ch != ' ' && ch != '\n')
    908. 		//{
    909. 		//	s += ch;
    910. 		//	//in >> ch;
    911. 		//	ch = in.get();
    912. 		//}
    913. 		//return in;
    914. 		//优化
    915. 		s.clear();
    916. 		char ch;
    917. 		ch = in.get();
    918. 		char buff[128] = { '\0' };
    919. 		size_t i = 0;
    920. 		while (ch != ' ' && ch != '\n')
    921. 		{
    922. 			buff[i++] = ch;
    923. 			if (i == 127)
    924. 			{
    925. 				s += buff;
    926. 				memset(buff, '\0', 128);
    927. 				i = 0;
    928. 			}
    929. 			ch = in.get();
    930. 		}
    931. 		s += buff;
    932. 		return in;
    933. 	}
    934. 	//getline
    935.  
    936. }
    937. //类型转换函数
    938. //atoi C
    939. //itoa C
    940. //stoi C++11
    941. //to_string

    （2）test.cpp:

    1. #include "string.h"
    2. //1.基本初始化测试
    3. void TestString1()
    4. {
    5. 	my::string s1("hello,world");
    6. 	cout << s1.c_str() << endl;
    7. 	//修改测试
    8. 	s1[0] = 'x';  //s1.operator[](0)='x';
    9. 	cout << s1.c_str() << endl;
    10. 	//读取测试
    11. 	for (size_t i = 0; i < s1.size(); ++i)
    12. 	{
    13. 		cout << s1[i] << " ";
    14. 	}
    15. 	cout << endl;
    16. }
    17. //2.浅拷贝及其问题测试
    18. void TestString2()
    19. {
    20. 	//浅拷贝带来的问题：
    21. 	//1.析构两次，程序崩溃 2.修改一个值，另一个也被改变
    22. 	my::string s1("hello,world");
    23. 	my::string s2(s1);  //调用拷贝构造函数
    24. 	cout << s1.c_str() << endl;
    25. 	cout << s2.c_str() << endl;
    26. }
    27. //3.深拷贝测试
    28. void TestString3()
    29. {
    30. 	//深拷贝：使得值相同，空间大小相同，但空间地址不同
    31. 	my::string s1("hello,world");
    32. 	my::string s2(s1);            //调用深拷贝构造函数
    33. 	cout << s1.c_str() << endl;
    34. 	cout << s2.c_str() << endl;
    35.  
    36. 	s1[0] = 'x';
    37. 	cout << s1.c_str() << endl;
    38. 	cout << s2.c_str() << endl;
    39. }
    40. //4.赋值重载测试
    41. void TestString4()
    42. {
    43. 	//赋值面临的问题与浅拷贝相似
    44. 	my::string s1("hello,world");
    45. 	my::string s2(s1);              //调用深拷贝构造函数
    46. 	my::string s3("qqqqqqqqqq");
    47. 	s1 = s3;       //赋值
    48.  
    49. 	cout << s1.c_str() << endl;
    50. 	cout << s2.c_str() << endl;
    51. 	cout << s3.c_str() << endl;
    52. }
    53. //int main()
    54. //{
    55. //	//TestString1();
    56. //	//TestString2();
    57. //	//TestString3();
    58. //	TestString4();
    59. //	//对于new的异常捕获
    60. //	try
    61. //	{
    62. //		TestString4();
    63. //	}
    64. //	catch (const exception& e)
    65. //	{
    66. //		cout << e.what() << endl;
    67. //	}
    68. //	return 0;
    69. //}
    70.  
    71. //5.增删查改测试
    72. void TestString5()
    73. {
    74. 	my::string s1("hello,world");
    75. 	cout << s1.c_str() << endl;
    76. 	my::string s2;  
    77. 	cout << s2.c_str() << endl;
    78. }
    79. //6.尾插测试+扩容测试
    80. void TestString6()
    81. {
    82. 	//my::string s1("hello,world");
    83. 	//cout << s1.c_str() << endl;
    84. 	使用push_back
    85. 	//s1.push_back('y');
    86. 	//cout << s1.c_str() << endl;
    87. 	//s1.push_back('y');
    88. 	//cout << s1.c_str() << endl;
    89.  
    90. 	使用重载+= （附用push_back）
    91. 	//s1 += '6';
    92. 	//s1 += '7';
    93. 	//s1 += '8';
    94. 	//cout << s1.c_str() << endl;
    95. 	使用重载+= （附用reserve）
    96. 	//s1 += 'a';
    97. 	//s1 += 'b';
    98. 	//s1 += 'c';
    99. 	//cout << s1.c_str() << endl;
    100.  
    101. 	//my::string s2; //reserve解决空串_capacity=0，再去_capacity*2仍为0
    102. 	//s2.reserve(20); //直接开辟指定空间
    103. 	
    104. 	//库里的string::resize
    105. 	std::string s3("cplusplus");
    106. 	s3.resize(20, 'x');
    107. 	s3.resize(5, 'x');
    108.  
    109. 	cout << s3 << endl;
    110.  
    111. 	//模拟实现的string::resize
    112. 	my::string s4("stringtest");
    113. 	s4.resize(5, 'y');
    114. 	s4.resize(15, 'g');
    115. 	cout << s4.c_str() << endl;
    116. }
    117.  
    118. //7.遍历测试
    119. void TestString7()
    120. {
    121. 	my::string s1("hello,world");
    122. 	//方式1:下标+[]
    123. 	for (size_t i = 0; i < s1.size(); ++i)
    124. 	{
    125. 		s1[i] += 1;
    126. 		cout << s1[i] << " ";
    127. 	}
    128. 	cout << endl;
    129. 	//方式2:迭代器
    130. 	my::string::iterator it = s1.begin();
    131. 	while (it != s1.end())
    132. 	{
    133. 		*it -= 1;
    134. 		cout << *it << " ";
    135. 		++it;
    136. 	}
    137. 	cout << endl;
    138. 	//方式3：范围for——底层被替换成迭代器访问
    139. 	for (auto& ch : s1)
    140. 	{
    141. 		cout << ch << " ";
    142. 		ch += 1;
    143. 	}
    144. 	cout << endl;
    145. 	for (auto ch : s1)
    146. 	{
    147. 		cout << ch << " ";
    148. 	}
    149. 	cout << endl;
    150.  
    151. }
    152. //const对象权限测试
    153. void  func(const my::string& s) //string的拷贝是深拷贝，使用引用减少拷贝
    154. {
    155. 	//方式1:下标+[]
    156. 	for (size_t i = 0; i < s.size(); ++i)
    157. 	{
    158. 		//s[i] += 1; //这里传给const形参，不能写
    159. 		cout << s[i] << " ";
    160. 	}
    161. 	cout << endl;
    162. 	//方式2:迭代器
    163. 	my::string::const_iterator it = s.begin();
    164. 	while (it != s.end())
    165. 	{
    166. 		//*it -= 1; //这里调用的是const_iterator,不支持写
    167. 		cout << *it << " ";
    168. 		++it;
    169. 	}
    170. 	cout << endl;
    171. 	//方式3：范围for——底层被替换成迭代器访问
    172. 	for (auto& ch : s)  //s是const修饰，会调用对应的迭代器
    173. 	{
    174. 		//cout << ch << " ";
    175. 		//ch += 1;  //这里调用的是const_iterator,不支持写
    176. 		cout << ch << " ";
    177.  
    178. 	}
    179. 	cout << endl;
    180. }
    181. //8.insert测试
    182. void TestString8()
    183. {
    184. 	my::string s1("hello,world");
    185. 	//插入字符
    186. 	//s1.insert(6, '@');
    187. 	//cout << s1.c_str() << endl;
    188.  
    189. 	//s1 += '#';
    190. 	//cout << s1.c_str() << endl;
    191.  
    192. 	遍历：范围for，按照实际长度去遍历
    193. 	//for (auto& ch : s1)  
    194. 	//{
    195. 	//	cout << ch << " ";
    196. 	//}
    197. 	//cout << endl;
    198.  
    199. 	//s1 += '\0'; //无法打印，不可见字符，使用范围for可确定，但不显示
    200. 	//cout << s1.c_str() << endl;
    201.  
    202. 	//s1 += '&';
    203. 	//cout << s1.c_str() << endl;
    204. 	遍历：范围for，按照实际长度去遍历
    205. 	//for (auto& ch : s1)  
    206. 	//{
    207. 	//	cout << ch << " ";
    208. 	//}
    209. 	//cout << endl;
    210. 	//s1.insert(0, '#');
    211. 	//cout << s1.c_str() << endl;
    212.  
    213. 	//插入字符串
    214.     s1.insert(0, "###");
    215. 	cout << s1.c_str() << endl;
    216. 	s1.insert(10, "@@@");
    217. 	cout << s1.c_str() << endl;
    218. }
    219. //9.erase测试
    220. void TestString9()
    221. {
    222. 	my::string s1("hello,world");
    223. 	cout << s1.c_str() << endl;
    224. 	//删除字符串
    225. 	s1.erase(0, 3);
    226. 	cout << s1.c_str() << endl;
    227. 	s1.erase(5, 10);
    228. 	cout << s1.c_str() << endl;
    229. 	s1.erase(1); //位置1之后全删完
    230. 	cout << s1.c_str() << endl;
    231. }
    232. //10.find测试
    233. void TestString10()
    234. {
    235. 	my::string s1("hello,world");
    236. 	cout << s1.c_str() << endl;
    237. 	//查找字符
    238. 	size_t found = s1.find('w');
    239. 	cout << "Object found at : "<
    240. 	//查找字符
    241. 	found = s1.find('l');
    242. 	cout << "Object found at : " << found << endl;
    243. 	
    244. 	//查找字符串
    245. 	found = s1.find("hell");
    246. 	cout << "Object found at : " << found << endl;
    247.  
    248. }
    249. //11.流重载测试
    250. void TestString11()
    251. {
    252. 	//1.<< 测试
    253. 	//my::string s1("hello,world");
    254. 	//cout << s1.c_str() << endl;
    255. 	//s1 += 'x';
    256. 	//cout << s1 << endl;
    257. 	//s1 += '\0';
    258. 	//s1 += '@';
    259. 	//cout << s1 << endl;
    260. 	//cout << s1.c_str() << endl; //读取到\0就结束
    261. 	//2.>>测试
    262. 	/*my::string s2,s3;
    263. 	cin >> s2>>s3;
    264. 	cout << s2 << endl;
    265. 	cout << s3 << endl;*/
    266. 	my::string s4("hello,world");
    267. 	cin >> s4;
    268. 	cout << s4 << endl;
    269.  
    270. }
    271. //12.赋值重载测试
    272. void TestString12()
    273. {
    274. 	my::string s1("hello,world");
    275. 	my::string s2(s1);
    276. 	cout << s2<< endl;
    277. 	my::string s3;
    278. 	s3 = s1;
    279. 	cout << s3 << endl;
    280.  
    281. }
    282. //13.转换函数测试
    283. void TestString13()
    284. {
    285. 	int i;
    286. 	cin >> i;
    287. 	string s1 = to_string(i);  //to_string是库里的
    288. 	cout << s1 << endl;
    289. 	int val = stoi(s1);        //stoi是库里的
    290. 	cout << s1 << endl;
    291.  
    292. }
    293.  
    294. int main()
    295. {
    296. 	
    297. 	//TestString1();
    298. 	//TestString2();
    299. 	//TestString3();
    300. 	//TestString4();
    301. 	//TestString5();
    302. 	//TestString6();
    303. 	//TestString7();
    304. 	//func("hello,world");
    305. 	//TestString8();
    306. 	//TestString9();
    307. 	//TestString10();
    308. 	//TestString11();
    309. 	//TestString12();
    310. 	TestString13();
    311. 	//对于new的异常捕获
    312. 	/*try
    313. 	{
    314. 		TestString4();
    315. 	}
    316. 	catch (const exception& e)
    317. 	{
    318. 		cout << e.what() << endl;
    319. 	}*/
    320. 	return 0;
    321. }

    后记：
    ●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！
                                                                        ——By 作者：新晓·故知 

  • 相关阅读:
    每日一题 LCP 06. 拿硬币
    求求了！这份GitHub 70K+的纯手写RabbitMQ 笔记都给我码住好吗！
    Python练习题：实现除自身以外元素的乘积
    论文解读：《DeepIPs：使用基于深度学习的方法对SARS-CoV-2感染的磷酸化位点进行全面评估和计算识别》
    Vue-router的安装使用
    Rocky/GNU之Zabbix部署(1)
    CDH/CDP中开启kerberos后如何访问HDFS/YARN/HIVESERVER2 等服务的webui
    Oracle中序列
    做测试8年，33岁前只想追求大厂高薪，今年只求稳定收入
    SMART S7-200PLC控制步进电机转动 step7开发环境 步进电机选择
  • 原文地址：https://blog.csdn.net/m0_57859086/article/details/126124276