devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C++】-- STL之String模拟实现_ostream& operator<<(ostream& out, const string& s)

作者：不正经 | 2024-04-26 10:24:31

赞

踩

ostream& operator<<(ostream& out, const string& s) { for (size_t i = 0; i <

目录

一、String类实现

1.string类的构造 

2.swap() 

3.拷贝构造

4.赋值运算符重载

5.析构

6.迭代器

7.operator[ ]

8.size()

9.c_str()

10.reserve() 

11.resize()

12.push_back()

13.append()

14.operator+=()

15.insert()

16.erase()

17.find()

18.operator>

19.operator==

20.operator>=

21.operator<

22.operator<=

23.operator!=

24.clear()

25.operator<<

26.operator>> 

 完整代码段

二、在线OJ题

 

一、String类实现

为了和库里面的string 区分开，使用命名空间delia将 string类和库里string隔离开

string类有3个成员变量：_str字符串内容、_size字符串大小、_capacity字符串容量

  1. namespace delia
  2. {
  3. 	class string
  4. 	{
  5.     private:
  6.         char* _str;
  7. 	    size_t _size;
  8. 	    size_t _capacity;
  9.     }
  10. }

string的模拟实现包括：

1.string类的构造 

分配空间时，要多分配1个字节的空间，这1个字节是留给'\0'的，_size最大为申请字节数-1，_capacity最大也为申请字节数-1 

  1.         //构造函数
  2. 		string(const char* str = "")
  3. 		{
  4. 			_str = new char[strlen(str) + 1];
  5. 			strcpy(_str, str);
  6.  
  7. 			_size = strlen(str);
  8. 			_capacity = _size;
  9. 		}

 

2.swap() 

使用库里的swap函数交换*this和s的内容：包括_str字符串内容、_size字符串大小和_capacity字符串容量 

  1.         //实现交换函数
  2. 		void swap(string& s)
  3. 		{
  4.             //用::指定调用全局的swap函数即库里的swap函数
  5. 			::swap(_str, s._str);
  6. 			::swap(_size, s._size);
  7. 			::swap(_capacity, s._capacity);
  8. 		}

3.拷贝构造

（1）先使用s._str作为参数构造一个临时对象

（2）将临时对象tmp的内容和*this进行交换

注意：必须要在初始化列表进行初始化 ，否则交换完毕后tmp出了拷贝构造函数作用域会调用析构函数释放tmp在堆上申请的空间，因为如果_str没有被初始化为空指针，那么_str就是随机值，交换后，tmp对象的成员_str也是随机值，随机值的空间时不可以被释放的，会导致不可预知的错误；空指针时可以被释放的，因此_str必须被初始化为空指针。

  1.         //现代拷贝构造
  2. 		string(const string& s)
  3. 			:_str(nullptr)
  4. 			, _size(0)
  5. 			, _capacity(0)
  6. 		{
  7. 			string tmp(s._str);
  8. 			swap(tmp);
  9. 		}

4.赋值运算符重载

使用swap()函数将*this的内容和s进行交换 

  1.         //赋值运算符重载
  2. 		string& operator=(string s)
  3. 		{
  4. 			swap(s);
  5. 			return *this;
  6. 		}

 

5.析构

释放_str在对上申请的空间、将_size和_capacity置0 

  1. 	    //析构函数
  2. 		~string()
  3. 		{
  4. 			delete[] _str;
  5. 			_str = nullptr;
  6. 			_size = 0;
  7. 			_capacity = 0;
  8. 		}

 

6.迭代器

分两种：普通迭代器（可读可写）和const迭代器（只读） 

（1）普通迭代器

  1.         //迭代器
  2. 		iterator begin()
  3. 		{
  4. 			return _str;
  5. 		}
  6.  
  7. 		//迭代器
  8. 		iterator end()
  9. 		{
  10. 			return _str + _size;
  11. 		}

（2）const迭代器

  1.         //const迭代器
  2. 		iterator begin() const 
  3. 		{
  4. 			return _str;
  5. 		}
  6.  
  7. 		//const迭代器
  8. 		iterator end() const
  9. 		{
  10. 			return _str + _size;
  11. 		}

 

7.operator[ ]

 也分为普通operator[ ]（可读可写）和const operator[ ]（只读）

char要加&，如果不加，那么return就是传值返回，返回的是_str[i]的拷贝，即临时对象，而临时对象具有常性，不能被修改，只能读；如果要对_str进行修改的话，char要加&，用传引用返回

  1. 	    //const string对象遍历，只读
  2. 		char& operator[](size_t i)  const
  3. 		{
  4. 			assert(i < _size);
  5. 			return _str[i];
  6. 		}
  7.  
  8. 		//非const string对象遍历，可读可写
  9. 		char& operator[](size_t i)
  10. 		{
  11. 			assert(i < _size);
  12. 			return _str[i];
  13. 		}

 

8.size()

  1. 	    //求string对象大小
  2. 		size_t size() const
  3. 		{
  4. 			return strlen(_str);
  5. 		}

 

9.c_str()

获取c形式字符串，将 const string* 类型 转化为 const char* 类型 

  1. 	    const char* c_str()
  2. 		{
  3. 			return _str;
  4. 		}

 

10.reserve() 

开空间，扩展_capacity，_size不变 

（1）申请新空间
（2）拷贝字符串
（3）释放旧空间
（4）指向新空间
（5）更新容量 

  1.         void reserve(size_t n)
  2. 		{
  3. 			if (n > _capacity)
  4. 			{
  5. 				char* tmp = new char[n + 1];//1.申请新空间，多开的那一个空间，存放\0
  6. 				strncpy(tmp, _str, _size + 1);//2.将字符串包含\0在内都拷贝到新空间
  7. 				delete[] _str;//3.释放旧空间
  8.  
  9. 				_str = tmp;//4.指向新空间
  10. 				_capacity = n;//5.更新容量
  11. 			}
  12. 		}

11.resize()

开空间+初始化，扩展_capacity，_size也要修改 

（1）当n<_size，无需增容 

（2）当n>_size，分两种情况
            ①_size < n <_capacity，无需增容，直接将_size到n位置置为val
            ②n >_capacity，需增容，并将_size到n位置置为val
          n>_size的这两种情况只有是否增容的区别，其他没有区别，可以合二为一

  1.         void resize(size_t n, char val = '\0')//如果没有显式给出val，val为\0
  2. 		{
  3. 			//1.当n<_size，无需增容
  4. 			if (n < _size)
  5. 			{
  6. 				_size = n;//直接更新_size
  7. 				_str[_size] = '\0';//将_size位置置为\0
  8. 			}
  9. 			//2.当n>_size，分两种情况
  10. 			//（1）_size < n <_capacity，无需增容，直接将_size到n位置置为val
  11. 			//（2）n >_capacity，需增容，并将_size到n位置置为val
  12. 			//这两种情况只有是否增容的区别，其他没有区别
  13. 			else
  14. 			{
  15. 				if (n > _capacity)
  16. 				{
  17. 					reserve(n);
  18. 				}
  19.  
  20. 				for (size_t i = _size; i < n; i++)
  21. 				{
  22. 					_str[i] = val;
  23. 				}
  24.  
  25. 				_str[n] = '\0';//将n的位置置\0
  26. 				_size = n;//更新_size
  27. 			}
  28. 		}

 

12.push_back()

要考虑是否需要开空间

  1.         //尾插一个字符
  2. 		void push_back(char ch)
  3. 		{
  4. 			//字符个数已经达到容量时，重新开空间
  5. 			if (_size == _capacity)
  6. 			{
  7. 				reserve(_capacity == 0 ? 4 : _capacity * 2);//如果是第一次开空间，就开4个字节，如果不是第一次开空间，就开成原来的2倍容量
  8. 			}
  9.  
  10. 			_str[_size] = ch;//将字符ch缀到字符串末尾
  11. 			_str[_size + 1] = '\0';//字符ch后面加\0，表明字符串结束
  12. 			_size++;//字符串大小+1
  13. 		}

13.append()

将str内容copy至this._str+_size（*this._str的末尾）位置 

 

 

  1. 	    //追加字符串
  2. 		void append(const char* str)
  3. 		{
  4. 			size_t len = _size + strlen(str);//函数执行完毕后字符串的大小
  5.  
  6. 			if (len > _capacity)
  7. 			{
  8. 				reserve(len);//空间不够，增容
  9. 			}
  10.  
  11. 			strcpy(_str + _size, str);//将str内容拷贝至_str末尾
  12. 			_size = len;//更新_size
  13. 		}

 

14.operator+=()

分为两种情况：

（1）+= 1个字符 ，使用push_back插入

（2）+= 字符串，使用append追加到字符串末尾

  1. 	    //+= 1个字符
  2. 		string& operator+= (char c)
  3. 		{
  4. 			push_back(c);//尾插字符
  5. 			return *this;
  6. 		}
  7.  
  8. 		//+= 字符串
  9. 		string& operator+= (const char* str)
  10. 		{
  11. 			append(str);//拼接字符串
  12. 			return *this;
  13. 		}

 

15.insert()

在指定位置插入字符：

（1）判断是否需要增容

（2）将pos位至字符串末尾的字符都向后挪一个位置

（3）将要插入的字符插入到pos位

（4）更新_size

 

  1. 	    //insert插入一个字符
  2. 		string& insert(size_t pos, const char ch)
  3. 		{
  4. 			assert(pos <= _size);//pos必须小于等于字符串长度
  5.  
  6. 			if (_size == _capacity)
  7. 			{
  8. 				reserve(2 * _capacity);//如果满了就增容
  9. 			}
  10.  
  11. 			size_t end = _size + 1;
  12. 			while (end > pos)//将pos至_size之间的字符依次向后挪动一个位置，来腾出pos位置
  13. 			{
  14. 				_str[end] = _str[end - 1];
  15. 				end--;//end为0时，因此end类型应为int，那么end--就为-1，pos为无符号数，不满足循环条件，退出循环
  16. 					  //但如果end类型为size_t，那么end为0时，end--就为-1，在内存中存储为无符号数(-1补码全1)，满足循环条件，永远无法退出循环
  17. 			}
  18.  
  19. 			_str[pos] = ch;//pos位置插入ch
  20. 			_size++;//更新_size
  21.  
  22. 			return *this;
  23. 		}

16.erase()

删除字符，len为要删除的字符个数，分两种情况：

（1）从pos到字符串末尾的字符个数<要删除的字符个数，说明this._str长度不够删，那pos之后全都被删完了，直接将pos位置'\0'，_size更新为pos即可。

 

（2）从pos到字符串末尾的字符个数≥要删除的字符个数，说明this._str长度够删，但是剩余的字符需要向前挪动len位

 

  1. 		//erase 删除字符
  2. 		string& erase(size_t pos, size_t len = npos)
  3. 		{
  4. 			assert(pos < _size);
  5.  
  6. 			size_t leftLen = _size - pos;//从pos位置到字符串结束的字符长度
  7. 			if (leftLen < len)//1.pos之后的字符全部删掉
  8. 			{
  9. 				_str[pos] = '\0';
  10. 				_size = pos;
  11. 			}
  12. 			else//2.pos之后的字符删掉一部分，没删完的部分要挪到pos位置
  13. 			{
  14. 				strcpy(_str + pos, _str + pos + len);
  15. 				_size -= len;
  16. 			}
  17. 			return *this;
  18. 		}

 

17.find()

分为查找字符和查找字符串

  1. 		//查找字符
  2. 		size_t find(char ch, size_t pos = 0)
  3. 		{
  4. 			assert(pos < _size);
  5. 			for (size_t i = 0; i < _size; i++)
  6. 			{
  7. 				if (_str[i] == ch)
  8. 				{
  9. 					return i;//找到就返回字符所在位置
  10. 				}
  11. 			}
  12. 			return npos;//没找到就返回-1
  13. 		}
  1. 		//查找字符串(子串)
  2. 		size_t find(const char* str, size_t pos = 0)
  3. 		{
  4. 			assert(pos < _size);
  5. 			const char* ret  = strstr(_str + pos, str);
  6.  
  7. 			if (ret)
  8. 			{
  9. 				return ret - _str;//计算str与_str的偏移量，即str在_str中的下标
  10. 			}
  11. 			else
  12. 			{
  13. 				return npos;//没找到就返回-1
  14. 			}
  15. 		}

 

18.operator>

字符串比较，只需要实现>和==，剩余的可以用这两个实现重载 

  1.         bool operator>(const string& s)
  2. 		{
  3. 			return strcmp(_str, s._str) < 0;
  4. 		}

 

19.operator==

  1. 	    bool operator==(const string& s)
  2. 		{
  3. 			return strcmp(_str, s._str) == 0;
  4. 		}

 

20.operator>=

  1. 	    bool operator>=(const string& s)
  2. 		{
  3. 			return (*this > s) || (*this == s);
  4. 		}

 

21.operator<

  1. 	    bool operator<(const string& s)
  2. 		{
  3. 			return !(*this >= s);
  4. 		}

 

22.operator<=

  1. 	    bool operator<=(const string& s)
  2. 		{
  3. 			return !(*this > s);
  4. 		}

 

23.operator!=

  1. 	    bool operator!=(const string& s)
  2. 		{
  3. 			return !(*this == s);
  4. 		}

 

24.clear()

将字符串清空 

  1. 	    void clear()
  2. 		{
  3. 			_size = 0;
  4. 			_str[0] = '\0';
  5. 		}

 

25.operator<<

输出重载<<让string直接输出打印，像内置类型一样，用范围for就可以实现

  1.     ostream& operator<<(ostream& out, const string& s)
  2. 	{
  3. 		for (auto ch: s)
  4. 		{
  5. 			out << s;
  6. 		}
  7. 		return out;
  8. 	}

 

26.operator>> 

输入重载>>让string直接输入，像内置类型一样；从标准输入流读取字符，遇到' '或'\0'就停止 

  1. 	istream& operator>>(istream& in, string& s)
  2. 	{
  3. 		s.clear();
  4. 		char ch;
  5. 		ch = in.get();
  6. 		while (ch != ' ' && ch != '\0')
  7. 		{
  8. 			s += ch;
  9. 			ch = in.get();
  10. 		}
  11. 		return in;
  12. 	}

 完整代码段：

  1. #pragma  once  
  2. #define  _CRT_SECURE_NO_WARNINGS
  3. #include<iostream>
  4. #include<assert.h>
  5. #include<stdlib.h>
  6.  
  7. using namespace std;
  8. //定义一个新的命名空间，和全局命名空间隔离开
  9. namespace delia
  10. {
  11. 	class string
  12. 	{
  13. 	public:
  14.  
  15. 		typedef char* iterator;
  16.  
  17. 		//迭代器
  18. 		iterator begin()
  19. 		{
  20. 			return _str;
  21. 		}
  22.  
  23. 		//迭代器
  24. 		iterator end()
  25. 		{
  26. 			return _str + _size;
  27. 		}
  28.  
  29. 		//const迭代器
  30. 		iterator begin() const 
  31. 		{
  32. 			return _str;
  33. 		}
  34.  
  35. 		//const迭代器
  36. 		iterator end() const
  37. 		{
  38. 			return _str + _size;
  39. 		}
  40.  
  41. 		//构造函数
  42. 		string(const char* str = "")
  43. 		{
  44. 			_str = new char[strlen(str) + 1];//1是留给'/0'的，_size最大为申请字节数-1，_capacity也为申请字节数-1
  45. 			strcpy(_str, str);
  46.  
  47. 			_size = strlen(str);
  48. 			_capacity = _size;
  49. 		}
  50.  
  51. 		//现代拷贝构造
  52. 		string(const string& s)
  53. 			:_str(nullptr)
  54. 			, _size(0)
  55. 			, _capacity(0)
  56. 		{
  57. 			string tmp(s._str);
  58. 			swap(tmp);
  59. 		}
  60.  
  61. 		//赋值运算符重载
  62. 		string& operator=(string s)
  63. 		{
  64. 			swap(s);
  65. 			return *this;
  66. 		}
  67.  
  68. 		//析构函数
  69. 		~string()
  70. 		{
  71. 			delete[] _str;
  72. 			_str = nullptr;
  73. 			_size = 0;
  74. 			_capacity = 0;
  75. 		}
  76.  
  77. 		//实现交换函数
  78. 		void swap(string& s)
  79. 		{
  80. 			::swap(_str, s._str);//用::指定调用全局的swap函数即库里的swap函数
  81. 			::swap(_size, s._size);
  82. 			::swap(_capacity, s._capacity);
  83. 		}
  84.  
  85. 		//const string对象遍历，只读
  86. 		char& operator[](size_t i)  const//char要加&，如果不加，那么return就是传值返回，返回的是_str[i]的拷贝，临时对象，而临时对象具有常性，不能被修改，只能读
  87. 										 //如果要对_str进行修改的话，char要加&，用传引用返回
  88. 		{
  89. 			assert(i < _size);
  90. 			return _str[i];
  91. 		}
  92.  
  93. 		//非const string对象遍历，可读可写
  94. 		char& operator[](size_t i)
  95. 		{
  96. 			assert(i < _size);
  97. 			return _str[i];
  98. 		}
  99.  
  100. 		//求string对象大小
  101. 		size_t size() const
  102. 		{
  103. 			return strlen(_str);
  104. 		}
  105.  
  106. 		//获取c形式字符串，将 const string* 类型 转化为 const char* 类型
  107. 		const char* c_str()
  108. 		{
  109. 			return _str;
  110. 		}
  111.  
  112. 		//开空间，扩展_capacity，_size不变
  113. 		void reserve(size_t n)
  114. 		{
  115. 			//1.申请新空间
  116. 			//2.拷贝字符串
  117. 			//3.释放旧空间
  118. 			//4.指向新空间
  119. 			//5.更新容量
  120. 			if (n > _capacity)
  121. 			{
  122. 				char* tmp = new char[n + 1];//1.申请新空间，多开的那一个空间，存放\0
  123. 				strncpy(tmp, _str, _size + 1);//2.将字符串包含\0在内都拷贝到新空间
  124. 				delete[] _str;//3.释放旧空间
  125.  
  126. 				_str = tmp;//4.指向新空间
  127. 				_capacity = n;//5.更新容量
  128. 			}
  129. 		}
  130.  
  131. 		//开空间+初始化，扩展_capacity，_size也要修改
  132. 		void resize(size_t n, char val = '\0')//如果没有显式给出val，val为\0
  133. 		{
  134. 			//1.当n<_size，无需增容
  135. 			if (n < _size)
  136. 			{
  137. 				_size = n;//直接更新_size
  138. 				_str[_size] = '\0';//将_size位置置为\0
  139. 			}
  140. 			//2.当n>_size，分两种情况
  141. 			//（1）_size < n <_capacity，无需增容，直接将_size到n位置置为val
  142. 			//（2）n >_capacity，需增容，并将_size到n位置置为val
  143. 			//这两种情况只有是否增容的区别，其他没有区别
  144. 			else
  145. 			{
  146. 				if (n > _capacity)
  147. 				{
  148. 					reserve(n);
  149. 				}
  150.  
  151. 				for (size_t i = _size; i < n; i++)
  152. 				{
  153. 					_str[i] = val;
  154. 				}
  155.  
  156. 				_str[n] = '\0';//将n的位置置\0
  157. 				_size = n;//更新_size
  158. 			}
  159. 		}
  160.  
  161. 		//尾插一个字符
  162. 		void push_back(char ch)
  163. 		{
  164. 			//字符个数已经达到容量时，重新开空间
  165. 			if (_size == _capacity)
  166. 			{
  167. 				reserve(_capacity == 0 ? 4 : _capacity * 2);//如果是第一次开空间，就开4个字节，如果不是第一次开空间，就开成原来的2倍容量
  168. 			}
  169.  
  170. 			_str[_size] = ch;//将字符ch缀到字符串末尾
  171. 			_str[_size + 1] = '\0';//字符ch后面加\0，表明字符串结束
  172. 			_size++;//字符串大小+1
  173. 		}
  174.  
  175. 		//追加字符串
  176. 		void append(const char* str)
  177. 		{
  178. 			size_t len = _size + strlen(str);//函数执行完毕后字符串的大小
  179.  
  180. 			if (len > _capacity)
  181. 			{
  182. 				reserve(len);//空间不够，增容
  183. 			}
  184.  
  185. 			strcpy(_str + _size, str);//将str内容拷贝至_str末尾
  186. 			_size = len;//更新_size
  187. 		}
  188.  
  189. 		//+= 1个字符
  190. 		string& operator+= (char c)
  191. 		{
  192. 			push_back(c);//尾插字符
  193. 			return *this;
  194. 		}
  195.  
  196. 		//+= 字符串
  197. 		string& operator+= (const char* str)
  198. 		{
  199. 			append(str);//拼接字符串
  200. 			return *this;
  201. 		}
  202.  
  203. 		//insert插入一个字符
  204. 		string& insert(size_t pos, const char ch)
  205. 		{
  206. 			assert(pos <= _size);//pos必须小于等于字符串长度
  207.  
  208. 			if (_size == _capacity)
  209. 			{
  210. 				reserve(2 * _capacity);//如果满了就增容
  211. 			}
  212.  
  213. 			size_t end = _size + 1;
  214. 			while (end > pos)//将pos至_size之间的字符依次向后挪动一个位置，来腾出pos位置
  215. 			{
  216. 				_str[end] = _str[end - 1];
  217. 				end--;//end为0时，因此end类型应为int，那么end--就为-1，pos为无符号数，不满足循环条件，退出循环
  218. 					  //但如果end类型为size_t，那么end为0时，end--就为-1，在内存中存储为无符号数(-1补码全1)，满足循环条件，永远无法退出循环
  219. 			}
  220.  
  221. 			_str[pos] = ch;//pos位置插入ch
  222. 			_size++;//更新_size
  223.  
  224. 			return *this;
  225. 		}
  226.  
  227. 		//erase 删除字符
  228. 		string& erase(size_t pos, size_t len = npos)
  229. 		{
  230. 			assert(pos < _size);
  231.  
  232. 			size_t leftLen = _size - pos;//从pos位置到字符串结束的字符长度
  233. 			if (leftLen < len)//1.pos之后的字符全部删掉
  234. 			{
  235. 				_str[pos] = '\0';
  236. 				_size = pos;
  237. 			}
  238. 			else//2.pos之后的字符删掉一部分，没删完的部分要挪到pos位置
  239. 			{
  240. 				strcpy(_str + pos, _str + pos + len);
  241. 				_size -= len;
  242. 			}
  243. 			return *this;
  244. 		}
  245.  
  246. 		//查找字符
  247. 		size_t find(char ch, size_t pos = 0)
  248. 		{
  249. 			assert(pos < _size);
  250. 			for (size_t i = 0; i < _size; i++)
  251. 			{
  252. 				if (_str[i] == ch)
  253. 				{
  254. 					return i;//找到就返回字符所在位置
  255. 				}
  256. 			}
  257. 			return npos;//没找到就返回-1
  258. 		}
  259.  
  260. 		//查找字符串(子串)
  261. 		size_t find(const char* str, size_t pos = 0)
  262. 		{
  263. 			assert(pos < _size);
  264. 			const char* ret  = strstr(_str + pos, str);
  265.  
  266. 			if (ret)
  267. 			{
  268. 				return ret - _str;//计算str与_str的偏移量，即str在_str中的下标
  269. 			}
  270. 			else
  271. 			{
  272. 				return npos;//没找到就返回-1
  273. 			}
  274. 		}
  275. 		
  276.  
  277. 		//字符串比较，只需要实现>和==
  278. 		bool operator>(const string& s)
  279. 		{
  280. 			return strcmp(_str, s._str) < 0;
  281. 		}
  282.  
  283. 		bool operator==(const string& s)
  284. 		{
  285. 			return strcmp(_str, s._str) == 0;
  286. 		}
  287.  
  288. 		// 其它4个运算符都可以对>和==这两个运算符进行重载
  289. 		bool operator>=(const string& s)
  290. 		{
  291. 			return (*this > s) || (*this == s);
  292. 		}
  293.  
  294. 		bool operator<(const string& s)
  295. 		{
  296. 			return !(*this >= s);
  297. 		}
  298.  
  299. 		bool operator<=(const string& s)
  300. 		{
  301. 			return !(*this > s);
  302. 		}
  303.  
  304. 		bool operator!=(const string& s)
  305. 		{
  306. 			return !(*this == s);
  307. 		}
  308.  
  309. 		void clear()
  310. 		{
  311. 			_size = 0;
  312. 			_str[0] = '\0';
  313. 		}
  314.  
  315. 	private:
  316. 		char* _str;
  317. 		size_t _size;
  318. 		size_t _capacity;
  319.  
  320. 		static const size_t npos;
  321. 	};
  322.  
  323. 	const size_t string::npos = -1;//npos初始化
  324.  
  325. 	//输出重载<<让string直接输出打印，像内置类型一样，用范围for就可以实现
  326. 	ostream& operator<<(ostream& out, const string& s)
  327. 	{
  328. 		for (auto ch: s)
  329. 		{
  330. 			out << s;
  331. 		}
  332. 		return out;
  333. 	}
  334.  
  335. 	//输入重载>>让string直接输入，像内置类型一样；从标准输入流读取字符，遇到' '或'\0'就停止
  336. 	istream& operator>>(istream& in, string& s)
  337. 	{
  338. 		s.clear();
  339. 		char ch;
  340. 		ch = in.get();
  341. 		while (ch != ' ' && ch != '\0')
  342. 		{
  343. 			s += ch;
  344. 			ch = in.get();
  345. 		}
  346. 		return in;
  347. 	}
  348.  
  349. 	void f(const string& s)
  350. 	{
  351. 		for (size_t i = 0; i < s.size(); i++)
  352. 		{
  353. 			cout << s[i] << " ";
  354. 		}
  355. 		cout << endl;
  356. 	}
  357.  
  358. 	void test_string1()
  359. 	{
  360. 		string s1("hello world");
  361. 		string s2(s1);
  362.  
  363. 		string s3("cplusplus.com");
  364. 		std::swap(s1, s3);//调用库里的swap函数，3次深拷贝，再把原来的空间释放掉，再开一样大的空间，代价大
  365. 		s1.swap(s3);//调用delia::string类里面的成员函数swap，仅仅只是成员变量的交换，s3指向了s1的空间，s1指向了s3的空间
  366.  
  367. 		string s4 = s1.c_str();
  368. 		s1[2] = 'w';
  369. 		f(s1);//h e w l o   w o r l d
  370.  
  371. 		for (size_t i = 0; i < s1.size(); i++)
  372. 		{
  373. 			cout << s1[i] << " ";
  374. 		}
  375. 		cout << endl;//h e w l o   w o r l d
  376. 	}
  377.  
  378. 	void test_string2()
  379. 	{
  380. 		string s1("hello world");
  381.  
  382. 		//使用迭代器遍历
  383. 		string::iterator it = s1.begin();
  384. 		while (it != s1.end())
  385. 		{
  386. 			cout << *it << " ";
  387. 			it++;
  388. 		}
  389. 		cout << endl;//h e l l o   w o r l d
  390.  
  391. 		//使用范围for遍历,范围for会被编译器替换成迭代器形式,如果把17-26行屏蔽，会发现编译不过
  392. 		for (auto ch : s1)
  393. 		{
  394. 			cout << *it << " ";
  395. 		}
  396. 		cout << endl;//h e l l o   w o r l d
  397. 	}
  398.  
  399. 	void test_string3()
  400. 	{
  401. 		string s1("hello world");
  402. 		s1 += "abc";
  403. 		for (auto& ch : s1)
  404. 		{
  405. 			cout << ch << " ";
  406. 		}
  407. 		cout << endl;//h e l l o   w o r l d a b c
  408.  
  409. 		s1 += "xyz";
  410. 		for (auto& ch : s1)
  411. 		{
  412. 			cout << ch << " ";
  413. 		}
  414. 		cout << endl;//h e l l o   w o r l d a b c x y z
  415. 	}
  416.  
  417. 	void test_string4()
  418. 	{
  419. 		string s1("hello world");
  420. 		s1 += '#';
  421. 		for (auto ch : s1)
  422. 		{
  423. 			cout << ch << " ";
  424. 		}
  425. 		cout << endl;//hello world#
  426.  
  427. 		s1 += "xyz";
  428. 		for (auto ch : s1)
  429. 		{
  430. 			cout << ch << " ";
  431. 		}
  432. 		cout << endl;//hello world#xyz
  433.  
  434. 		s1 += "!!!!!!!!!!!!!!!!!!!!";
  435. 		for (auto ch : s1)
  436. 		{
  437. 			cout << ch << " ";
  438. 		}
  439. 		cout << endl;//hello world#xyz!!!!!!!!!!!!!!!!!!!!
  440. 	}
  441.  
  442. 	void test_string5()
  443. 	{
  444. 		string s1("hello world");
  445. 		s1.resize(3);
  446. 		cout << s1.c_str() << endl;//hel
  447. 	}
  448.  
  449. 	void test_string6()
  450. 	{
  451. 		string s1("hello");
  452. 		s1.resize(6, 'a');
  453. 		cout << s1.c_str() << endl;//helloa
  454. 	}
  455.  
  456. 	void test_string7()
  457. 	{
  458. 		string s1("hello");
  459. 		s1.resize(9, 'o');
  460. 		cout << s1.c_str() << endl;//helloooo
  461. 	}
  462.  
  463. 	void test_string8()
  464. 	{
  465. 		string s1("hello");
  466. 		s1.insert(0, 'u');
  467. 		cout << s1.c_str() << endl;//uhello
  468. 	}
  469.  
  470. 	void test_string9()
  471. 	{
  472. 		string s1("hello");
  473. 		s1.erase(0, 2);
  474. 		cout << s1.c_str() << endl;//llo
  475.  
  476. 		string s2("world");
  477. 		s2.erase(1);//如果不给len，那么npos=-1，无符号数为4294967295，删除从位置为1-4294967295的字符，把后面的字符全部删除了
  478. 		cout << s2.c_str() << endl;//w
  479. 	}
  480.  
  481.  
  482. 	void test_string10()
  483. 	{
  484. 		string s1("hello world");
  485. 		cout << s1.find("rl",6) << endl;//8,从s1中的第6个位置开始查找"rl"字符串
  486. 	}
  487.  
  488. 	void test_string11()
  489. 	{
  490. 		std::string s("hello");
  491. 		cin >> s;
  492. 		cout << s << endl;
  493. 	}
  494. }
  495.  
  496.  
  497. int main()
  498. {
  499. 	//delia::test_string1();
  500. 	//delia::test_string2();
  501. 	//delia::test_string3();
  502. 	//delia::test_string4();
  503. 	//delia::test_string5();
  504. 	//delia::test_string6();
  505. 	//delia::test_string7();
  506. 	//delia::test_string8();
  507. 	//delia::test_string9();
  508. 	//delia::test_string10();
  509. 	delia::test_string11();
  510. 	return 0;
  511. }

二、在线OJ题

替换空格 OJ链接

分析：（1）如果使用string的replace或erase+insert都要挪动数据，效率低
           （2）考虑直接用新串，用新串需要分配多大空间？一个空格占1个字节，‘%20’占3个字节，替换后，每个空格都比原来多两个字节，新串空间应为：原串长度+2*空格数

  1. class Solution {
  2. public:
  3.     string replaceSpace(string s) {
  4.  
  5.         //1.计算空格数
  6.         size_t spaceCount = 0;
  7.         for(auto ch:s)
  8.         {
  9.             if(ch == ' ')
  10.             {
  11.                 spaceCount++;
  12.             }
  13.         }
  14.        
  15.         //2.声明新串
  16.         string ret;
  17.  
  18.         //3.为新串分配空间：从空格变为%20,长度增加2
  19.         ret.reserve(s.size()+2*spaceCount);
  20.  
  21.         //4.将空格替换为%20
  22.         for(auto ch:s)
  23.         {
  24.             if(ch != ' ')
  25.             {
  26.                 ret += ch;
  27.             }
  28.             else
  29.             {
  30.                 ret += "%20";
  31.             }
  32.         }
  33.  
  34.         return ret;
  35.     }
  36. };

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/490407
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号