• C++:string的使用

    目录

    1、string的介绍

    2、string的初始化 

    2.1、方法1 

    2.2、方法2

    2.3、方法3

     2.4、方法4

      2.5、方法5

       2.6、方法6

    3、string的赋值运算符重载

    4、 string的常用内置函数使用 

     5、string的遍历

    4.1数组下标访问

    4.2迭代器 

    4.3范围for 

     6、模拟实现MyString

    6.1、头文件：MyString.h

    6.2、源文件：MyString.cpp

    1、string的介绍

    string 是表示字符串的字符串类

    2、string的初始化 

    2.1、方法1 

    1.     string();
    2. //空字符串构造函数（默认构造函数),构造一个长度为零个字符的空字符串。
    3. 	string s;

    2.2、方法2

    1.     string(const string & str);
    2. //拷贝构造函数,构造str的副本
    3. 	string s1(str);

    2.3、方法3

    1.     string(const string & str, size_t pos, size_t len = npos);
    2. //子字符串构造函数,复制str中从字符位置pos开始并跨越len个字符的部分
    3. //（如果str太短或len为string::npos，则复制到str的末尾）
    4. 	string s2(s, 1, 2);

     2.4、方法4

    1.      
    2.     string (const char* s);
    3. //复制s指向的以'\0'结尾的字符序列
    4. 	string s3("A character sequence");
    5.  
    6.     string (const char* s, size_t n);
    7. //从s指向的字符数组中复制前n个字符
    8. 	string s4("Another character sequence", 12);

      2.5、方法5

    1.     string(size_t n, char c);
    2. //用字符c的n个连续副本填充字符串。
    3. 	string s5(10, 'x');
    4. 	string s6(10, 100);    //100是ascll码值

       2.6、方法6

    1. //迭代器初始化
    2. 	string(InputIterator first, InputIterator last);
    3. 	string s7(s.begin(), s.begin() + 7);

    3、string的赋值运算符重载

    1.     string str1, str2, str3;
    2.     string & operator= (const char* s);
    3. 	str1 = "Test string: ";   
    4.  
    5. 	string& operator= (char c);
    6. 	str2 = 'x';               
    7.  
    8.     string& operator= (const string & str);    
    9. 	str3 = str1 + str2; 
    10.     str3 = str1;

    4、 string的常用内置函数使用 

    1. string v(10, 'x');
    2. 	string v1 = "www";
    3. 	//Iterators(迭代器)
    4. 	v.begin();          //获取第一个数的位置
    5. 	v.end();            //获取最后一个数的位置
    6. 	v.rbegin();         //获取最后一个数的位置
    7. 	v.rend();           //获取第一个数的位置
    8.  
    9. 	//Capacity(容量)
    10. 	v.size();           //获取v数据的个数
    11. 	v.length();         //获取v数据的个数
    12. 	v.max_size();       //返回字符串可以达到的最大长度
    13. 	v.clear();          //擦除字符串的内容，该字符串将变为空字符串（长度为0个字符）
    14. 	v.capacity();       //获取v容量的大小
    15. 	v.empty();          //判断v是否为空
    16. 	v.resize(10);       //改变vector的size,将v的现有元素个数调整至10个，多则删，少则补，其值随机
    17. 	v.resize(10, 3);    //将v的现有元素个数调整至10个，多则删，少则补，并且赋值为3
    18. 	v.reserve(100);     //改变vector的capacity,将v的容量扩充至100
    19.  
    20. 	//Element access(元素访问)
    21. 	v[0];               //下标访问
    22. 	v.at(3);            //返回对字符串中位置pos处的字符的引用
    23. 	//与下标访问的区别，函数会自动检查pos是否是字符串中字符的有效位置
    24. 	//（即pos是否小于字符串长度），如果不是，则抛出out_of_range异常                    
    25.  
    26. 	//Modifiers（修改器）
    27. 	v += " K. ";                  //通过在字符串的当前值末尾附加附加字符来扩展字符串
    28. 	v.append(v1);                 //通过在字符串的当前值末尾附加附加字符来扩展字符串
    29. 	v.append(v1, 6, 3);                   
    30. 	v.append("dots are cool", 5);          
    31. 	v.append("here: ");                                      
    32. 	v.append(v1.begin(), v1.end());
    33. 	v.assign("c-string");          //为字符串指定一个新值，替换其当前内容
    34. 	v.swap(v1);                    //交换
    35. 	v.pop_back();                 //尾删
    36. 	v.push_back(5);               //尾插一个数，值为5
    37. 	v.insert(v.begin(), 2);       //在pos前插入元素，例如头插2
    38. 	v.erase(v.begin());           //删除pos位置的数据，例如头删
    39.  
    40. 	//string operations(字符串操作)
    41. 	v.c_str();                   //字符转整型
    42.  
    43. 	
    44. 	getline(cin, v);            //输入值到v中，直到回车

     5、string的遍历

    4.1数组下标访问

    1. string a("www.6666.hh");
    2. for(int i = 0;i <= a.size() - 1;++i)
    3. {
    4.     cout << a[i] << endl;
    5. }

    4.2迭代器 

    1.     string::iterator it = a.begin();
    2. 	while (it != a.end())
    3. 	{
    4. 		cout << *it << " ";
    5. 		++it;
    6. 	}
    7. 	cout << endl;

    4.3范围for 

    1. for (auto ch : a)
    2. 	{
    3. 		cout << ch << " ";
    4. 	}
    5. 	cout << endl;

     6、模拟实现MyString

    6.1、头文件：MyString.h

    1. #pragma once
    2. #include
    3. #include 
    4. #include 
    5. #include 
    6.  
    7.  
    8.  
    9.  
    10. 	class MyString
    11. 	{
    12. 	public:
    13. 		typedef char* iterator;
    14. 		typedef const char* const_iterator;
    15.  
    16. 		iterator begin()
    17. 		{
    18. 			return _str;
    19. 		}
    20.  
    21. 		iterator end()
    22. 		{
    23. 			return _str + _size;
    24. 		}
    25.  
    26. 		const_iterator begin() const
    27. 		{
    28. 			return _str;
    29. 		}
    30.  
    31. 		const_iterator end() const
    32. 		{
    33. 			return _str + _size;
    34. 		}
    35.  
    36. 		//MyString();
    37. 		MyString(const char* str = "");
    38. 		MyString(const MyString& s);
    39. 		~MyString();
    40.  
    41. 		void swap(MyString& s);
    42. 		MyString& operator=(MyString tmp);
    43.  
    44. 		char& operator[](size_t pos);
    45. 		const char& operator[](size_t pos) const;
    46. 	
    47. 		size_t capacity() const;
    48. 		size_t size() const;
    49. 		void reserve(size_t n);
    50. 		void resize(size_t n, char ch = '\0');
    51. 		void clear();
    52. 		
    53. 		size_t find(char ch, size_t pos = 0);
    54. 		size_t find(const char* sub, size_t pos = 0);
    55. 		void push_back(char ch);
    56. 		void append(const char* str);
    57. 		void insert(size_t pos, char ch);
    58. 		void insert(size_t pos, const char* str);
    59. 		void erase(size_t pos, size_t len = npos);
    60.  
    61. 		MyString& operator+=(char ch);
    62. 		MyString& operator+=(const char* str);
    63. 		bool operator<(const MyString& s) const;
    64. 		bool operator==(const MyString& s) const;
    65. 		bool operator<=(const MyString& s) const;
    66. 		bool operator>(const MyString& s) const;
    67. 		bool operator>=(const MyString& s) const;
    68. 		bool operator!=(const MyString& s) const;
    69.  
    70. 		MyString substr(size_t pos, size_t len = npos);
    71. 		const char* c_str() const;
    72.  
    73.  
    74. 	private:
    75. 		char* _str;
    76. 		size_t _size;
    77. 		size_t _capacity;
    78. 	public:
    79. 		const static size_t npos;
    80. 	};
    81.  
    82. 	std::ostream& operator<<(std::ostream& out, const MyString& s);
    83. 	std::istream& operator>>(std::istream& in, MyString& s);

    6.2、源文件：MyString.cpp

    1. #include"MyString.h"
    2.  
    3. const size_t MyString::npos = -1;
    4. //MyString::MyString()
    5. //	:_str(new char[1] {'\0'})
    6. //	, _size(0)
    7. //	, _capacity(0)
    8. //{}
    9.  
    10. MyString::MyString(const char* str)
    11. 	:_size(strlen(str))
    12. 	, _capacity(_size)
    13. {
    14. 	_str = new char[_capacity + 1];
    15. 	strcpy(_str, str);
    16. }
    17.  
    18. void MyString::swap(MyString& s)
    19. {
    20. 	std::swap(_str, s._str);
    21. 	std::swap(_size, s._size);
    22. 	std::swap(_capacity, s._capacity);
    23. }
    24.  
    25. // s2(s1)
    26. MyString::MyString(const MyString& s)
    27. 	:_str(nullptr)
    28. 	, _size(0)
    29. 	, _capacity(0)
    30. {
    31. 	MyString tmp(s._str);
    32. 	swap(tmp);
    33. }
    34.  
    35. // s2 = s3
    36. MyString& MyString::operator=(MyString tmp)
    37. {
    38. 	swap(tmp);
    39. 	return *this;
    40. }
    41.  
    42. MyString::~MyString()
    43. {
    44. 	delete[] _str;
    45. 	_str = nullptr;
    46. 	_size = _capacity = 0;
    47. }
    48.  
    49. char& MyString::operator[](size_t pos)
    50. {
    51. 	assert(pos < _size);
    52.  
    53. 	return _str[pos];
    54. }
    55.  
    56. const char& MyString::operator[](size_t pos) const
    57. {
    58. 	assert(pos < _size);
    59. 	return _str[pos];
    60. }
    61.  
    62. size_t MyString::capacity() const
    63. {
    64. 	return _capacity;
    65. }
    66.  
    67. size_t MyString::size() const
    68. {
    69. 	return _size;
    70. }
    71.  
    72. const char* MyString::c_str() const
    73. {
    74. 	return _str;
    75. }
    76.  
    77. void MyString::reserve(size_t n)
    78. {
    79. 	if (n > _capacity)
    80. 	{
    81. 		char* tmp = new char[n + 1];
    82. 		strcpy(tmp, _str);
    83. 		delete[] _str;
    84. 		_str = tmp;
    85.  
    86. 		_capacity = n;
    87. 	}
    88. }
    89.  
    90. void MyString::resize(size_t n, char ch)
    91. {
    92. 	if (n <= _size)
    93. 	{
    94. 		_str[n] = '\0';
    95. 		_size = n;
    96. 	}
    97. 	else
    98. 	{
    99. 		reserve(n);
    100. 		while (_size < n)
    101. 		{
    102. 			_str[_size] = ch;
    103. 			++_size;
    104. 		}
    105.  
    106. 		_str[_size] = '\0';
    107. 	}
    108. }
    109.  
    110. size_t MyString::find(char ch, size_t pos)
    111. {
    112. 	for (size_t i = pos; i < _size; i++)
    113. 	{
    114. 		if (_str[i] == ch)
    115. 		{
    116. 			return i;
    117. 		}
    118. 	}
    119.  
    120. 	return npos;
    121. }
    122.  
    123. size_t MyString::find(const char* sub, size_t pos)
    124. {
    125. 	const char* p = strstr(_str + pos, sub);
    126. 	if (p)
    127. 	{
    128. 		return p - _str;
    129. 	}
    130. 	else
    131. 	{
    132. 		return npos;
    133. 	}
    134. }
    135.  
    136. MyString MyString::substr(size_t pos, size_t len)
    137. {
    138. 	MyString s;
    139. 	size_t end = pos + len;
    140. 	if (len == npos || pos + len >= _size) // 有多少取多少
    141. 	{
    142. 		len = _size - len;
    143. 		end = _size;
    144. 	}
    145.  
    146. 	s.reserve(len);
    147. 	for (size_t i = pos; i < end; i++)
    148. 	{
    149. 		s += _str[i];
    150. 	}
    151.  
    152. 	return s;
    153. }
    154.  
    155. void MyString::push_back(char ch)
    156. {
    157. 	if (_size == _capacity)
    158. 	{
    159. 		reserve(_capacity == 0 ? 4 : _capacity * 2);
    160. 	}
    161.  
    162. 	_str[_size] = ch;
    163. 	++_size;
    164. 	_str[_size] = '\0';
    165. }
    166.  
    167. void MyString::append(const char* str)
    168. {
    169. 	size_t len = strlen(str);
    170. 	if (_size + len > _capacity)
    171. 	{
    172. 		reserve(_size + len);
    173. 	}
    174.  
    175. 	strcpy(_str + _size, str);
    176. 	_size += len;
    177. }
    178.  
    179. MyString& MyString::operator+=(char ch)
    180. {
    181. 	push_back(ch);
    182. 	return *this;
    183. }
    184.  
    185. MyString& MyString::operator+=(const char* str)
    186. {
    187. 	append(str);
    188. 	return *this;
    189. }
    190.  
    191. // insert(0, 'x')
    192. void MyString::insert(size_t pos, char ch)
    193. {
    194. 	assert(pos <= _size);
    195. 	if (_size == _capacity)
    196. 	{
    197. 		reserve(_capacity == 0 ? 4 : _capacity * 2);
    198. 	}
    199.  
    200. 	size_t end = _size + 1;
    201. 	while (end > pos)
    202. 	{
    203. 		_str[end] = _str[end - 1];
    204. 		--end;
    205. 	}
    206.  
    207. 	_str[pos] = ch;
    208. 	_size++;
    209. }
    210.  
    211. void MyString::insert(size_t pos, const char* str)
    212. {
    213. 	assert(pos <= _size);
    214.  
    215. 	size_t len = strlen(str);
    216. 	if (_size + len > _capacity)
    217. 	{
    218. 		reserve(_size + len);
    219. 	}
    220.  
    221. 	// 挪动数据
    222. 	int end = _size;
    223. 	while (end >= (int)pos)
    224. 	{
    225. 		_str[end + len] = _str[end];
    226. 		--end;
    227. 	}
    228.  
    229. 	strncpy(_str + pos, str, len);
    230. 	_size += len;
    231. }
    232.  
    233. void MyString::erase(size_t pos, size_t len)
    234. {
    235. 	assert(pos < _size);
    236.  
    237. 	if (len == npos || pos + len >= _size)
    238. 	{
    239. 		_str[pos] = '\0';
    240. 		_size = pos;
    241. 	}
    242. 	else
    243. 	{
    244. 		size_t begin = pos + len;
    245. 		while (begin <= _size)
    246. 		{
    247. 			_str[begin - len] = _str[begin];
    248. 			++begin;
    249. 		}
    250. 		_size -= len;
    251. 	}
    252. }
    253.  
    254. bool MyString::operator<(const MyString& s) const
    255. {
    256. 	return strcmp(_str, s._str) < 0;
    257. }
    258.  
    259. bool MyString::operator==(const MyString& s) const
    260. {
    261. 	return strcmp(_str, s._str) == 0;
    262. }
    263.  
    264. bool MyString::operator<=(const MyString& s) const
    265. {
    266. 	return *this < s || *this == s;
    267. }
    268.  
    269. bool MyString::operator>(const MyString& s) const
    270. {
    271. 	return !(*this <= s);
    272. }
    273.  
    274. bool MyString::operator>=(const MyString& s) const
    275. {
    276. 	return !(*this < s);
    277. }
    278.  
    279. bool MyString::operator!=(const MyString& s) const
    280. {
    281. 	return !(*this == s);
    282. }
    283.  
    284. void MyString::clear()
    285. {
    286. 	_str[0] = '\0';
    287. 	_size = 0;
    288. }
    289.  
    290. std::ostream& operator<<(std::ostream& out, const MyString& s)
    291. {
    292. 	for (auto ch : s)
    293. 		out << ch;
    294.  
    295. 	return out;
    296. }
    297.  
    298. std::istream& operator>>(std::istream& in, MyString& s)
    299. {
    300.  
    301. 	s.clear();
    302.  
    303. 	char buff[129];
    304. 	size_t i = 0;
    305.  
    306. 	char ch;
    307. 	ch = in.get();
    308. 	while (ch != ' ' && ch != '\n')
    309. 	{
    310. 		buff[i++] = ch;
    311. 		if (i == 128)
    312. 		{
    313. 			buff[i] = '\0';
    314. 			s += buff;
    315. 			i = 0;
    316. 		}
    317.  
    318. 		//s += ch;
    319.  
    320. 		ch = in.get();
    321. 	}
    322.  
    323. 	if (i != 0)
    324. 	{
    325. 		buff[i] = '\0';
    326. 		s += buff;
    327. 	}
    328.  
    329. 	return in;
    330. }

  • 相关阅读:
    springBoot 源码三：Starter机制和springboot整合tomcat
    财务RPA与数字化转型——财务RPA如何促进企业的数字化转型
    Nginx 安装配置和实际使用
    React基础教程：TodoList案例
    #paypay付款测试#
    教授 Avi Wigderson荣获2023年图灵奖
    k8s集群新增计算节点使用华为iscsi存储创建的pvc存储挂载报错：FailedMount
    王杰qtday3
    WPFdatagrid结合comboBox
    Docker部署私有仓库Harbor
  • 原文地址：https://blog.csdn.net/weixin_74268082/article/details/134054441