• 【C++--string模拟实现】

    一、基本思路

    新建一个项目，在项目中创建头文件string.h 源文件string.cpp

    在头文件中，先定义一个新的命名空间（为了防止与库中的string发生冲突），命名空间的名字可以按照自己意愿来命名。

    接下来就可以在命名空间中来模拟实现string类辣

    在实现的过程中可以多查查string::operator+= - C++ Reference (cplusplus.com)

    了解函数功能，然后再去实现 

    【1】确定成员变量： size_t _size; size_t _capacity; char* _str;

    【2】成员函数模拟实现

    （1）构造和析构函数

    1. 		string(const char* str = "")
    2. 		{
    3. 			_size = strlen(str);
    4. 			_capacity = _size;
    5. 			_str = new char[_size + 1];
    6. 		    my_strcpy(_str, str);//完成初始化工作
    7. 		}
    8. 		~string()
    9. 		{
    10. 			delete[] _str;
    11. 			_str = nullptr;
    12. 			_size = _capacity = 0;
    13. 			std::cout << "~string()" << std::endl;
    14. 		}

    （2）size()和capacity()

    1. 		size_t size()const
    2. 		{
    3. 			return _size;
    4. 		}
    5. 		size_t capacity()const
    6. 		{
    7. 			return _capacity;
    8. 		}

    （3）operator[ ]重载

    1. 		char& operator[](size_t pos)
    2. 		{
    3. 			assert(pos <= _size);
    4. 			return _str[pos];
    5. 		}

    （4）reserve()

    1. 		void reserve(size_t n = 0)
    2. 		{
    3. 			char* tmp = new char[n];//在堆区开辟空间，出函数不会销毁
    4. 			my_strcpy(tmp, _str);//由于有的vs使用strcpy会报错，所以可以用自己实现的strcpy
    5. 			delete[] _str;
    6. 			_str = tmp;
    7. 			_capacity = n;
    8. 		}

    （5）push_back()

    1. 		void push_back(char c)
    2. 		{
    3. 			if (_size == _capacity)
    4. 			{
    5. 				reserve(_capacity == 0 ? 6 : _capacity * 2);
    6. 			}
    7. 			_str[_size] = c;
    8. 			_size++;
    9. 			_str[_size] = '\0';
    10. 		}

    （6）operator+=的实现

    1. 		string& operator+= (char c)
    2. 		{
    3. 			push_back(c);
    4. 			return *this;
    5. 		}
    6. 		string& operator+= (const char* s)
    7. 		{
    8. 			size_t len = strlen(s);
    9. 			if (_size + len > _capacity)
    10. 			{
    11. 				reserve(_size + len+10);
    12. 			}
    13. 			append(s);
    14. 			return *this;
    15. 		}

    （7）append()

    1. 		string& append(const char* s)
    2. 		{
    3. 			size_t len = strlen(s);
    4. 			if (_size + len > _capacity)
    5. 			{
    6. 				reserve(_size + len + 10);
    7. 			}
    8. 			my_strcpy(_str + _size, s);
    9. 			return *this;
    10. 		}

    (8)c_str()

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

    (9)operator<<

    这个函数得在类外实现，因为在类内实现的话，默认第一个参数是this，那么在实际使用的时候对象名就得写在ostream的左边，与我们常规写法不一样。

    由于库中的_str是私有成员，因此可以通过调用函数c_str来获取_str

    1. std::ostream& operator<<(std::ostream& os, const abl::string& str)
    2. {
    3. 	os << str.c_str() ;
    4. 	return os;
    5. }

    (10)拷贝构造

    1. 		//现代写法
    2. 	string(const string& s)
    3. 		:_str(nullptr)
    4. 		,_size(0)
    5. 		,_capacity(0)
    6. 	{
    7. 		string tmp(s._str);//调用默认构造函数string(const char* str = "")
    8. 		swap(tmp);//this可能没有初始化，析构的时候就会报错，因此要写参数初始化列表
    9. 	}
    10. 		//string(const string& s)
    11. 		//{
    12. 		//	_str = new char[s._capacity + 1];
    13. 		//	memcpy(_str, s._str, s._size);
    14. 		//	_size = s._size;
    15. 		//	_capacity = s._capacity;
    16. 		//}

    (11)insert

    1. 		string& insert(size_t pos, size_t n, char c)
    2. 		{
    3. 			assert(pos <= _size);
    4. 			if (_size + n > _capacity)
    5. 			{
    6. 				reserve(_size + n);
    7. 			}
    8. 			size_t end = _size+n;
    9. 			for (; end>=pos+n; end--)
    10. 			{
    11. 				//abcd  size==4   pp  n==2  end==6  end-n==4
    12. 				_str[end] = _str[end-n];
    13. 			}
    14. 			for (size_t i = 0; i < n; i++)
    15. 			{
    16. 				_str[pos + i] = c;
    17. 			}
    18. 			_size += n;
    19. 			return *this;
    20.  
    21. 		}
    22. 		string& insert(size_t pos, const char* s, size_t n)
    23. 		{
    24. 			assert(pos <= _size);
    25. 			size_t len = strlen(s);
    26. 			if (_size + n > _capacity)
    27. 			{
    28. 				reserve(_size + n);
    29. 			}
    30. 			size_t end = _size + n;
    31. 			for (; end >= pos + n; end--)//当pos==0时，end>=pos恒成立，因为end为size_t类型，不可能是负数
    32. 			{
    33. 				//abcd  size==4   pp  n==2  end==6  end-n==4
    34. 				_str[end] = _str[end - n];
    35. 			}
    36. 			for (size_t i = 0; i < n; i++)
    37. 			{
    38. 				_str[pos + i] = s[i];
    39. 			}
    40. 			_size += n;
    41. 			return *this;
    42. 		}

    二、完整代码

    1、string.h
    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. //#include
    7. void my_strcpy(char* dest, const char* src) {
    8. 	while (*src != '\0') {
    9. 		*dest++ = *src++;
    10. 	}
    11. 	*dest = *src;   //拷贝\0
    12. }
    13.  
    14. namespace abl
    15. {
    16.  
    17. 	class string
    18. 	{
    19. 		//这里暂时还用不到友元，因为在operator>>中并没有访问string的私有成员
    20. 	//friend std::istream& operator>>(std::istream& in, string& s);
    21. 	private:
    22. 		size_t _size;
    23. 		size_t _capacity;
    24. 		char* _str;
    25. 		static size_t npos;
    26. 	public:
    27. 		
    28. 		typedef char* iterator;
    29. 		typedef const char* const_iterator;
    30. 		iterator begin()
    31. 		{
    32. 			return _str;//指向首元素
    33. 		}
    34. 		iterator end()
    35. 		{
    36. 			return _str + _size;//指向'\0'
    37. 		}
    38. 		const_iterator begin()const
    39. 		{
    40. 			return _str;
    41. 		}
    42. 		const_iterator end()const
    43. 		{
    44. 			return _str + _size;
    45. 		}
    46. 		string(const char* str = "")
    47. 		{
    48. 			_size = strlen(str);
    49. 			_capacity = _size;
    50. 			_str = new char[_size + 1];
    51. 		    memcpy(_str, str,_size+1);//完成初始化工作
    52. 		}
    53. 		~string()
    54. 		{
    55. 			//std::cout <<"::"<< _str << std::endl;
    56. 			delete[] _str;
    57. 			_str = nullptr;
    58. 			_size = _capacity = 0;
    59. 			std::cout << "~string()" << std::endl;
    60. 		}
    61. 		//现代写法
    62. 	string(const string& s)
    63. 		:_str(nullptr)
    64. 		,_size(0)
    65. 		,_capacity(0)
    66. 	{
    67. 		string tmp(s._str);//调用默认构造函数string(const char* str = "")
    68. 		swap(tmp);//this可能没有初始化，析构的时候就会报错，因此要写参数初始化列表
    69. 	}
    70. 		//string(const string& s)
    71. 		//{
    72. 		//	_str = new char[s._capacity + 1];
    73. 		//	memcpy(_str, s._str, s._size);
    74. 		//	_size = s._size;
    75. 		//	_capacity = s._capacity;
    76. 		//}
    77.  
    78. 		void swap(string& tmp)
    79. 		{
    80. 			std::swap(_str, tmp._str);
    81. 			std::swap(_size, tmp._size);
    82. 			std::swap(_capacity, tmp._capacity);
    83. 		}
    84. 		//现代写法
    85. 		string& operator= (string& s)
    86. 		{
    87. 			if (this != &s)
    88. 			{
    89. 				string tmp(s);//调用拷贝构造（深拷贝）
    90. 				swap(tmp);
    91. 			}
    92. 			return *this;
    93. 		}
    94. 		size_t size()const
    95. 		{
    96. 			return _size;
    97. 		}
    98. 		size_t capacity()const
    99. 		{
    100. 			return _capacity;
    101. 		}
    102. 		char& operator[](size_t pos)
    103. 		{
    104. 			assert(pos <= _size);
    105. 			return _str[pos];
    106. 		}
    107. 		void reserve(size_t n = 0)
    108. 		{
    109. 			//多留出一个空位给\0
    110. 			char* tmp = new char[n+1];//在堆区开辟空间，出函数不会销毁
    111. 			my_strcpy(tmp, _str);
    112. 			delete[] _str;
    113. 			_str = tmp;
    114. 			_capacity = n;
    115. 			//只改变了capacity，没有改变size，size不变
    116. 		}
    117. 		void push_back(char c)
    118. 		{
    119. 			if (_size == _capacity)
    120. 			{
    121. 				reserve(_capacity == 0 ? 6 : _capacity * 2);
    122. 			}
    123. 			_str[_size] = c;
    124. 			_size++;
    125. 			_str[_size] = '\0';
    126. 		}
    127. 		string& operator+= (char c)
    128. 		{
    129. 			push_back(c);
    130. 			return *this;
    131. 		}
    132. 		string& operator+= (const char* s)
    133. 		{
    134. 			size_t len = strlen(s);
    135. 			if (_size + len > _capacity)
    136. 			{
    137. 				reserve(_size + len+10);
    138. 			}
    139. 			append(s);
    140. 			return *this;
    141. 		}
    142. 		string& append(const char* s)
    143. 		{
    144. 			size_t len = strlen(s);
    145. 			if (_size + len > _capacity)
    146. 			{
    147. 				reserve(_size + len + 1);
    148. 			}
    149. 			memcpy(_str + _size, s,len+1);
    150. 			_size += len;
    151. 			return *this;
    152. 		}
    153. 		string& insert(size_t pos, size_t n, char c)
    154. 		{
    155. 			assert(pos <= _size);
    156. 			if (_size + n > _capacity)
    157. 			{
    158. 				reserve(_size + n);
    159. 			}
    160. 			size_t end = _size+n;
    161. 			for (; end>=pos+n; end--)
    162. 			{
    163. 				//abcd  size==4   pp  n==2  end==6  end-n==4
    164. 				_str[end] = _str[end-n];
    165. 			}
    166. 			for (size_t i = 0; i < n; i++)
    167. 			{
    168. 				_str[pos + i] = c;
    169. 			}
    170. 			_size += n;
    171. 			return *this;
    172.  
    173. 		}
    174. 		string& insert(size_t pos, const char* s, size_t n)
    175. 		{
    176. 			assert(pos <= _size);
    177. 			size_t len = strlen(s);
    178. 			if (_size + n > _capacity)
    179. 			{
    180. 				reserve(_size + n);
    181. 			}
    182. 			size_t end = _size + n;
    183. 			for (; end >= pos + n; end--)//当pos==0时，end>=pos恒成立，因为end为size_t类型，不可能是负数
    184. 			{
    185. 				//abcd  size==4   pp  n==2  end==6  end-n==4
    186. 				_str[end] = _str[end - n];
    187. 			}
    188. 			for (size_t i = 0; i < n; i++)
    189. 			{
    190. 				_str[pos + i] = s[i];
    191. 			}
    192. 			_size += n;
    193. 			return *this;
    194. 		}
    195. 		//string& erase(size_t pos = 0, size_t len = npos)
    196. 		//{
    197.  
    198. 		//}
    199. 		bool operator<(string& s)const
    200. 		{
    201. 			size_t i1 = 0, i2 = 0;//遍历两个字符串4
    202. 			while (i1 < _size && i2 < s._size)
    203. 			{
    204. 				if (_str[i1] < s._str[i2])
    205. 				{
    206. 					return true;
    207. 				}
    208. 				else if (_str[i1] > s._str[i2])
    209. 				{
    210. 					return false;
    211. 				}
    212. 				else
    213. 				{
    214. 					i1++;
    215. 					i2++;
    216. 				}
    217. 			}
    218. 			//若循环正常进行结束，可能出现的情况：
    219. 			//hello hello     return false
    220. 			//hellowwww hello return false
    221. 			//hello hellowww  return true
    222. 			if (_size < s._size)
    223. 			{
    224. 				return true;
    225. 			}
    226. 			return false;
    227. 		}
    228. 		bool operator==(string& s)const
    229. 		{
    230. 			//std::cout << s._size << std::endl;
    231. 			if (_size != s._size)
    232. 			{
    233. 				return false;
    234. 			}
    235. 			return memcmp(_str, s._str, _size) == 0;
    236. 		}
    237. 		bool operator>(string& s)const
    238. 		{
    239. 			return !((*this < s) || (*this == s));
    240. 		}
    241. 		bool operator<=(string& s)const
    242. 		{
    243. 			return !(*this > s);
    244. 		}
    245. 		bool operator>=(string& s)const
    246. 		{
    247. 			return !(*this < s);
    248. 		}
    249. 		//string& operator= (const string& s)
    250. 		//{
    251. 		//	//开辟新空间，进行拷贝
    252. 		//	if (this != &s)//如果两个对象不相同
    253. 		//	{
    254. 		//		char* tmp = new char[s._capacity + 1];
    255. 		//		memcpy(tmp, s._str, s._size);
    256. 		//		delete[] _str;
    257. 		//		_str = tmp;
    258. 		//		_size = s._size;
    259. 		//		_capacity = s._capacity;
    260. 		//	}
    261. 		//	return *this;
    262. 		//}
    263. 		//void swap(string& str)
    264. 		//{
    265. 		//	
    266. 		//}
    267. 		//template
    268. 		//void swap(T m)
    269. 		//{
    270. 		//	T tmp = m;
    271. 		//	m = *this;
    272. 		//	*this = tmp;
    273. 		//}
    274.  
    275. 		const char* c_str()const
    276. 		{
    277. 			return _str;
    278. 		}
    279. 		void clear()
    280. 		{
    281. 			_str[0] = '\0';
    282. 			_size = 0;
    283. 		}
    284. 	};
    285. }
    286. //std::ostream& operator<<(std::ostream& os, const abl::string& str)
    287. //{
    288. //	os << str._str << std::endl;
    289. //	return os;
    290. //}
    291. size_t abl::string::npos = -1;//静态成员变量必须初始化，并且只能在类体外进行初始化
    292. std::ostream& operator<<(std::ostream& out,const abl::string& str)
    293. {
    294. 	for (auto ch : str)
    295. 	{
    296. 		out << ch;
    297. 	}
    298. 	//out << str.c_str();
    299. 	return out;
    300. }
    301. std::istream& operator>>(std::istream& in, abl::string& s)
    302. {
    303. 	s.clear();
    304. 	char bucket[128];//相当于一个桶，装满了再往s里边加，减少了开辟空间的次数，充分利用空间
    305. 	char c=in.get();
    306. 	int i = 0;
    307. 	while (c != ' ' && c != '\n')
    308. 	{
    309. 		bucket[i] = c;
    310. 		i++;
    311. 		
    312. 		if (i == 127)
    313. 		{
    314. 			bucket[i] = '\0';//operator+=中要计算bucket的长度，以'\0'为终止条件，因此要在最后加上
    315. 			s += bucket;
    316. 			i = 0;//重新往buckt里边放入数据
    317. 		}
    318. 		c = in.get();
    319. 	}
    320. 	if (i != 0)
    321. 	{
    322. 		bucket[i] = '\0';//...
    323. 		s += bucket;
    324. 	}
    325.  
    326. 	return in;
    327. }
    2、string.cpp
    1. #include 
    2. #include 
    3. #include "String.h"
    4. using namespace std;
    5.  
    6. void test_string1()
    7. {
    8.     abl::string s1("hello world");
    9.     abl::string s2("legacy.cplusplus.com");
    10.     string s3("jdksanxkdsd");
    11.     string s4;
    12.     cout << s3.c_str() << endl;
    13.     cout << s4.c_str() << endl;
    14.     cout << s1.c_str() << endl;
    15.     for (size_t i = 0; i < s1.size(); i++)
    16.     {
    17.         cout << s1[i] << " ";
    18.     }
    19.     cout << endl;
    20.     cout << s2.c_str() << endl;
    21.     abl::string::iterator it = s2.begin();
    22.     while(it!=s2.end())
    23.     {
    24.         cout << *it << " ";
    25.         ++it;
    26.     }
    27.     cout << endl;
    28.     cout << s2 << endl;
    29. }
    30. void test_string2()
    31. {
    32.     //string s1("hello");
    33.     //cout << s1 << endl;
    34.     //cout << s1.capacity() << endl;
    35.  
    36.     //abl::string s2("world");
    37.     cout << s2.capacity() << endl;
    38.     //s2.push_back('c');
    39.     //s2.push_back('c');
    40.     //s2.push_back('c');
    41.     //cout << s2 << endl;
    42.     //s2 += 's';
    43.     //cout << s2 << endl;
    44.     //s2 += "good";
    45.     //cout << s2 << endl;
    46.     abl::string s3("hello");
    47.     s3.append(" judy");
    48.     cout << s3 << endl;
    49.     //abl::string s4("helloooo");
    50.     s4 += '\0';
    51.     //cout << s4 << endl;
    52.     //s4 += "wwwwwww";
    53.     //s4.insert(2, 3, 'y');
    54.     //cout << s4 << endl;
    55.     //abl::string s5("hello");
    56.     //s5.insert(2, 5, 'p');
    57.     //cout << s5 << endl;
    58.     //s5.insert(9, "world", 6);
    59.     //cout << s5 << endl;
    60.     //for (auto ch : s5)
    61.     //{
    62.     //    cout << ch;
    63.     //}
    64.     //cout << endl;
    65.  
    66.     //string s6;
    67.     //cin >> s6;
    68.     //cout << s6 << endl;
    69.     //cin >> s6;
    70.     //cout << s6;
    71.    /* cout << s4.npos << endl;*/
    72. }
    73. void test_string3()
    74. {
    75.     abl::string s1("hello");
    76.     abl::string s2("helloxxxxx");
    77.     //cout << (s2 < s1) << endl;
    78.     abl::string s3("hello");
    79.     //cout << (s1 == s2) << endl;
    80.     //cout << (s1 == s3) << endl;
    81.     cout << (s2 >= s3) << endl;
    82.     cout << (s1 >= s2) << endl;
    83.     cout << (s1 >= s3) << endl;
    84. }
    85. void test_string4()
    86. {
    87.     abl::string s1("helloxxxxxxxxxxx");
    88.     //abl::string s2;
    89.     //s2 = s1;
    90.     //cout << s1 << endl;
    91.     //cout << s2 << endl;
    92.     //s1.append(" world");
    93.     abl::string s2("worldxxx");
    94.     s1 = s2;
    95.     cout << s1 << endl;
    96.     cout << s2 << endl;
    97. }
    98. int main()
    99. {
    100.     //test_string4();
    101.     string s("hello world");
    102.     string::iterator it = s.begin();
    103.     while (it != s.end())
    104.     {
    105.         *it = 'x';
    106.         it++;
    107.     }
    108.     cout << s << endl;
    109.     return 0;
    110. }

  • 相关阅读:
    RFSoC应用笔记 - RF数据转换器 -07- RFSoC关键配置之RF-DAC内部解析（一）
    第2-4-5章 规则引擎Drools高级语法-业务规则管理系统-组件化-中台
    Redis的安全网：掌握RDB和AOF的持久化技术【redis第四部分】
    Java23种设计模式-行为型模式之命令模式
    实时天气API
    计算机毕业设计Java学科竞赛管理系统（源码+系统+mysql数据库+Lw文档）
    ArcGIS_地质多样性评价方法
    Vue框架学习记录之环境安装与第一个Vue项目
    如何完善文件传输审批流程，降低企业文件安全风险？
    Serialiable接口和serialVersionUID的作用及其在redisson中的应用
  • 原文地址：https://blog.csdn.net/awww224112/article/details/133952383