• C++ 【模板和string模拟实现】

    string模拟实现

    构造函数+析构函数

    拷贝构造函数：深拷贝

    赋值运算符拷贝

    resize和reserve

    push_back && append

    insert

    erase

    << && >>

    迭代器

    迭代器模拟实现

    c_str(cpp中使用了string，要和c语言兼容，用c去读文件等)

    find和substr

    getline练习题

    运算符重载

    to_string:从字符串转换-其他转字符串函数

    string模拟实现

    构造函数+析构函数

    注意：1.空对象初始化时开一个空间：\0

    2.写全缺省，隐含了一个\0，只要是常量字符串，后面都已\0为结尾

    1. 	/*string()  //无参构造函数
    2. 		:_str(new char[1])
    3. 		,_size(0)
    4. 		,_capacity(0)
    5. 	{
    6. 		_str[0] = '\0';
    7. 	}*/
    8.  
    9. 	//string(const char* str = "")//strlen时间复杂度O（N）
    10. 	//	:_str(new char[strlen(str)+1])
    11. 	//	,_size(strlen(str))
    12. 	//	, _capacity(strlen(str))//capacity不包含\0，只统计有效字符
    13. 	//{
    14. 	//	strcpy(_str, str);
    15. 	//}
    16.  
    17. 	string(const char* str = "")//全缺省，隐含了一个\0，只要是常量字符串，后面都已\0为结尾
    18. 	{
    19. 		_size = strlen(str);
    20. 		_capacity = _size;
    21. 		_str = new char[_capacity + 1];
    22. 		strcpy(_str, str);
    23. 	}
    24.  
    25. 		~string()
    26. 		{
    27. 			delete[] _str;
    28. 			_str = nullptr;
    29. 			_size = _capacity = 0;
    30. 		}

    拷贝构造函数：深拷贝

    默认的拷贝构造，代码崩溃原因：浅拷贝指向同一块空间并析构两次（默认生成拷贝构造对内置类型值拷贝） 

    1. 	void test_string2()
    2. 	{	
    3. 		string s1("hello world");
    4. 		string s2(s1);
    5. 		cout << s1.c_str() << endl;
    6. 		cout << s2.c_str() << endl;
    7.  
    8. 	}

    正确的普通写法

    1. 	string(const string& s)//s2(s1)
    2. 		:_str(new char[s._capacity+1])//capacity存储有效数据空间，每次都多开一个\0
    3. 		,_size(s._size)
    4. 		,_capacity(s._capacity)
    5. 	{
    6. 		strcpy(_str, s._str);
    7. 	}

    正确的现代写法 --利用构造函数swap

    把随机数换给tmp导致程序崩溃--析构释放随机空间 

    1. 	string(const string& s)//s2(s1)
    2. 	{
    3. 		string tmp(s._str);//tmp是打工人，s._str是const字符串，相当于调用构造函数，s2想要一样大的空间和一样大的值
    4. 		swap(_str, tmp._str);
    5. 		swap(_size, tmp._size);
    6. 		swap(_capacity, tmp._capacity);
    7. 	}

    再改进：放nullptr，delete nullptr不会报错

    1. 	void swap(string& tmp)
    2. 	{
    3. 		::swap(_str, tmp._str);//::调用全局swap
    4. 		::swap(_size, tmp._size);
    5. 		::swap(_capacity, tmp._capacity);
    6. 	}
    7.  
    8. 	string(const string& s)//s2(s1)
    9. 		:_str(nullptr)
    10. 		,_size(0)
    11. 		,_capacity(0)
    12. 	{
    13. 		string tmp(s._str);//tmp是打工人，s._str是const字符串，相当于调用构造函数
    14. 		swap(tmp);//s2和tmp交换
    15. 	}

    赋值运算符拷贝

     默认的赋值代码崩溃原因：同样的浅拷贝报错，只是依次拷贝给s1，内存泄漏+析构两次

    1. 	void test_string3()
    2. 	{
    3. 		string s1("hello world");
    4. 		string s3("ww");
    5. 		s1 = s3;
    6. 	}

    正确的普通写法（直接释放旧空间重新开辟）

      自己给自己赋值（释放后随机值拷贝给自己）解决方法：判断相等

    1.     string& operator=(const string& s)
    2. 	{
    3. 		if (this != &s)
    4. 		{
    5. 			char* tmp  = new char[s._capacity + 1];
    6.         //先开空间再释放，防止new失败抛异常破坏原数据
    7. 			strcpy(tmp, s._str);
    8. 			delete[] _str;
    9. 			_str = tmp;
    10. 			_size = s._size;
    11. 			_capacity = s._capacity;
    12. 		}
    13. 		return *this;
    14. 	}

    现代写法

    1.错误的写法,此处swap包含赋值，死循环

    1.    string& operator=(const string& s)
    2. 	{
    3. 		if (this != &s)
    4. 		{
    5. 			string tmp(s);//调拷贝构造
    6. 			::swap(*this,tmp);
    7. 		}
    8. 		return *this;
    9. 	}

    2.直接使用全局中的swap包含了一次拷贝构造，两次赋值，一共三次深拷贝，代价极高

    正确的写法，swap成员变量换

    1. 	void swap(string& tmp)
    2. 	{
    3. 		::swap(_str, tmp._str);//::调用全局swap
    4. 		::swap(_size, tmp._size);
    5. 		::swap(_capacity, tmp._capacity);
    6. 	}
    7.  
    8.     string& operator=(const string& s)
    9. 	{
    10. 		if (this != &s)
    11. 		{
    12. 			//string tmp(s._str);//调用构造函数
    13. 			string tmp(s);//调拷贝构造
    14. 			swap(tmp); //this->swap(tmp) 
    15. 		}
    16. 		return *this;
    17. 	}

    第二种正确的写法

    1. 	string& operator=(string s)//传值拷贝顶替tmp，s就是深拷贝的s3
    2. 	{
    3. 		swap(s);
    4. 		return *this;
    5. 	}

    resize和reserve

    resize默认用0来填充多出的元素空间，resize改变size大小，开空间+初始化。resize新的字符原有的值不动，在后面新增字符。resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变

    1. 		void resize(size_t n, char ch = '\0')
    2. 		{
    3. 			if (n > _size)//插入数据
    4. 			{
    5. 				reserve(n);
    6. 				for (size_t i = _size; i < n; ++i)
    7. 				{
    8. 					_str[i] = ch;
    9. 				}
    10. 				_str[n] = '\0';
    11. 				_size = n;
    12. 			}
    13. 			else//删除数据
    14. 			{
    15. 				_str[n] = '\0';
    16. 				_size = n;
    17. 			}
    18. 		}

    reserve不改变有效元素个数，只开空间。当reserve的参数小于string的底层空间总大小时，不会改变容量大小，比当前空间大完成扩容

    1. 		void reserve(size_t n)
    2. 		{
    3. 			if (n > _capacity)
    4. 			{
    5. 				char* tmp = new char[n+1];
    6. 				strcpy(tmp, _str);
    7. 				delete[] _str;
    8. 				_str = tmp;
    9. 				_capacity = n;
    10. 			}
    11. 		}

    push_back && append

    1. void push_back(char ch)
    2. 		{
    3. 			if (_size >= _capacity)
    4. 			{
    5. 				reserve(_capacity == 0 ? 4 : _capacity * 2);
    6. 			}
    7. 			_str[_size] = ch;
    8. 			++_size;
    9. 			_str[_size] = '\0';
    10. 		}
    11.  
    12. 		void append(const char* str)
    13. 		{
    14. 			size_t len = strlen(str);
    15. 			if (_size + len > _capacity)
    16. 			{
    17. 				reserve(_size + len);
    18. 			}
    19. 			strcpy(_str + _size, str);//strcpy也会拷贝\0
    20. 			_size += len;
    21. 		}
    22.  
    23. 		string& operator+=(char ch)
    24. 		{
    25. 			push_back(ch);
    26. 			return *this;
    27. 		}
    28.  
    29. 		string& operator+=(const char* str)
    30. 		{
    31. 			append(str);
    32. 			return *this;
    33. 		}

    insert

     注意边界

    1. 		string& insert(size_t pos, char ch)
    2. 		{
    3. 			assert(pos <= _size);
    4. 			if (_size == _capacity)
    5. 			{
    6. 				reserve(_capacity == 0 ? 4 : _capacity * 2);
    7. 			}
    8. 			size_t end = _size+1;
    9. 			while (end > pos)
    10. 			{
    11. 				_str[end] = _str[end - 1];//防止pos位置为0时--end越界
    12. 				--end;
    13. 			}
    14. 			_str[pos] = ch;
    15. 			++_size;
    16. 			return *this;
    17. 		}
    18.  
    19. 		string& insert(size_t pos, const char* str)
    20. 		{
    21. 			assert(pos <= _size);
    22. 			size_t len = strlen(str);
    23. 			if (_size + len > _capacity)
    24. 			{
    25. 				reserve(_size + len);
    26. 			}
    27. 			size_t end = _size + len;
    28. 			while (end >= pos + len)
    29. 			{	
    30. 				_str[end] = _str[end - len];
    31. 				--end;
    32. 			}
    33. 			strncpy(_str + pos, str, len);
    34. 			_size += len;
    35. 			return *this;
    36. 		}

    erase

    1.         void erase(size_t pos, size_t len = npos)
    2. 		{
    3. 			assert(pos < _size);
    4. 			if (len == npos || pos + len >= _size)//>=size删完
    5. 			{
    6. 				_str[pos] = '\0';
    7. 				_size = pos;
    8. 			}
    9. 			else//删除需要挪动数据,挪动pos+len往前覆盖
    10. 			{
    11. 				strcpy(_str + pos, _str + pos + len);
    12. 				_size -= len;
    13. 			}
    14. 		}

    << && >>

    注意：空格和换行默认作为数据之间的间隔，in>>ch获取会忽略掉空格或者换行，会认定为字符之间的换行输入、多个字符之间的空格或者换行

    1. 	ostream& operator<<(ostream& out, const string& s)
    2. 	{
    3. 		for (size_t i = 0; i < s.size(); ++i)
    4. 		{
    5. 			out << s[i];
    6. 		}
    7. 		return out;
    8. 	}
    9.  
    10.     	void clear()//类里
    11. 		{
    12. 			_str[0] = '\0';
    13. 			_size = 0;
    14. 		}
    15.     
    16.     istream& operator>>(istream& in,string& s)
    17. 	{
    18.         s.clear();//跟库中保持一致
    19. 		//char ch;
    20. 		//in >> ch;
    21. 		//while(ch != ' ' && ch != '\n')
    22. 		//{
    23. 		//	s+= ch;
    24. 		//	in >> ch;
    25. 		//}
    26. 		//拿不到空格和换行,程序无法终止,cin自动忽略空格或者换行，默认认为输入字符之间间隔
    27.  
    28. 		char ch;
    29. 		ch = in.get();//get获取每一个对应字符，不会忽略\n或者空格
    30. 		const int N = 32;//类似缓冲区，避免多次重复扩容
    31. 		char buff[N];
    32. 		size_t i = 0;
    33. 		while(ch != ' ' && ch != '\n')
    34. 		{
    35. 			buff[i++] = ch;
    36. 			if (i == N - 1)
    37. 			{
    38. 				buff[i] = '\0';
    39. 				s += buff;
    40. 				i = 0;
    41. 			}
    42. 			ch = in.get();
    43. 		}
    44. 		buff[i] = '\0';
    45. 		s += buff;
    46.  
    47. 		return in;
    48. 	}

    迭代器

    所有迭代器区间都是左闭右开；迭代器用法类似；迭代器用法类似指针

    迭代器需要begin（返回第一个位置的类似用法指针）和end（最后一个位置的下一个位置）

    1. void test_string2()
    2. {
    3. 	string s1("hello");
    4.     //普通用法
    5. 	for (size_t i = 0; i < s1.size(); ++i)
    6. 	{
    7. 		cout << s1[i] << " ";
    8. 	}
    9.  
    10.     //string迭代器写法
    11. 	string::iterator it = s1.begin();
    12. 	while (it != s1.end())
    13. 	{
    14. 		cout << *it;
    15. 		it++;
    16. 	}
    17. 	cout << endl;
    18.  
    19.     //list迭代器用法
    20. 	list<int> lt(10, 1);
    21. 	list<int>::iterator lit = lt.begin();
    22. 	while  (lit != lt.end())
    23. 	{
    24. 		cout << *lit<< " ";
    25. 		++lit;
    26. 	}
    27.  
    28. }

    迭代器模拟实现

    string的迭代器就是原生指针

    1. 	namespace MyString
    2. {
    3. 	class string
    4.   {
    5.  
    6. 	public:
    7.     typedef char* iterator;
    8. 	iterator begin()
    9. 	{
    10. 		return _str;//返回第一个位置
    11. 	}
    12. 	iterator end()
    13. 	{
    14. 		return _str+_size;//end返回的迭代器是最后一个数据的下一个位置（\0）
    15. 	}
    16.  
    17. 		void test_string1()
    18. 	{
    19. 		string s1("hello world");
    20. 		string s2;
    21. 		/*for (size_t i = 0; i < s1.size(); ++i)
    22. 		{
    23. 			cout << s1[i];
    24. 		}*/
    25.  
    26. 	string::iterator it = s1.begin();
    27. 	while (it != s1.end())
    28. 	{
    29. 		cout << *it << " ";
    30. 		it++;
    31. 	}
    32. 	cout << endl;
    33. 	for (auto ch : s1)
    34. 	{
    35. 		cout << ch << " ";
    36. 	}
    37. 	}
    38.  
    39.   }
    40. }

    范围for的底层就是迭代器，优化写法

    c_str(cpp中使用了string，要和c语言兼容，用c去读文件等)

    打印test.cpp中的数据读取到屏幕中

    1. void test_string5()
    2. {
    3. 	string filename("test.cpp");
    4. 	//用c去读文件 
    5. 	FILE* fout = fopen(filename.c_str(), "r");
    6. 	assert(fout);
    7. 	char ch = fgetc(fout);
    8. 	while (ch != EOF)
    9. 	{
    10. 		cout << ch;
    11. 		ch = fgetc(fout);
    12. 	}
    13. }
    14.  
    15.  
    16. int main()
    17. {
    18. 	test_string5();
    19. 	return 0;
    20. }

    注意，两个字符串打印有区别，c语言以\0为结尾.cpp以string对象的size为结尾

    1.     cout << filename << endl;
    2. 	cout << filename.c_str() << endl;

    append迭代器版本

    模板（迭代器区间） 

    1. 	string s1("hello");
    2. 	string s2("world");
    3. 	s1.append(s2.begin(), s2.end());//左闭右开迭代器区间数据添加进去
    4. 	cout << s1;

    find和substr

     取文件后缀

    1. void test_string6()
    2. {
    3. 	string s("test.a.cpp");
    4. 	size_t pos = s.rfind('.');
    5. 	if (pos != string::npos)
    6. 	{
    7. 		string suf = s.substr(pos);
    8. 		cout << suf << endl;
    9. 	}
    10. }

     取协议、网站域名、uri

    1. void DealUrl(const string& url)
    2. {
    3. 	size_t pos1 = url.find("://");
    4. 	if (pos1 == string::npos)
    5. 	{
    6. 		cout << "非法url" << endl;
    7. 		return;
    8. 	}
    9. 	string protocol = url.substr(0, pos1);
    10. 	cout << protocol<
    11.  
    12. 	size_t pos2 = url.find('/', pos1 + 3);
    13. 	if (pos2 == string::npos)
    14. 	{
    15. 		cout << "非法url" << endl;
    16. 		return;
    17. 	}
    18. 	string domain = url.substr(pos1 + 3,pos2-pos1-3);
    19. 	cout << domain << endl;
    20.  
    21. 	string uri = url.substr(pos2+1);
    22. 	cout << uri << endl;
    23. }
    24.  
    25.  
    26. int main()
    27. {
    28. 	string s1("https://www.baidu.com/baidu?tn=monline_3_dg&ie=utf-8&wd=%5C0%E7%AD%89%E4%BA%8E0");
    29. 	DealUrl(s1);
    30. 	return 0;
    31. }

    注意：find是搜素字符串匹配字符的第一个位置，要求全部匹配；

    find_first_of是匹配整个字符串中出现的对应字符

    find模拟实现

    1.  
    2. 		size_t find(char ch, size_t  pos = 0)//找一个字符，从pos位置开始
    3. 		{
    4. 			assert(pos < _size);
    5. 			for (size_t i = pos; i < _size; ++i)
    6. 			{
    7. 				if (ch == _str[i])
    8. 				{
    9. 					return i;
    10. 				}
    11. 			}
    12. 			return npos;
    13. 		}
    14.  
    15. 		size_t find(const char* sub, size_t pos = 0)
    16. 		{
    17. 			const char* tmp = strstr(_str + pos, sub);
    18. 			if (tmp == nullptr)
    19. 			{
    20. 				return npos;
    21. 			}
    22. 			else
    23. 			{
    24. 				return tmp - _str;//要返回下标，指针-指针 
    25. 			}
    26. 		}

    从pos位置开始，取len个字符构造新的字串：substr模拟实现

    1. 		string substr(size_t pos, size_t len = npos) const
    2. 		{
    3. 			assert(pos < _size);
    4. 			size_t reallen = len;
    5. 			if (len == npos || pos + len > _size)
    6. 			{
    7. 				reallen = _size - pos;//只要是左闭右开，右开-左闭就是长度
    8. 			}
    9. 			string tmp;
    10. 			for (size_t i = 0; i < reallen; ++i)
    11. 			{
    12. 				tmp += _str[pos+i];//剩余数据拷贝
    13. 			}
    14. 			return tmp; 
    15. 		}

    getline练习题

    字符串最后一个单词的长度_牛客题霸_牛客网

     以下写法错误的原因在于cin

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main(){
    6.     string s;
    7.     cin>>s;
    8.     //getline(cin,s);
    9.     size_t pos = s.rfind(' ');
    10.     if(pos != string::npos)
    11.     {
    12.         cout<size()-pos-1<
    13.     }
    14.     else
    15.     {
    16.         cout<size()<
    17.     }
    18. }

    cin和scanf都一样,如果输入多个值或者多个字符串，多个值之间是用：空格，换行来间隔。

    现在我们输入的一行里面，本身带有空格，用cin接收不到，只能接收到空格前的一串字符，剩下的字符在缓冲区中，此时使用getline

     

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main(){
    6.     string s;
    7.     getline(cin,s);
    8.     size_t pos = s.rfind(' ');
    9.     if(pos != string::npos)
    10.     {
    11.         cout<size()-pos-1<
    12.     }
    13.     else
    14.     {
    15.         cout<size()<
    16.     }
    17. }

    运算符重载

    1. 		bool operator>(const string& s) const
    2. 		{
    3. 			return strcmp(_str, s._str) > 0;
    4. 		}
    5.  
    6. 		bool operator>=(const string& s) const
    7. 		{
    8. 			return *this > s || *this == s;
    9. 		}
    10.  
    11. 		bool operator==(const string& s) const
    12. 		{
    13. 			return strcmp(_str, s._str) == 0;
    14. 		}
    15.  
    16. 		bool operator<=(const string& s) const
    17. 		{
    18. 			return !(*this > s);
    19. 		}
    20. 		bool operator<(const string& s) const
    21. 		{
    22. 			return !(*this >= s);
    23. 		}
    24.  
    25. 		bool operator!=(const string& s) const
    26. 		{
    27. 			return !(*this == s);
    28. 		}

    to_string:从字符串转换-其他转字符串函数

    1. void test_string7()
    2. {
    3. 	const char* s1 = "123";
    4. 	cout<<atoi(s1);
    5. 	
    6. 	int ival;
    7. 	double dval;
    8. 	cin >> ival >> dval;
    9. 	string istr = to_string(ival);
    10. 	string dstr = to_string(dval); 
    11. 	cout << istr << endl;
    12. 	cout << dstr << endl;
    13.  
    14. 	istr = "9999";
    15. 	dstr = "88.88";
    16. 	ival = stoi(istr);
    17. 	dval = stod(dstr);
    18. }

     

  • 相关阅读:
    deepstream6.2部署yolov5详细教程与代码解读
    闭包的详细认识与实例
    入门力扣自学笔记149 C++ （题目编号1608）
    HelloGitHub 社区动态，开启新的篇章！
    大一新生常踩的5大坑，轻则损失钱财，重则影响毕业
    模块及分类
    阿拉伯数字转汉子数字
    docker安装部署nginx
    最大似然函数 损失函数 逻辑回归与线性回归的比较
    驱动开发：通过MDL映射实现多次通信
  • 原文地址：https://blog.csdn.net/weixin_63543274/article/details/126288655