STL之string

Flying clouds

已于 2022-11-23 10:52:29 修改

阅读量852

点赞数 2

分类专栏： C++ 文章标签： c++ 开发语言

于 2022-10-27 11:09:38 首次发布

本文链接：https://blog.csdn.net/flyingcloud6/article/details/127517709

版权

C++ 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

1、构造string(const char* str, int first, int last）

2、find函数去查找对象中是不是含有这个字符串

3、借用临时对象去释放原来的空间

一、string的底层原理

string是一个默认的字符串类，他内部是一个数组去存放着字符串

二、string各函数的接口

1、构造

2、string类对象的容量操作

size 、 capacity、length

clear

reserve、resize

针对reserve，这个函数主要是用来预留空间的，一次性申请足够的空间，之后就不再需要再次申请空间，

这样效率就会变高很多，因为数组申请空间代价有点大

但如果预留空间的话就会

这样一直都在同一块空间上进行操作，效率自然就会提升不少

3、string类对象的访问及遍历方式

1、<<和operator[ ]

2、三种遍历方法：

1、 for+operator 2、迭代器 3、范围for

4、string类对象的修改操作

push_back、append、operator+=

c_str函数

find函数

find函数是去查找字符或字符串，还好几个用法

substr函数

5、string类非成员函数

1、operator>>

getline()

三、string的模拟实现

代码：

#pragma once
#include<iostream>
#include<list>
using namespace std;
namespace bit
{
	class string
	{
		friend ostream& operator <<(ostream& out, const string& s);
	public:
		typedef char* iterator;
	public:
		string() :_str(nullptr), _capacity(0), _size(0)
		{}
		string(const char* s)
		{
			_str = new char[strlen(s) + 1];
			_capacity = strlen(s);
			_size = strlen(s);
			strcpy(_str, s);
		}
		string(const char* str, int first, int last) :_str(nullptr), _capacity(0), _size(0)
		{
			//_str = new char[last - first + 1];
			//_capacity = last - first;
			//while (first != last)
			//{
			//	push_back(str[first]);
			//	++first;
			//}

			_str = new char[last - first + 1];
			int n = last - first;
			_capacity = _size = n;
			for (int i = 0; i < n; ++i)
			{
				_str[i] = str[first];//这里赋不进去值
				//_str[i + 1] = '\0'; //关键在于'\0'
				first++;
				
			}
			_str[n] = '\0';
		}
        //赋值运算符重载
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				string tmp(s);//创建临时的对象
				this->swap(tmp);//调用系统自带的交换函数，
								//妙就妙在因为是临时的对象，那么tmp在函数结束就会自动被析构
								//也就意味着不用再去管原来this对象的空间问题
			}
		}
		~string()
		{
			delete[]_str;
			_str = nullptr;
			_capacity = _size = 0;
		}
	public:
		void reserve(size_t n = 0)
		{
			if (n > _capacity)
			{
				char* new_str = new char[n + 1];//这时候实际容量多一个，用来放'\0'
				if (_str)
				{
					strcpy(new_str, _str);	      //防止越界操作

				}
				delete[]_str;
				_str = new_str;
				_capacity = n;
			}
		}

		void resize(size_t n, char c = '\0')
		{
			if (n > _size)
			{
				if (n > _capacity)//需要扩容
				{
					reserve(n);
				}
				for (int i = _size; i < n; ++i)
				{
					_str[i] = c;
				}
			}
			_size = n;
			_str[n] = '\0';

		}
	
		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}
		void append(const char* str)
		{
			reserve(size() + strlen(str) + 1);//先扩容
			strcat(_str, str);//再之间把str拼接到后面
			_size = strlen(_str);
		}
		string& operator+=(const char* str)
		{
			append(str);//相当于追加
			return *this;
		}
		void clear()
		{
			_str = nullptr;
			_size = 0;
		}
		void swap(string& s) //用到拷贝构造是不是更好？
		{
			//string tmp(_str);   方法回头再想，先用笨的



			/笨方法
			//对*this进行修改
			string tmp(_str);//借助一个中间变量
			int n = s.size();
			(*this).reserve(n);
			memcpy(_str, s._str,n);
			_str[s.size()] = '\0';
			_size = strlen(_str);


			//对s进行修改
			s.reserve(tmp.size());
			memcpy(s._str, tmp._str,tmp.size());//这时候s的_str好像没有'\0'
			s._str[tmp.size()] = '\0';
			s._size = strlen(s._str);

		}
		const char* c_str()const
		{
			return _str;
		}
		bool empty()const
		{
			return (_size == 0);
		}
		char& operator[](size_t index)
		{
			return _str[index];
		}
		bool operator<(const string& s)
		{
			return (memcmp(_str, s._str, size()) < 0);
		}
		bool operator<=(const string& s)
		{
			return (memcmp(_str, s._str, size()) <= 0);
		}
		bool operator>(const string& s)
		{
			return (memcmp(_str, s._str, size()) > 0);
		}
		bool operator>=(const string& s)
		{
			return (memcmp(_str, s._str, size()) >= 0);
		}
		bool operator==(const string& s)
		{
			return (memcmp(_str, s._str, size()) == 0);
		}
		bool operator!=(const string& s)
		{
			return (memcmp(_str, s._str, size()) == 0);
		}
		size_t find(char c, size_t pos = 0) const
		{
			for (int i = pos; i < _size; ++i)
			{
				if (_str[i] == c)
				{
					return i;
				}
			}
			return -1;//返回size_t类型的-1，相当于 npos
		}
		size_t find(const char* s, size_t pos = 0) const
		{
			int n = strlen(s);
			string str(s);
			//从pos的位置开始找
			for (int i = pos; i <= _size-n; ++i)//当走到_size-n之后就不可能了
			{
				string tmp(_str, i, i + n);//利用构造，感觉很妙~~~
				if (tmp == str)
				{
					return i;
				}
			}
			return -1;
		}
		string& insert(size_t pos, char c)
		{
			reserve(size()+1);
			string tmp(_str);
			for (int i = 0; i < pos; ++i)
			{
				_str[i] = tmp._str[i];
			}
			_str[pos] = c;
			for (int i = pos + 1; i < size() + 1; ++i)
			{
				_str[i] = tmp._str[i - 1];
			}
			_str[size() + 1] = '\0';
			_size++;
			return *this;
		}
		string& insert(size_t pos, const char* str)
		{
			for (int i = 0; i < strlen(str);++i)
			{
				insert(pos, str[i]);
			}
			return *this;
		}
		string& erase(size_t pos, size_t len)//从pos位置，删除len长度
		{
			for (int i = pos; i <= size()-len; ++i)
			{
				_str[i] = _str[i +len];
			}
			_str[size() - len] = '\0';
			_size -= len;
			return *this;
		}
	public:
		void push_back(char c)
		{
			if (_size >= _capacity)
			{
				size_t new_capacity = _capacity == 0 ? 1 : _capacity * 2;
				reserve(new_capacity);
			}
			_str[_size++] = c;
			_str[_size] = '\0';
		}
	public:
		size_t capacity()
		{
			return _capacity;
		}
		size_t size()
		{
			return _size;
		}
	public:
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
	private:
		char* _str;
		size_t _capacity;
		size_t _size;
	};

	ostream& operator<<(ostream& out, const string& s)
	{
		out << s._str;
		return out;

	}
}