string 类中常见操作及其模拟实现

转x33g5p2x  于2021-11-22 转载在 其他  
字(11.8k)|赞(0)|评价(0)|浏览(426)

1.string容器的基本概念

本质：string是c++类型的字符串，其本质是一个封装好的类
string和char的区别：
1.char 是一个指针
2.string是一个内部封装了char* 的类，管理这个字符串，是一个char型容器
特点：
string类内部封装了很多成员函数
例如：查找find，拷贝copy，删除delete，替换replace,插入insert
string管理char所分配的内存，不用担心赋值越界和取值越界等问题，由类内部负责

2.string容器的常用操作string 的构造函数

  1. string();//创建一个空的字符串例如：string str;
  2. string(const string &str)//使用一个string 对象去初始化另外一个string 对象
  3. string(const char*str)//使用字符串s初始化
  4. string (int n,char c)//使用n个字符串c初始化

下面我们来实验

1.string ()

  1. #include<iostream>
  2. using namespace std;
  3. #include<string>
  4.  int main()
  5. {
  6. 	string s;
  7. 	cout << s;
  8. }

运行结果：

我们可以发现字符串是空的

2.string (const string&str);

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string s = "abvede";
  6. 	string s1(s);
  7. 	cout << s1;
  8. }

运行结果：

3.string (const char*str);

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string s1("abdedf");
  6. 	cout << s1;
  7. }

运行结果：

4.string (int n,char c)

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string s1(3, 'a');
  6. 	cout << s1;
  7. }

 3.string 类的基本赋值操作

  1. string &operator=(const char*s)//将char*类型字符串赋值给当前字符串
  2. string &operator=(const string &s)把字符串s赋值给当前字符串
  3. string& operator=(char c)把字符赋值给当前字符串
  4. string &assign (const char*s)把字符串s赋给当前字符串
  5. string &assign(const char*s,int n)把字符串s的前n个字符赋给当前字符串
  6. string &assign(const string&s)把字符串s赋给当前字符串
  7. string &assign(int n,char c)用n个字符赋给当前字符串
  8. string &assign(const string &s,int start,int n)将s从start开始n个字符赋值给字符串

例：string &operator=(const char*s)

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string s = "aveddfhf";
  6. 	cout << s << endl;
  7. 	return 0;
  8. }

运行结果：

2.string &operator=(const string&s)

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string s = "aveddfhf";
  6. 	string s1;
  7. 	s1 = s;
  8. 	cout << s1<< endl;
  9. 	return 0;
  10. }

运行结果：

3.string&operator=（char c);

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string s1;
  6. 	s1 = 'a';
  7. 	cout << s1 << endl;
  8. 	return 0;
  9. }

4.string  &assign(const char*s)

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string s1;
  6. 	s1.assign("djfgfjdfgh");
  7. 	cout << s1 << endl;
  8. }

运行结果：

string 存取字符字符操作及遍历方法

  1. //string存取字符操作
  2. //char&operator[](int n)；通过[]的方式取字符
  3. //char&at(int n);通过at的方式获取字符

例：

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string str = "hello world";
  6. 	for (int i = 0; i < str.size(); i++) {
  7. 		cout << str[i] << endl;
  8. 	}
  9. }

运行结果：

通过at 的方式来获取：

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string str = "hello world";
  6. 	for (int i = 0; i < str.size(); i++) {
  7. 		cout << str.at(i) << endl;
  8. 	}
  9. }

运行结果：

我们可以发现两者的运行结果没有取别，拿这两种方式有什么区别吗？

[]和at的区别：

[]访问越界程序会直接挂掉，而at访问越界会抛出异常out_of_range

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string str = "hello world";
  6. 	cout << str[100] << endl;
  7. }

运行结果：


  

我们可以看到此时程序直接崩溃了

通过at的方式来获取：

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string str = "hello world";
  7. 	try {
  8. 		cout << str.at(100) << endl;
  9. 	}
  10. 	catch (out_of_range& e) {
  11. 		cout << e.what() << endl;
  12. 	}
  14. }

运行结果：

string 中如何访问最后一个元素或者第一个元素

访问第一个元素：

1.通过[]

2.通过at

3.通过成员函数的方法 对象.front();

4.通过迭代器

访问最后一个元素与访问第一个元素类似

1.通过[]

2.通过at

3.通过成员函数的方法

4.通过迭代器

例：

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string str = "hello world";
  6. 	cout << str[0] << endl;//通过[]
  7. 	cout << str.at(0) << endl;//通过at
  8. 	cout << str.front() << endl;//通过成员函数
  9. 	cout << *str.begin() << endl;//通过迭代器
  10. 	return 0;
  11. }

运行结果：

访问最后一个元素：

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string str = "hello world";
  6. 	cout << str[str.size() - 1] << endl;
  7. 	cout << str.at(str.size() - 1) << endl;
  8. 	cout << str.back() << endl;
  9. 	cout << *(str.end() - 1) << endl;//注意str.end()返回的是最后一个元素的下一个位置
  10. 	return 0;
  11. }

运行结果：

2.string对象的几种遍历方式

1.通过[]或者at加for或者while循环遍历

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string str = "hello world";
  6. 	for (int i = 0; i < str.size(); i++) {
  7. 		cout << str[i];
  8. 	 }
  9. }

运行结果：

2.通过迭代器

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string str = "hello world";
  6. 	string::iterator it = str.begin();
  7. 	while (it != str.end()) {
  8. 		cout << *it;
  9. 		it++;
  10. 	}
  11. 	return 0;
  12. }

运行结果：

3.通过范围for来遍历

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	string str = "hello world";
  6. 	for (auto& e : str) {
  7. 		cout << e;
  8. 	}
  9. }

运行结果：

4.通过algorithm里面的for_each来遍历

  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. void myprint(char ch) {
  5. 	cout << ch;
  6. }
  7. int main()
  8. {
  9. 	string str = "hello world";
  10. 	for_each(str.begin(), str.end(), myprint);
  11. }

运行结果：

string 中的拼接操作

  1. /string 类中的拼接操作
  2. //string &operator+=(const char*str)重载+=
  3. //string &operator+=(const string&str)重载+=
  4. //string &operator+=(const char ch)重载+=
  5. //string &append (const char*str)把字符串str连接到当前字符串结尾
  6. //string &append(const char*str,int n)把字符串str前n个字符连接到当前字符串结尾
  7. //string &append(const string&s)和+=一样
  8. //string&append(const string&s int pos,int n)把字符串s中从pos位置开始的n个字符连接到当前字符串
  9. //string &append(int n,char c)在当前字符串结尾添加n个字符c

在这里就不一一测试

string&operator(const char ch)

  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. int main()
  5. {
  6. 	string s = "ab";
  7. 	s += 'c';
  8. 	cout << s << endl;
  9. }

运行结果：

string&operator+=(const char*str)

  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. int main()
  5. {
  6. 	string s = "ab";
  7. 	s += "abcdeff";
  8. cout<<s<<endl;
  9. }

运行结果：

string &append(const char*str,int n);

  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. int main()
  5. {
  6. 	string s = "ab";
  7. 	s.append("abcdef", 3);
  8. 	cout << s << endl;
  9. }

运行结果：

string&append(int n,char ch);

  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. int main()
  5. {
  6. 	string s = "ab";
  7. 	s.append(3, '0');
  8. 	cout << s << endl;
  9. }

运行结果：

string 中的查找和替换

  1. //int find(const string&str,int pos=0)const查找str第一次出现的位置,默认从0号位置开始找
  2. //int find(const char*s,int pos=0)查找s第一次出现的位置从pos位置开始找
  3. // int find(const char*s,int pos,int n)从pos位置查找s的前n个字符第一次出现的位置
  4. //int find(const char c,int pos=0)查找字符c第一次出现的位置
  5. //int rfind(const string&str,int pos=npos)const查找str最后一次出现的位置，从pos位置开始找
  6. //int rfind(const char*s,int pos=npos)const 查找s最后一次出现的位置，从pos位置开始找
  7. //int rfind(const char*s,int pos,int n)从pos位置开始查找s前n个字符第一次出现的位置
  8. //int rfind(const char ch,int pos=0)const 查找字符ch最后一次出现的位置
  9. //string &replace (int pos,int n,const string&str)替换从pos位置开始n个字符为字符串
  10. //string &replace (int pos,int n,const char*s)替换从pos开始的n个字符为字符串s
  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. int main()
  5. {
  6. 	string s1="abcdef";
  7. 	string s2 = "abc";
  8. 	int ret = s1.find(s2);
  9. 	cout << ret;
  11. }

运行结果：

  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. int main()
  5. {
  6. 	string s1="abcdef";
  7. 	string s2 = "abc";
  8. 	int ret = s1.find(s2);
  9. 	cout << ret;
  11. }

我们在s1中查找s2中从0号位置开始

运行结果：

int rfind(string&s,int pos=npos);

  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. int main()
  5. {
  6. 	string s1="abcdefabc";
  7. 	string s2 = "abc";
  8. 	int ret = s1.rfind(s2);
  9. 	cout << ret;
  11. }

运行结果：

如果没有找到则会返回-1

find和rfind的区别：

find 是从从左往右找，而rfind是从右往左找

string 字串

  1. string substr(int pos=0,int n=npos)const 返回由pos开始的n个字符组成的字符串

例

  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. int main()
  5. {
  6. 	string s1="abcdefabc";
  7. 	cout << s1.substr(0, 3);
  9. }

运行结果：

string插入和删除操作

  1. /string&insert(int pos,const char*s)插入字符串
  2. //string&insert(int pos,const string&s)插入字符串
  3. //string&insert(int pos,int n,char c)在指定位置插入n个字符c
  4. //string&erase(int pos,int n=npos)删除从pos开始的n个字符

在这里就不测试了可以自己下来测试一下

string 中的c_str(重点）

string.c_str是Borland封装的String类中的一个函数，它返回当前字符串的首字符地址。

c_str函数的返回值是const char的，不能直接赋值给char，所以就需要我们进行相应的操作转化。
 

  1. #include<iostream>
  2. using namespace std;
  3. #include<algorithm>
  4. int main()
  5. {
  6. 	string s = "Chelse";
  7. 	const char* str = s.c_str();
  8. 	cout << str << endl;
  9. 	s[1] = 'm';
  10. 	cout << str << endl;
  12. }

运行结果：

第一个输出 当然是 Chelse；
第二个输出呢: Chelse还是Cmelse呢？
答案是Cmelse。
const char的值应该是个常量啊，怎么还能改变值呢？
这就是很多人遇到的坑儿，也许面试的时候你会顺利的回答出来，但是在实际的工程中，往往掉进坑儿里，难以自拔。
const char, char const*, char* const的区别是什么？老
const char与char const是等价的，指的是指向字符常量的指针，即指针可以改变指向但其指向的内容不可以改变。
而char* const相反，指的是常量指针，即指向不可以改变但指针指向的内容可以改变。因此这里的const char*指向的内容本类是不可以改变的。

那么这里为什么改变了呢？这跟str这个const char的生命周期及string类的实现有关，string的c_str()返回的指针是由string管理的，因此它的生命期是string对象的生命期，而string类的实现实际上封装着一个char的指针，而c_str()直接返回该指针的引用，因此string对象的改变会直接影响已经执行过的c_str()返回的指针引用。

string 模拟实现：

  1. #pragma once 
  2. #include<iostream>
  3. using namespace std;
  4. #include<string.h>
  5. #include<assert.h>
  6. namespace ksy {
  7. 	class string
  8. 	{
  9. 	public:
  10. 		typedef char* iterator;
  11. 		/*string() :_str(nullptr)
  12. 		{}
  13. 		string(char*str)
  14. 			:_str(str)
  15. 		{}*/
  16. 		/*string(const char* str = "")
  17. 			:_str(new char[strlen(str)+1])
  18. 		{
  19. 		
  20. 			strcpy(_str, str);
  22. 		}*/
  24. 		/*string&operator=(string& s) {
  25. 			if (&s != this) {
  26. 				char* tmp = new char[s.size() + 1];
  27. 				delete this->_str;
  28. 				strcpy(tmp, s._str);
  29. 				_str = tmp;
  30. 			}
  31. 			return *this;
  32. 		}*/
  33. 		
  34. 		void reserve(int n) {
  35. 			if (n > _capacity) {
  36. 				
  37. 				char* newstr = new char[n+1];
  38. 				strcpy(newstr, _str);
  39. 				delete[]_str;
  40. 				_str = newstr;
  41. 				_capacity = n;
  42. 			}
  43. 		}
  45. 		void resize(int n,char ch='\0') {
  46. 			if (n < _size) {
  47. 				_str[n] = '\0';
  48. 				_size = n;
  49. 			}
  50. 			else {
  51. 				if (n > _capacity) {
  52. 					reserve(n);
  53. 				}
  54. 				for (int i = _size; i < n; i++) {
  55. 					_str[i] = ch;
  56. 				}
  57. 				_size = n;
  58. 				_str[_size] = '\0';
  60. 			}
  62. 		}
  63. 		iterator begin() {
  64. 			return _str;
  65. 		}
  66. 		iterator end() {
  67. 			return _str + _size;
  68. 		}
  69. 		friend ostream& operator<<(ostream& cout, const string& s);
  70. 		friend istream& operator>>(istream& cin, string& s);
  72. 		string(const  char* str = "") {
  73. 			_size = strlen(str);
  74. 			_capacity = _size;
  75. 			_str = new char[_capacity + 1];//'\0'不是有效字符
  76. 			strcpy(_str, str);
  77. 		 }
  78. 		~string() {
  79. 			delete[]_str;
  80. 			_str = nullptr;
  81. 			_size = _capacity;
  82. 	}
  84. 		string(const string& s)
  85. 			:_str(nullptr)
  86. 		{
  87. 			string tmp(s._str);
  88. 			swap(_str, tmp._str);
  89. 	    }
  90. 		string& operator=(string s) {
  91. 			if (&s != this) {
  92. 				swap(_str, s._str);
  93. 			}
  94. 			return *this;
  95. 		}
  97. 		size_t size() {
  98. 			return _size;
  99. 		}
  101. 		size_t size()const {
  102. 			return _size;
  103. 		}
  105. 		size_t capacity() {
  106. 			return _capacity;
  107. 		}
  108. 		size_t capacity()const {
  109. 			return _capacity;
  110. 		}
  112. 		char& operator[](int i) {
  113. 			assert(i < _size);
  114. 			return _str[i];
  115. 		}
  117. 		const char& operator[](int i)const {
  118. 			assert(i < _size);
  119. 			return _str[i];
  120. 		}
  122. 		const char* c_str() {
  123. 			return _str;
  124. 		}
  125. 		void push_back(char ch) {
  126. 			if (_size == _capacity) {
  127. 				
  128. 				size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
  129. 				reserve(newcapacity);
  130. 			}
  131. 			_str[_size] = ch;
  132. 			_size++;
  133. 			_str[_size] = '\0';
  134. 		 }
  136. 		void append(const char*str) {
  137. 			int len = strlen(str);
  138. 			if (_size + len > _capacity) {
  139. 				reserve(_size + len);
  140. 			}
  141. 			strcpy(_str + _size, str);
  142. 			_size += len;
  143. 	  }
  144. 		string& operator +=(char ch) {
  145. 			this->push_back(ch);
  146. 			return *this;
  147. 	 }
  148. 	
  149. 		string& operator+=(const char* str) {
  150. 			this->append(str);
  151. 			return *this;
  152. 	      }
  153. 		
  154. 		string insert(size_t pos, char ch)
  155. 		{
  156. 			assert(pos > 0 && pos < _size);
  157. 			if (_size == _capacity) {
  158. 				size_t newcapacity = _capacity == 0 ? 2 : 2 * _capacity;
  159. 				reserve(newcapacity);
  160. 			}
  161. 			int end = _size;
  162. 			while (_size >= pos) {
  163. 				_str[end + 1] = _str[end];
  164. 				end--;
  165. 			}
  166. 			_str[pos] = ch;
  167. 			_size++;
  168. 			return *this;
  169. 		}
  170. 		string& insert(size_t pos, const char* str)
  171. 		{
  172. 			assert(pos < _size);
  173. 			int len = strlen(str);
  174. 			if (len + _size > _capacity) {
  175. 				reserve(len + _size);
  176. 			} 
  177. 			
  178. 			int end = _size;
  179. 			while (end >= pos) {
  180. 				_str[end+len] = _str[end];
  181. 				--end;
  182. 			}
  183. 			strncpy(_str + pos, str, len);
  184. 			_size += len;
  185. 			return *this;
  186. 		}
  187. 		string& erase(size_t pos, size_t len = npos)
  188. 		{
  189. 			assert(pos < _size);
  190. 			if (len >= _size - pos) {
  191. 				_str[pos] = '\0';
  192. 				_size = pos;
  193. 				}
  194. 			else {
  195. 				size_t i = pos + len;
  196. 				while (i <= _size) {
  197. 					_str[i - len] = _str[i];
  198. 					++i;
  199. 				}
  200. 				_size -= len;
  201. 			}
  202. 			return *this;
  203. 		}
  204. 		size_t  find(char ch, size_t pos = 0)
  205. 		{
  206. 			for (int i = pos; i < _size; i++) {
  207. 				if (_str[i] == ch) {
  208. 					return i;
  209. 				}
  210. 			}
  211. 			return npos;
  212. 		}
  214. 		size_t find(const char* str, size_t pos = 0)
  215. 		{
  216. 			char*p=strstr(_str, str);
  217. 			if (p == nullptr) {
  218. 				return npos;
  219. 			}
  220. 			else {
  221. 				return p - _str;
  222. 			}
  224. 		}
  225. 		bool operator<(const string& s)
  226. 		{
  227. 			int ret= strcmp(_str, s._str);
  228. 			return ret < 0;
  230. 		}
  232. 		bool operator>(const string& s)
  233. 		{
  234. 			int ret=strcmp(_str, s._str);
  235. 			return ret > 0;
  236. 		}
  238. 		bool operator<=(const string& s)
  239. 		{
  240. 			return *this < s || *this == s;
  241. 		}
  243. 		bool operator>=(const string& s)
  244. 		{
  245. 			return *this > s || *this == s;
  246. 		}
  248. 		bool operator!=(const string& s)
  249. 		{
  250. 			return !(*this == s);
  251. 		}
  253. 		bool operator==(const string& s)
  254. 		{
  255. 			int ret = strcmp(_str, s._str);
  256. 			return ret == 0;
  257. 		}
  259. 	private:
  260. 		char* _str;
  261. 		int _size;
  262. 		int _capacity;
  263. 		static size_t npos;
  264. 	};
  265. 	size_t string ::npos = -1;
  267.   ostream& operator<<(ostream& cout, const string& s) {
  268. 	  for (size_t i = 0; i < s.size(); i++) {
  269. 		  cout << s[i];
  270. 	  }
  271. 	  return cout;
  272. 	}
  273.   istream& operator>>(istream& cin, string& s) {
  274. 	  
  275. 	  while (1) {
  276. 		  char ch;
  277. 		  ch = cin.get();
  278. 		  if (ch == ' ' || ch == '\n') {
  279. 			  break;
  280. 		  }
  281. 		  else {
  282. 			  s += ch;
  283. 		  }
  285. 	  }
  286. 	  return cin;
  287.   }
  289.   void test_string() {
  290. 	  string s("hfdf");
  291. 	 /* cout << s << endl;
  292. 	  cout << s.capacity() << " " << s.size();
  293. 	  string s1(s);
  294. 	  cout << s1 << endl;
  295. 	  cout << s1.size() << " " << s1.capacity() << endl;*/
  296. 	  for (auto& e : s) {
  297. 		  cout << e;
  298. 	  }
  299.  }
  301. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_56999918/article/details/120879166

内容来源于网络，如有侵权，请联系作者删除！

c语言后端开发语言

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com