C++的STL简介（二）

熬夜苦读学习

已于 2024-08-02 18:35:17 修改

阅读量494

点赞数 34

文章标签： c++ linux 开发语言 c语言后端

于 2024-07-27 16:52:55 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/2302_81171591/article/details/140734288

版权

目录

1.模拟实现string

1.string基本属性和大体框架

2.3 begin() 和end()

2.4capacity（）

1.模拟实现string

1.string基本属性和大体框架

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include <string>
#include<assert.h>
namespace String
{
	class string
	{
	public:
//默认构造
		string(const char* str="")
		{
			_size = strlen(str);
			//capacity不包含"\0"
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
//析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}
		
//基本变量
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};

2.基本函数

2.1size（）

内容个数


		//模拟size()
		size_t size()
		{
			return _size;
		}

2.2 []

访问元素

#
		//模拟[] 普通引用和const引用两个版本

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		 const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}

2.3 begin() 和end()

简单用typedef重定义char* 来模拟iterator获取begin（）和end（）

	 typedef char* iterator;
	 iterator begin()
	 {
		 return _str;
	 }
	 iterator end()
	 {
		 return _str + _size;
	 }

2.4capacity（）

获取容量

size_t capacity() const
{
	return _capacity;
}

2.5 reserve

调整空间

void string::reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}

2.6push_back

尾插字符

void string::push_back(char ch)
{
	if (_size = _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size++] = ch;
	_str[_size] = '\0';
}

2.7 append

尾插支付串


	void  string::append(const char* str)
	{
		size_t len = strlen(str);
//大于二倍就要多少开多少，低于二倍按二倍开
		if (_size + len > _capacity)
		{
			reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
		}
		strcpy(_str + _size, str);
		_size += len;
	}

2.8 +=

string& string::operator+=(char ch)
{
	push_back(ch);
	return *this;
}

string& string::operator+=(const char* str)
{
	append(str);
	return *this;
}

2.9insert

在指定位置插入字符或字符串

void string::insert(size_t pos, char ch)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	assert(pos <= _size);
	size_t end = _size;
	while (end > pos)
	{
		_str[end ] = _str[end-1];
		--end;
	}
	_str[pos] = ch;
	++_size;
}

void string::insert(size_t pos, const char* s)
{
	assert(pos <= _size);
	size_t len = strlen(s);
if(len==0)
return;
	if (_size + len > _capacity)
	{
		reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
	}
	size_t end = _size + len;
	while (end > pos + len-1)
	{
		_str[end - len] = _str[end];
		--end;
	}
	for (size_t i = 0; i < len; i++)
	{
		_str[pos + i] = s[i];
	}
	_size += len;
}

2.10 erase

删除指定位置元素

void string::erase(size_t pos, size_t len)
{
	if (len >= _size - pos)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		for (size_t i = pos + len; i < _size; i++)
		{
			_str[i - len] = _str[i];
		}
		_size -= len;
	}
}

2.10find

查找字符或字符串

size_t string::find(char ch, size_t pos = 0)
{
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == ch)
		{
			return i;
		}
	}
	return npos;
}
size_t string::find(const char* str, size_t pos = 0)
{
	assert(pos < _size);
	const char* ptr = strstr(_str + pos, str);
	if (ptr == nullptr)
	{
		return npos;
	}
	else {
		return ptr - _str;
	}
}

2.11substr

提取字符重新构建string类

//深拷贝
string(const string&s)
{
	_str = new char[s._capacity + 1];
	strcpy(_str, s._str);
	_size = s._size;
	_capacity = s._capacity;
}









string string::substr(size_t pos, size_t len )
{
	assert(pos < _size);
	//len答疑剩余有效长度更新一下
	if (len > _size - len)
	{
		len = _size - len;
	}
	string sub;
	sub.reserve(len);
	for (size_t i = 0; i < len; i++)
	{
		sub += _str[pos + i];
	}
	return sub;
}

2.12 =

 //s2=s1
 string& operator=(const string& s)
 {//避免s1=s1出现释放了_str
     if(this!=&s)
	 delete[] _str;

	 _str = new char[s._capacity];
	 strcpy(_str, s._str);
	 _size = s._size;
	 _capacity = s._capacity;
	 return *this;
 }

2.12 <

bool operator<(const string& s1, const string& s2)
{
	return strcmp(s1.Get_str(), s2.Get_str())<0;
}

2.13 >



bool operator>(const string& s1, const string& s2)
{
	return !(s1 <= s2);
}

2.14 <=

bool operator<=(const string& s1, const string& s2)
{
	return s1 < s2 || s1 == s2;

}

2.15 >=

bool operator>=(const string& s1, const string& s2)
{
    return !( s1 < s2);
}

2.16 ==

bool operator==(const string& s1, const string& s2)
{
	return strcmp(s1.Get_str(), s2.Get_str()) ==0;
}

2.17 !=

bool operator!=(const string& s1, const string& s2)
{
	return !(s1 == s2);
}

2.18 clear

void clear()
{
_str[0]='\0';
_size=0;
}

2.19 <<

	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto ch : s)
		{
			out << ch;
		}
		return out;
	}

2.20 >>


	istream& operator >> (istream& in, string& s)
	{
		char ch;
		ch = in.get();	
		while (ch != ' ' && ch != '\n')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}

3.完整代码

string.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include <string>
#include<assert.h>
namespace String
{
	class string
	{
	public:
		//s1(s)
		string(const string&s)
		{
			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}
		
		string(const char* str="")
		{
			_size = strlen(str);
			//capacity不包含"\0"
			_capacity = _size;
			_str = new char[_capacity + 1];
			//+1位置给'\0'
			strcpy(_str, str);
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}
		//短小频繁，默认inline
		//获取_str
		 char* Get_str() const
		{
			return _str;
		}

		//模拟size()
		size_t size()
		{
			return _size;
		}
		//模拟实现capacity()
		size_t capacity() const
		{
			return _capacity;
		}

		//简单用typedef重定义char* 来模拟iterator获取begin（）和end（）
		typedef char* iterator;
		iterator begin() const
		{
			return _str;
		}
		iterator end() const
		{
			return _str + _size;
		}

		//模拟[] 普通引用和const引用两个版本
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		 const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}
		 //s2=s1
		 string& operator=(const string& s)
		 {//避免s1=s1出现释放了_str
			 if (this != &s)
			 delete[] _str;
			 _str = new char[s._capacity];
			 strcpy(_str, s._str);
			 _size = s._size;
			 _capacity = s._capacity;
			 return *this;
		 }
		 void clear()
		 {
			 _str[0] = '\0';
			 _size = 0;
		 }

		 void reserve(size_t n);
		 void push_back(char ch);
		 void append(const char* str);
		 string& operator+=(char ch);
		 string& operator+=(const char* str);

		 void insert(size_t pos, char ch);
		 void insert(size_t pos, const char* s);
		 void erase(size_t pos, size_t len = npos);

		 size_t find(char ch, size_t pos = 0);
		 size_t find(const char* str, size_t pos = 0);
		 string substr(size_t pos = 0, size_t len = npos);


		 
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		static const size_t npos;
	};
	bool operator>(const string& s1, const string& s2);
	bool operator>=(const string& s1, const string& s2);
	bool operator<(const string& s1, const string& s2);
	bool operator<=(const string& s1, const string& s2);
	bool operator<=(const string& s1, const string& s2);
	bool operator==(const string& s1, const string& s2);
	bool operator!=(const string& s1, const string& s2);
	istream& operator>>(istream& out, const string& s);
	istream& operator<<(istream& in, string& s);
}

string.c


//text.cpp

using namespace std;
#include"FileName.h"
namespace String
{
	const size_t string::npos = -1;


	void string::reserve(size_t n)
	{
		if (n > _capacity)
		{
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}
	void string::push_back(char ch)
	{
		if (_size = _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		_str[_size++] = ch;
		_str[_size] = '\0';
	}
	string& string::operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}
	void  string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
		}
		strcpy(_str + _size, str);
		_size += len;
	}
	string& string::operator+=(const char* str)
	{
		append(str);
		return *this;
	}

	void string::insert(size_t pos, char ch)
	{
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		assert(pos <= _size);
		size_t end = _size;
		while (end > pos)
		{
			_str[end ] = _str[end-1];
			--end;
		}
		_str[pos] = ch;
		++_size;
	}
	void string::insert(size_t pos, const char* s)
	{
		assert(pos <= _size);
		size_t len = strlen(s);
		if (len == 0)
			return;
		if (_size + len > _capacity)
		{
			reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
		}
		size_t end = _size + len;
		while (end > pos + len-1)
		{
			_str[end - len] = _str[end];
			--end;
		}
		for (size_t i = 0; i < len; i++)
		{
			_str[pos + i] = s[i];
		}
		_size += len;
	}
	void string::erase(size_t pos, size_t len)
	{
		if (len >= _size - pos)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			for (size_t i = pos + len; i < _size; i++)
			{
				_str[i - len] = _str[i];
			}
			_size -= len;
		}
	}

	size_t string::find(char ch, size_t pos )
	{
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == ch)
			{
				return i;
			}
		}
		return npos;
	}
	size_t string::find(const char* str, size_t pos )
	{
		assert(pos < _size);
		const char* ptr = strstr(_str + pos, str);
		if (ptr == nullptr)
		{
			return npos;
		}
		else {
			return ptr - _str;
		}
	}
	string string::substr(size_t pos, size_t len )
	{
		assert(pos < _size);
		//len答疑剩余有效长度更新一下
		if (len > _size - len)
		{
			len = _size - len;
		}
		string sub;
		sub.reserve(len);
		for (size_t i = 0; i < len; i++)
		{
			sub += _str[pos + i];
		}
		return sub;
	}

	bool operator<(const string& s1, const string& s2)
	{
		return strcmp(s1.Get_str(), s2.Get_str())<0;
	}

	bool operator<=(const string& s1, const string& s2)
	{
		return s1 < s2 || s1 == s2;

	}

	bool operator>(const string& s1, const string& s2)
	{
		return !(s1 <= s2);
	}

	bool operator>=(const string& s1, const string& s2)
	{
        return !( s1 < s2);
	}

	bool operator==(const string& s1, const string& s2)
	{
		return strcmp(s1.Get_str(), s2.Get_str()) ==0;
	}

	bool operator!=(const string& s1, const string& s2)
	{
		return !(s1 == s2);
	}

	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto ch : s)
		{
			out << ch;
		}
		return out;
	}
	istream& operator >> (istream& in, string& s)
	{
		s.clear();
		const int N = 256;
		char buff[N];
		int i = 0;

		char ch;
		//in >> ch ;
		ch = in.get();	
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == N - 1)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
		}
		return in;
	}
}
int main()
{
	
	return 0;
}

熬夜苦读学习

关注

34
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
19
评论
C++的STL简介（二）

简单用typedef重定义char* 来模拟iterator获取begin（）和end（）提取字符重新构建string类。在指定位置插入字符或字符串。
复制链接

扫一扫

熬夜苦读学习 CSDN认证博客专家 CSDN认证企业博客

码龄1年

景德镇艺术职业大学

25: 原创

1156: 周排名

2万+: 总排名

1万+: 访问

: 等级

1069: 积分

350: 粉丝

596: 获赞

97: 评论

407: 收藏

私信

关注

热门文章

分类专栏

C++ 7篇
c语言算法 3篇
语法 5篇

最新评论

C++的STL简介（二）
破浪前行之路: 文章中的代码实例丰富且具有代表性，涵盖了多个编程领域。这些实例不仅帮助读者更好地理解编程原理，还提供了许多实用的技巧和方法期待博主持续带来更多好文
C++的STL简介（三）
破浪前行之路: 文章中的代码实例丰富且具有代表性，涵盖了多个编程领域。这些实例不仅帮助读者更好地理解编程原理，还提供了许多实用的技巧和方法期待博主持续带来更多好文
C++的STL简介（四）
破浪前行之路: 文章中的代码实例丰富且具有代表性，涵盖了多个编程领域。这些实例不仅帮助读者更好地理解编程原理，还提供了许多实用的技巧和方法期待博主持续带来更多好文
C++的STL简介（三）
GG Bond.ฺ: 优质好文，博主的文章细节很到位，三连支持，期待博主持续输出好文!希望大佬也能来指导我一下
C++的STL简介（三）
不穿格子衬衫: 博主的文章细节很到位，兼顾实用性和可操作性，感谢博主的分享，文章思路清晰，干货满满，很有学习价值！

大家在看

最新文章

目录

评论 19

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

打赏作者

熬夜苦读学习 你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20

扫码支付：¥1

获取中

扫码支付

您的余额不足，请更换扫码支付或充值

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。