• 【模拟string函数的实现】

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

    目录

    前言

    模拟string函数的实现

    浅拷贝

    深拷贝

    vs和g++下string结构的说明

    总结

    前言

    模拟string函数的实现

    浅拷贝

    深拷贝

    总结

    前言

    世上有两种耀眼的光芒，一种是正在升起的太阳，一种是正在努力学习编程的你!一个爱学编程的人。各位看官，我衷心的希望这篇博客能对你们有所帮助，同时也希望各位看官能对我的文章给与点评，希望我们能够携手共同促进进步，在编程的道路上越走越远！

    提示：以下是本篇文章正文内容，下面案例可供参考

    模拟string函数的实现

    string.h
    1. #pragma once
    2. #include 
    3. //string其实就是一个字符顺序表，唯一的区别就是在有效字符后面加了一个\0
    4. namespace bit
    5. {
    6. 	class string
    7. 	{
    8. 	public:
    9.  
    10. 		typedef char* iterator;//把类型重命名成iterator,然后让类域隔开
    11. 		typedef const char* const_iterator;//const_iterator其实就是const char*
    12.  
    13. 		const_iterator begin() const
    14. 		{
    15. 			return _str;
    16. 		}
    17.  
    18. 		const_iterator end() const//const修饰的是this
    19. 		{
    20. 			return _str + _size;
    21. 		}
    22. 		//函数的类型是无法支持函数的重载
    23. 		iterator begin()
    24. 		{
    25. 			return _str;//返回的是字符串第一个字符的下标
    26. 		}
    27.  
    28. 		iterator end()
    29. 		{
    30. 			return _str + _size;//返回的是'\0'的下标
    31. 		}
    32.  
    33.  
    34. 		//无参的构造函数
    35. 		//string()
    36. 		//	:_str(nullptr)//不能给str空指针，怕返回空指针
    37. 		//	//如果给str赋值 nullptr，采用c语言的接口，返回的字符串是空指针，打印空指针会报错的
    38. 		//	,_size(0)
    39. 		//	,_capacity(0)
    40. 		//{}
    41. 		
    42. 		//c++兼容c，我们要用c语言的接口：返回字符串
    43. 		const char* c_str() const
    44. 		{
    45. 			return _str;
    46. 		}
    47. 		
    48. 		所以，我们要给str开一个空间，并赋值'\0',返回字符的地址，这是可以的
    49. 		//string()
    50. 		//	:_str(new char[1])
    51. 		//	, _size(0)
    52. 		//	, _capacity(0)
    53. 		//{
    54. 		//	_str[0] = '\0';
    55. 		//}
    56.  
    57. 		//带参的构造函数
    58. 		/*string(const char* str)//strlen：遍历字符串，遇到 \0 就停止，不易多调用
    59. 			:_size(strlen(str))
    60. 			,_str(new char[strlen(str)+1])
    61. 			,_capacity(strlen(str))//capacity：不包含 \0 
    62. 		{
    63. 			strcpy(_str, str);
    64. 		}*/
    65.  
    66. 		//以上的无参和带参的构造函数合二为一：全缺省的构造函数(即可传参，也可不传传参)
    67. 		//第一种情况：
    68. 		//string(const char* str = nullptr)
    69. 		//如果传的是无参，strlen(str)：遍历字符串时，会对指针指向的内容解引用，str指向的是空指针
    70. 		//第二种情况：
    71. 		//string(const char* str = '\0')
    72.         //也不能给str赋值 '\0',左右两边的类型要匹配；右边类型：char  左边类型：const char*
    73. 		//第三种情况：
    74. 		//string(const char* str = "\0")//字符串是"\0",但是结束时，还会再加一个 \0
    75. 		//第四种情况：
    76. 		string(const char* str = "")//缺省值给一个空字符串
    77. 			:_size(strlen(str))
    78. 		{
    79. 			_capacity = _size;//capacity：存有效的字符空间，有效的字符是0个，但是还开了一个空间，用来存\0 
    80. 			_str = new char[_capacity + 1];
    81. 			strcpy(_str, str);
    82. 		}
    83.  
    84. 		size_t capacity() const
    85. 		{
    86. 			return _capacity;
    87. 		}
    88.  
    89. 		//遍历
    90. 		size_t size() const
    91. 		{
    92. 			return _size;//返回有效字符串的个数
    93. 		}
    94.  
    95. 		//函数的声明和定义在一块，本质就相当于是内联
    96. 		char& operator[](size_t pos)
    97. 		{
    98. 			assert(pos < _size);
    99. 			return _str[pos];//这些数据在堆区上，出来作用域也不会销毁，可以返回别名
    100. 		}
    101. 		//函数重载，上面的和下面的各用各的
    102. 		const char& operator[](size_t pos) const
    103. 		{
    104. 			//只能获取pos位置的字符，但是不能修改
    105. 			assert(pos < _size);
    106. 			return _str[pos];//这些数据在堆区上，出来作用域也不会销毁，可以返回别名
    107. 		}
    108.  
    109. 		//s2(s1)：深拷贝(拷贝构造函数)
    110. 		string(const string& s)
    111. 		{
    112. 			_str = new char[s._capacity + 1];
    113. 			strcpy(_str, s._str);
    114. 			_size = s._size;
    115. 			_capacity = s._capacity;
    116. 		}
    117.  
    118. 		//s2(s1)
    119. 		string(const string& s)
    120. 		{
    121. 			string tmp(s._str);
    122. 			swap(tmp);
    123. 		}
    124.  
    125.  
    126. 		//赋值运算符重载(s1 = s3)：也会出现浅拷贝的问题
    127. 		string& operator=(const string& s)
    128. 		{
    129. 			char* tmp = new char[s._capacity + 1];
    130. 			strcpy(tmp, s._str);
    131. 			delete[] _str;//把s1原来空间释放掉
    132. 			_str = tmp;
    133. 			_size = s._size;
    134. 			_capacity = s._capacity;
    135.  
    136. 			return *this;
    137. 		}
    138.  
    139. 		//析构函数
    140. 		~string()
    141. 		{
    142. 			delete[] _str;
    143. 			_str = nullptr;
    144. 			_size = _capacity = 0;
    145. 		}
    146.  
    147. 		void resize(size_t n, char ch = '\0')//半缺省函数，有实参会替换缺省值
    148. 		{
    149. 			//保留前n个数据
    150. 			if (n <= _size)
    151. 			{
    152. 				_str[n] = '\0';
    153. 				_size = n;
    154. 			}
    155. 			else
    156. 			{
    157. 				reserve(n);//n > capacity，就扩容
    158. 				for (size_t i = _size; i < n; i++)
    159. 				{
    160. 					_str[i] = ch;
    161. 				}
    162. 				_str[n] = '\0';
    163. 				_size = n;
    164. 			}
    165. 		}
    166.  
    167.  
    168. 		void reserve(size_t n)
    169. 		{
    170. 			if (n > _capacity)
    171. 			{
    172. 				//手动扩容
    173. 				char* tmp = new char[n + 1];//开空间永远要多开一个，多开的一个是给'\0'准备的
    174. 				strcpy(tmp, _str);//拷贝数据
    175. 				delete[] _str;//释放旧空间
    176. 				_str = tmp;//指针指向新空间
    177.  
    178. 				_capacity = n;
    179. 			}
    180. 		}
    181.  
    182. 		void push_back(char ch)
    183. 		{
    184. 			// 扩容2倍
    185. 			/*if (_size == _capacity)
    186. 			{
    187. 				reserve(_capacity == 0 ? 4 : 2 * _capacity);
    188. 			}
    190. 			_str[_size] = ch;
    191. 			++_size;
    192. 			_str[_size] = '\0';*/
    193.  
    194. 			insert(_size, ch);//复用insert()函数
    195. 		}
    196.  
    197. 		void append(const char* str)
    198. 		{
    199. 			// 扩容
    200. 			//size_t len = strlen(str);
    201. 			//if (_size + len > _capacity)
    202. 			//{
    203. 			//	//_size:当前字符串的长度；len:插入的字符串的长度；'\0'会单独开空间存放
    204. 			//	reserve(_size + len);
    205. 			//}
    206.  
    207. 			insert(_size, str);//复用insert()函数
    208. 		}
    209.  
    210. 		string& operator+=(char ch)
    211. 		{
    212. 			push_back(ch);
    213. 			return *this;
    214. 		}
    215.  
    216. 		string& operator+=(const char* str)
    217. 		{
    218. 			append(str);
    219. 			return *this;
    220. 		}
    221.  
    222. 		void insert(size_t pos, char ch)
    223. 		{
    224. 			assert(pos <= _size);
    225.  
    226. 			// 扩容2倍
    227. 			if (_size == _capacity)
    228. 			{
    229. 				reserve(_capacity == 0 ? 4 : 2 * _capacity);
    230. 			}
    231.  
    232. 			//挪动数据方法一：
    233. 			/*int end = _size;
    234. 			//while (end >= pos)//end：有符号；pos：无符号；有符号会向无符号提升
    235. 			while (end >= (int)pos)//这里的循环是把包括pos位置和end位置之间的数据往后挪动
    236. 			{
    237. 			    //如果一个运算符两边的操作数的类型不同的时候,会发生类型提升(范围小的向范围大的提升)
    238. 				_str[end + 1] = _str[end];
    239. 				--end;
    240. 			}*/
    241. 			/*_str[pos] = ch;
    242. 			++_size;*/
    243.  
    244. 			//挪动数据方法二：
    245. 			size_t end = _size + 1;
    246. 			while (end > pos)
    247. 			{
    248. 				_str[end] = _str[end - 1];
    249. 				--end;
    250. 			}
    251. 			_str[pos] = ch;
    252. 			++_size;
    253. 		}
    254.  
    255. 		void insert(size_t pos, const char* str)
    256. 		{
    257. 			assert(pos <= _size);//pos=size--->就相当于尾插
    258. 			size_t len = strlen(str);
    259. 			if (_size + len > _capacity)
    260. 			{
    261. 				// 扩容
    262. 				reserve(_size + len);
    263. 			}
    264.  
    265. 			size_t end = _size + len;
    266. 			while (end > pos + len - 1)
    267. 			{
    268. 				_str[end] = _str[end - len];
    269. 				end--;
    270. 			}
    271.  
    272. 			strncpy(_str + pos, str, len);
    273. 			_size += len;
    274. 		}
    275.  
    276. 		void erase(size_t pos, size_t len = npos)
    277. 		{
    278. 			assert(pos < _size);//不用删除\0
    279.  
    280. 			//if (len == npos || len + pos >= _size)
    281. 			//假如len == npos-1,npos是-1，是无符号整型的最大值，再加pos，可能会存在溢出的风险
    282. 			if (len == npos || len >= _size - pos)
    283. 			{
    284. 				_str[pos] = '\0';
    285. 				_size = pos;
    286. 			}
    287. 			else
    288. 			{
    289. 				strcpy(_str + pos, _str + pos + len);
    290. 				_size -= len;
    291. 			}
    292. 		}
    293.  
    294. 		void swap(string& s)
    295. 		{
    296. 			// 我们已经用 using namespace std;将std命名空间域给展开了,为什么还要加 std:: 呢？
    297. 			// 将 std 命名空间域展开(相当于:小王家开了一个通告,说你们可以拿我家的菜),
    298. 			// 但是顺序还是不变的:局部域----->全局域----->命名空间域
    299. 			// 加 std::是为了防止 swap()函数在局部域找swap()函数的定义出处时，发生事故；
    300. 			// 不加 std:: 的话,swap()函数会先找到 swap(string& s)的,但是参数的类型不一样,会发生报错 
    301. 			std::swap(_str, s._str);//调用库里的模板,这里是交换了堆区空间的地址
    302. 			std::swap(_size, s._size);
    303. 			std::swap(_capacity, s._capacity);
    304. 		}
    305. 		//找字符
    306. 		size_t find(char ch, size_t pos = 0) const
    307. 		{
    308. 			assert(pos < _size);
    309.  
    310. 			for (size_t i = pos; i < _size; i++)
    311. 			{
    312. 				if (_str[i] == ch)
    313. 					return i;
    314. 			}
    315.  
    316. 			return npos;
    317. 		}
    318. 		//找字符串
    319. 		size_t find(const char* sub, size_t pos = 0) const
    320. 		{
    321. 			assert(pos < _size);
    322.  
    323. 			const char* p = strstr(_str + pos, sub);
    324. 			if (p)
    325. 			{
    326. 				return p - _str;//指针 - 指针 == 两个指针之间的元素个数(返回的是下标)
    327. 			}
    328. 			else
    329. 			{
    330. 				return npos;
    331. 			}
    332. 		}
    333.  
    334. 		string substr(size_t pos = 0, size_t len = npos)
    335. 		{
    336. 			string sub;
    337. 			//if (len == npos || len >= _size-pos)
    338. 			if (len >= _size - pos)
    339. 			{
    340. 				for (size_t i = pos; i < _size; i++)
    341. 				{
    342. 					sub += _str[i];
    343. 				}
    344. 			}
    345. 			else
    346. 			{
    347. 				for (size_t i = pos; i < pos + len; i++)
    348. 				{
    349. 					sub += _str[i];
    350. 				}
    351. 			}
    352.  
    353. 			return sub;
    354. 		}
    355. 		//只清理空间中的数据,并不会缩容
    356. 		void clear()
    357. 		{
    358. 			_size = 0;
    359. 			_str[_size] = '\0';
    360. 		}
    361.  
    362.  
    363. 	private:
    364. 		//初始化列表初始化的顺序和声明的顺序一样
    365. 		char* _str;
    366. 		size_t _size;
    367. 		size_t _capacity;
    368.  
    369. 	public:
    370. 		static const int npos;//npos:是一个公有的静态成员变量
    371. 	};
    372.  
    373. 	const int string::npos = -1;
    374.  
    375. 	//string中的非成员函数
    376. 	void swap(string& x, string& y)
    377. 	{
    378. 		x.swap(y);
    379. 	}
    380. 	//全局函数
    381. 	bool operator==(const string& s1, const string& s2)
    382. 	{
    383. 		int ret = strcmp(s1.c_str(), s2.c_str());
    384. 		return ret == 0;
    385. 	}
    386.  
    387. 	bool operator<(const string& s1, const string& s2)
    388. 	{
    389. 		int ret = strcmp(s1.c_str(), s2.c_str());
    390. 		return ret < 0;
    391. 	}
    392.  
    393. 	bool operator<=(const string& s1, const string& s2)
    394. 	{
    395. 		return s1 < s2 || s1 == s2;
    396. 	}
    397.  
    398. 	bool operator>(const string& s1, const string& s2)
    399. 	{
    400. 		return !(s1 <= s2);
    401. 	}
    402.  
    403. 	bool operator>=(const string& s1, const string& s2)
    404. 	{
    405. 		return !(s1 < s2);
    406. 	}
    407.  
    408. 	bool operator!=(const string& s1, const string& s2)
    409. 	{
    410. 		return !(s1 == s2);
    411. 	}
    412. 	//流插入(必须是全局函数,没有访问类中的私有成员变量,所以不需要设置成友元函数)
    413. 	ostream& operator<<(ostream& out, const string& s)
    414. 	{
    415. 		for (auto ch : s)
    416. 		{
    417. 			out << ch;
    418. 		}
    419.  
    420. 		return out;
    421. 	}
    422. 	//流提取(是一个覆盖)
    423. 	istream& operator>>(istream& in, string& s)//提取的字符放入string类型的对象中,所以不需要要用const来修饰
    424. 	{
    425. 		//s是s1和s2的别名,s对象中有s1或s2的字符串内容,流提取是一个覆盖；
    426. 		//此时流提取只会在字符串的尾部插入数据,所以我们要先把s对象中的数据清理掉
    427. 		s.clear();
    428.  
    429. 		char ch;
    430. 		//in >> s[i];//不能这么写,对象s中还没有写入字符,还没有数据
    431. 		//in >> ch;
    432. 		//c++的cin和c语言的scanf是读元素的时候,是读不到空格和换行的
    433. 		//(他们认为空格或换行是多个元素之间的分割符,会自动把空格或换行符给忽略掉)
    434. 		//c语言应该用 getchar/getc;但是c++是不能用的
    435. 		//(因为c语言和c++的iostream流不是同一个,他们都有各自的缓存区)
    436. 		ch = in.get();//所以用它来取字符
    437. 		char buff[128];//1、在栈上开空间比在堆上开空间要快一些;2、出了函数作用域空间就销毁了,不会一直浪费空间
    438. 		size_t i = 0;
    439. 		//流插入和流提取遇到 空格或换行 就默认结束
    440. 		while (ch != ' ' && ch != '\n')
    441. 		{
    442. 			//buff:字符数组,一段一段往对象s中加
    443. 			buff[i++] = ch;
    444. 			// [0,126]
    445. 			if (i == 127)
    446. 			{
    447. 				buff[127] = '\0';
    448. 				s += buff;//把前127个字符加入对象s中
    449. 				i = 0;
    450. 			}
    451.  
    452. 			ch = in.get();
    453. 		}
    454.  
    455. 		if (i > 0)
    456. 		{
    457. 			buff[i] = '\0';
    458. 			s += buff;//把有效的数据个数加入对象s中
    459. 		}
    460.  
    461. 		return in;
    462. 	}
    463.  
    464. 	//流提取(是一个覆盖)
    465. 	//istream& operator>>(istream& in, string& s)//提取的字符放入string类型的对象中,所以不需要要用const来修饰
    466. 	//{
    467. 	//	//s是s1和s2的别名,s对象中有s1或s2的字符串内容,流提取是一个覆盖；
    468. 	//	//此时流提取只会在字符串的尾部插入数据,所以我们要先把s对象中的数据清理掉
    469. 	//	s.clear();
    470. 	//	char ch;
    471. 	//	//in >> s[i];//不能这么写,对象s中还没有写入字符,还没有数据
    472. 	//	//in >> ch;
    473. 	//	//c++的cin和c语言的scanf是读元素的时候,是读不到空格和换行的
    474. 	//	//(他们认为空格或换行是多个元素之间的分割符,会自动把空格或换行符给忽略掉)
    475. 	//	//c语言应该用 getchar/getc;但是c++是不能用的
    476. 	//	//(因为c语言和c++的iostream流不是同一个,他们都有各自的缓存区)
    477. 	//	ch = in.get();//所以用它来取字符
    478. 	//	s.reserve(128);
    479. 	//	//流插入和流提取遇到 空格或换行 就默认结束
    480. 	//	while (ch != '\n' && ch != ' ')
    481. 	//	{
    482. 	//		s += ch;
    483. 	//		ch = in.get();
    484. 	//	}
    485.  
    486. 	//	return in;
    487. 	//}
    488. 	//获取一行
    489. 	istream& getline(istream& in, string& s)
    490. 	{
    491. 		s.clear();
    492.  
    493. 		char ch;
    494. 		//in >> ch;
    495. 		ch = in.get();
    496. 		char buff[128];
    497. 		size_t i = 0;
    498. 		while (ch != '\n')
    499. 		{
    500. 			buff[i++] = ch;
    501. 			// [0,126]
    502. 			if (i == 127)
    503. 			{
    504. 				buff[127] = '\0';
    505. 				s += buff;  
    506. 				i = 0;
    507. 			}
    508.  
    509. 			ch = in.get();
    510. 		}
    511.  
    512. 		if (i > 0)
    513. 		{
    514. 			buff[i] = '\0';
    515. 			s += buff;
    516. 		}
    517.  
    518. 		return in;
    519. 	}
    1. 	void test_string1()
    2. 	{
    3. 		string s1("hello world");
    4. 		string s2;
    5. 		cout << s1.c_str() << endl;
    6. 		cout << s2.c_str() << endl;
    7.  
    8. 		for (size_t i = 0; i < s1.size(); i++)
    9. 		{
    10. 			s1[i]++;
    11. 		}
    12. 		cout << endl;
    13. 		//遍历：下标+[]
    14. 		for (size_t i = 0; i < s1.size(); i++)
    15. 		{
    16. 			//s1：既能调用const的函数，也可以调用非const的函数
    17. 			//s1.operator[](i)
    18. 			cout << s1[i] << "";
    19. 		}
    20. 		cout << endl;
    21.  
    22. 		const string s3("xxxx");//只能调用const char& operator[](size_t pos) const这个函数
    23. 		for (size_t i = 0; i < s3.size(); i++)
    24. 		{
    25. 			//s3[i]++;
    26. 			cout << s3[i] << " ";
    27. 		}
    28. 		cout << endl;
    29.  
    30.  
    31. 		数组的越界是很不好检查的：
    32. 		//int a[10];
    33. 		数组的读是检查不出来的
    34. 		//a[10];
    35. 		//a[11];
    36. 		数组的写不一定能检查出来。因为数组的越界检查是一种抽查
    37. 		//a[10] = 1;
    38. 	}
    39.  
    40. 	void test_string2()
    41. 	{
    42. 		string s3("hello world");
    43. 		//范围for是一个替换机制(会自动替换成迭代器,这个地方是写死的,迭代器中必须要有iterator、begin、end)：
    44. 		//自动取对象s3里面的数据赋值给ch,自动迭代，自动加加
    45. 		for (auto ch : s3)//s3是普通对象，范围for替换成普通迭代器
    46. 		{
    47. 			cout << ch << " ";
    48. 		}
    49. 		cout << endl;
    50.  
    51. 		//迭代器(像指针，但不一定是指针)
    52. 		string::iterator it3 = s3.begin();
    53. 		while (it3 != s3.end())
    54. 		{
    55. 			*it3 -= 1;
    56. 			cout << *it3 << " ";
    57. 			++it3;
    58. 		}
    59. 		cout << endl;
    60.  
    61. 		const string s4("xxxx");
    62. 		string::const_iterator it4 = s4.begin();
    63. 		while (it4 != s4.end())
    64. 		{
    65. 			//*it4 += 3;
    66. 			cout << *it4 << " ";
    67. 			++it4;
    68. 		}
    69. 		cout << endl;
    70. 		//s4是const对象，范围for替换成const迭代器(class类中必须声明iterator、begin、end)
    71. 		for (auto ch : s4)
    72. 		{
    73. 			cout << ch << " ";
    74. 		}
    75. 		cout << endl;
    76. 	}
    77.  
    78. 	void test_string3()
    79. 	{
    80. 		string s3("hello world");
    81. 		s3.push_back('1');
    82. 		s3.push_back('2');
    83. 		cout << s3.c_str() << endl;
    84. 		s3 += 'x';
    85. 		s3 += "yyyyyy";
    86. 		cout << s3.c_str() << endl;
    87.  
    88. 		string s1("hello world");
    89. 		s1.insert(11, 'x');
    90. 		cout << s1.c_str() << endl;
    91.  
    92. 		s1.insert(0, 'x');
    93. 		cout << s1.c_str() << endl;
    94. 	}
    95.  
    96. 	void test_string4()
    97. 	{
    98. 		string s1("hello world");
    99. 		cout << s1.c_str() << endl;
    100.  
    101. 		s1.erase(6, 3);
    102. 		cout << s1.c_str() << endl;
    103.  
    104. 		s1.erase(6, 30);
    105. 		cout << s1.c_str() << endl;
    106.  
    107. 		s1.erase(3);
    108. 		cout << s1.c_str() << endl;
    109.  
    110. 		string s2("hello world");
    111. 		cout << s2.c_str() << endl;
    112.  
    113. 		s2.resize(5);
    114. 		cout << s2.c_str() << endl;
    115.  
    116. 		s2.resize(20, 'x');
    117. 		cout << s2.c_str() << endl;
    118. 	}
    119.  
    120. 	void test_string5()
    121. 	{
    122. 		string s1("hello world");
    123. 		cout << s1.c_str() << endl;
    124. 		//此时，这里是 浅拷贝/值拷贝;s1和s2中的_str所指向的空间是同一块,析构函数释放数据会释放两次,
    125. 		//并且改动数据,对两个都有影响
    126. 		string s2(s1);
    127. 		cout << s2.c_str() << endl;
    128.  
    129. 		s1[0] = 'x';
    130.  
    131. 		cout << s1.c_str() << endl;
    132. 		cout << s2.c_str() << endl;
    133.  
    134. 		string s3("xxxxx");
    135. 		s1 = s3;
    136.  
    137. 		cout << s1.c_str() << endl;
    138. 		cout << s3.c_str() << endl;
    139. 	}
    140.  
    141. 	void test_string6()
    142. 	{
    143. 		string s1("hello world");
    144. 		cout << s1.c_str() << endl;
    145.  
    146. 		s1.insert(6, "xxx");
    147. 		cout << s1.c_str() << endl;
    148.  
    149. 		string s2("xxxxxxx");
    150.  
    151. 		cout << s1.c_str() << endl;
    152. 		cout << s2.c_str() << endl;
    153. 		swap(s1, s2);//调用库里面的swap模板,代价:三次拷贝构造+一次析构(涉及到深拷贝,释放和申请空间的次数太多)
    154. 		s1.swap(s2);//高效的方法:交换两个堆区空间的地址,不需要多次释放和申请空间
    155. 		cout << s1.c_str() << endl;
    156. 		cout << s2.c_str() << endl;
    157. 	}
    158.  
    159. 	void test_string7()
    160. 	{
    161. 		string url1("https://legacy.cplusplus.com/reference/string/string/substr/");
    162. 		string url2("http://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=65081411_1_oem_dg&wd=%E5%90%8E%E7%BC%80%20%E8%8B%B1%E6%96%87&fenlei=256&rsv_pq=0xc17a6c03003ede72&rsv_t=7f6eqaxivkivsW9Zwc41K2mIRleeNXjmiMjOgoAC0UgwLzPyVm%2FtSOeppDv%2F&rqlang=en&rsv_dl=ib&rsv_enter=1&rsv_sug3=4&rsv_sug1=3&rsv_sug7=100&rsv_sug2=0&rsv_btype=i&inputT=1588&rsv_sug4=6786");
    163.  
    164. 		string protocol, domain, uri;
    165. 		size_t i1 = url1.find(':');
    166. 		if (i1 != string::npos)
    167. 		{
    168. 			protocol = url1.substr(0, i1 - 0);
    169. 			cout << protocol.c_str() << endl;
    170. 		}
    171.  
    172. 		// strchar
    173. 		size_t i2 = url1.find('/', i1 + 3);
    174. 		if (i2 != string::npos)
    175. 		{
    176. 			domain = url1.substr(i1 + 3, i2 - (i1 + 3));
    177. 			cout << domain.c_str() << endl;
    178.  
    179. 			uri = url1.substr(i2 + 1);
    180. 			cout << uri.c_str() << endl;
    181. 		}
    182.  
    183. 		// strstr  
    184. 		size_t i3 = url1.find("baidu");
    185. 		cout << i3 << endl;
    186. 	}
    187.  
    188.  
    189. 	void test_string8()
    190. 	{
    191. 		string s1("hello world");
    192. 		string s2("hello world");
    193.  
    194. 		cout << (s1 == s2) << endl;
    195.  
    196. 		cout << ("hello world" == s2) << endl;//左边是调用构造成员函数,类型是 const char*
    197. 		//左边不能是一个成员函数,他必须是一个对象,对象才能调用成员函数
    198. 		//(解释赋值运算符重载为什么是全局函数,如果是成员函数的话,第一个参数是 this,是对象的地址)
    199. 		cout << (s1 == "hello world") << endl;
    200. 		//单参数的构造函数可以支持隐式类型转换(const char*转换成string类型)
    201.  
    202. 		cout << s1 << endl;
    203. 		cout << s2 << endl;
    204. 		//c++中的cout和cin的缓存区也不是同一个,所以cout出去的,不会影响cin进来的
    205. 		cin >> s1 >> s2;
    206.  
    207. 		cout << s1 << endl;
    208. 		cout << s2 << endl;
    209.  
    210. 		getline(cin, s1);
    211. 		cout << s1 << endl;
    212. 	}
    213.  
    214. 	void test_string9()
    215. 	{
    216. 		string s1;
    217.  
    218. 		cin >> s1;
    219. 		cout << s1.capacity() << endl;
    220. 	}
    221.  
    222. 	void test_string10()
    223. 	{
    224. 		string s1("hello world");
    225. 		string s2(s1);
    226.  
    227. 		cout << s1 << endl;
    228. 		cout << s2 << endl;
    229. 	}
    230. }
    test.cpp
    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. using namespace std;
    4. #include
    5. #include"string.h"
    6.  
    7.  
    8. int main()
    9. {
    10.  
    11. 	bit::test_string1();
    12. 	return 0;
    13. }
    14.  
    15. //内置类型为什么支持流插入和流提取呢？
    16. //因为库里面直接就把内置类型重载了，直接掉库里面的函数；又可以自动识别类型，是因为这些函数有互相构成了函数重载

    tmp要初始化为nullptr，否则当swap交换之后，tmp指向空，出了函数的作用域之后，会调用析构函数，析构函数会对tmp局部变量销毁，如果tmp是随机值会报错，而是nullptr的话，就不会有问题。传统写法和现代写法效率基本都一样。

    拷贝构造是用一个存在的对象去构造另外一个要初始化的对象，那另外一个对象是没有空间的。

    赋值是两个对象都已经存在了。

    栈上开空间要比堆区上开空间要快，而且成本更低。

    浅拷贝

    浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

    说明：

    上述String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构 造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块 空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

    深拷贝

    vs和g++下string结构的说明

    注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。

    • vs下string的结构

    string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字 符串的存储空间：

    • 当字符串长度小于16时，使用内部固定的字符数组来存放
    • 当字符串长度大于等于16时，从堆上开辟空间
    1. union _Bxty
    2.  {   // storage for small buffer or pointer to larger one
    3.  value_type _Buf[_BUF_SIZE];
    4.  pointer _Ptr;
    5.  char _Alias[_BUF_SIZE]; // to permit aliasing
    6.  } _Bx;

    这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内 部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。

    其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量

    最后：还有一个指针做一些其他事情。

    故总共占16+4+4+4=28个字节。

    • g++下string的结构

    G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指 针将来指向一块堆空间，内部包含了如下字段：

    • 空间总大小
    • 字符串有效长度
    • 引用计数
    1. struct _Rep_base
    2.  {
    3.     size_type               _M_length;
    4.     size_type               _M_capacity;
    5.     _Atomic_word            _M_refcount;
    6.  };
    • 指向堆空间的指针，用来存储字符串。

    总结

    好了，本篇博客到这里就结束了，如果有更好的观点，请及时留言，我会认真观看并学习。
    不积硅步，无以至千里；不积小流，无以成江海。

  • 相关阅读:
    Docker高级篇之Docker微服务实战
    来写个贪吃蛇小游戏吧（TypeScript版本）
    Vue项目中强制刷新页面的方法
    R语言入门笔记2.5
    点击化学嫁接聚乙二醇包裹疏水性半导体聚合物，点击化学修饰疏水有机聚合物
    【Python基础篇016】异常处理的超详细讲解
    精读《正交的 React 组件》
    Nuxt3 中使用 ESLint
    Hadoop源码编译打包
    R语言可视化散点图（scatter plot）图、为图中的部分数据点添加标签、始终显示所有标签，即使它们有太多重叠、ggrepel包来帮忙
  • 原文地址：https://blog.csdn.net/2301_79585944/article/details/136591625