c++STL---string(模拟实现)

string实现的接口

默认成员函数

构造函数

构造函数设置为缺省参数,如不传参,则默认构造为空字符串.字符串的初始大小和容量均设置为传入的有效字符长度(不包含'\0')

	//构造函数
		string(const char* str ="")
			:_size(strlen(str))
			, _capacity(strlen(str))
		{
			_str = new char[_size+1];
			strcpy(_str, str);
		}

拷贝构造函数

要想实现拷贝构造需要先了解深浅拷贝

浅拷贝:拷贝出来的目标对象的指针和源对象的指针指向同一块内存空间.其中一个对象改动会对另一个对象造成影响

深拷贝:目标对象重新开辟一块内存空间,其中任何一个对象改动不会对另一个对象造成影响

传统写法

传统写法的思想是:先开辟一块空间,然后把源对象的字符串拷贝过去,接着把源对象的其他成员变量也赋值过去,因为拷贝对象和源对象的_str不是指向同一块空间,所以拷贝出来的对象与源对象是相互独立的,即修改其中一个对象另一个对象不会变

//拷贝构造传统写法
string(const string& s)
{
	_str = new char[s._capacity + 1];
	strcpy(_str, s._str);
	_size = s._size;
	_capacity = s._capacity;
}

现代写法 

现代拷贝构造:先根据源对象构造一个临时对象temp,然后在将temp对称和拷贝对象的数据交换即可,由于temp是临时对象,出作用域掉析构函数,即把开辟的也释放了,拷贝对象和源对象的_str不是指向同一开空间,所以改变其中一个另一个也不会改变 

//拷贝构造现代写法
	  string(const string&s)
			:_str(nullptr)
			,_size(0)
			,_capacity(0)
		{
			string temp(s._str);
			swap(temp);
		}
		

赋值运算符的重载

传统写法:

赋值运算符的重载的传统写法与拷贝构造的传统写法几乎相同,只是左值_str在开辟空间之前需要将原来的空间释放掉,并且在进行操作之前要判断是否是自己给自己赋值,如是自己给自己赋值,则无需进行任何操作.

	string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* temp = new char[s._capacity + 1];
				strcpy(temp, s._str);
				delete[] _str;
				_str = temp;
				_size = s._size;
				_capacity = s._capacity;
			}
			return *this;
		}

现代写法: 

赋值运算符的重载的现代写法与拷贝构造的现代写法也非常类似,但拷贝构造的现代写法是统一的是通过代码调用构造函数构造出一个对象,然后将该对象与拷贝对象交换,而赋值运算符的重载的现代写法是通常采用"传递值"接收右值的方法,让编译器自动调用拷贝构造函数,然后我们在将拷贝出来的对象与左值进行交换.

string& operator=(string s)
		{
			swap(s);
			return *this;
		}

但是这种写法有弊端:自己给自己赋值也会进行这些操作,虽然操作后对象中_str的内容不变但是字符串的地址发生了改变.还有一种现代的写法.

	string& operator=(const string& s)
		{
			if (this != &s)
			{
				string temp(s._str);
				swap(temp);
			}
			return *this;
		}

析构函数 

为何要自己写析构函数:因为每个string对象中的成员变量_str都指向一块堆区的空间,当对象销毁时对应的堆空间并不会销毁,为了避免内存泄漏需要我们手动销毁

	//析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

迭代器相关的函数

迭代器:我们完全可以把迭代器当指针使用,迭代器可能是指针实现也可能不是,但是string类的迭代器是指针实现的.

typedef char* iterator;
		typedef const char* const_iterator;

begin

begin函数其实就是返回字符串中第一个字符的地址 

iterator begin()
		{
			return _str;
		}
const_iterator begin() const
		{
			return _str;
		}

end

end函数的这样其实就是返回最后一个字符的地址,即'\0\的地址 

iterator end()
		{
			return _str + _size;
		}
const_iterator end()const
		{
			return _str + _size;
		}

迭代器遍历string的代码

string s1("hello world")	
string::iterator it = s1.begin();
		while (it != s1.end())
		{
			(*it)++;
			cout << *it << " ";
			++it;
		}
		cout << endl;

在string的使用中我们还用到范围for,其实范围for的底层就是迭代器,编译器会自动将范围for替换成迭代器的形式,我们已经实现了迭代器,自然也能用范围for来实现遍历

容量和大小相关的函数

size和capacity 

因为string类的成员函数是私有的,我们并不能之间对其进行访问,想访问私有成员咋办呢,于是就诞生了size和capacity函数.

size函数用于获取string对象的有效长度(不包括'\0')

size_t size() const
		{
			return _size;
		}

 capacity函数用于返回当前string的容量

		size_t capacity() const
		{
			return _capacity;
		}

reserve和resize

reserve使用规则:

1. 当n大于当前对象的capacity时,将capacity扩大到大于或等与n
2. 当 n小与当前对象的capacity时,什么也不做

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

 resize使用规则:

1. 当n大于当前的size时,将size扩大到n,扩大字符为ch,若未给出字符,则默认为'\0'
2. 当n小于当前的size时,将size缩小到n;

void resize(size_t n,char ch = '\0')
		{
			if (n > _size)
			{
				reserve(n);
				for (int i = _size; i < n; i++)
				{
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				_str[n] = '\0';
				_size = n;
			}
		}

 empty

empty是判断string类是否为空的,我是调用strcmp来实现的,strcmp使用规则当两个字符串相等时返回0.

bool empty()const
		{
			return strcmp(_str, "") == 0;
		}

修改字符相关的函数

push_back

push_back函数时在当前的字符串的后面插入一个字符,尾插之前需要判断是否需要扩容,若需要则调用reserve函数尽心扩容,注意尾插往之后要在该字符后面加一个'\0',否则打印的时候会出现非法访问.

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

append

append函数实在当前字符串后面插入一个字符串,尾插前也需要判断当前string类的空间是否可以容纳先该字符串,若不能也需要扩容,我们不需要在该字符串后面添加'\0'因为该字符串后面就带有'\0'

void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);
			_size = _size + len;
		}

operator+=

存在+=运算符是为了实现字符串与字符,字符串与字符串之间能够使用+=运算符进行尾插

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

insert

insert函数的作用是在字符串任意位置插入字符或字符串.

insert函数用于插入字符时,实现需要判断pos位置的合法性,若不合法直接返回,当然也需要判断对象的容量.

插入一个字符实现原理图

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

插入一个字符串的实现原理图

string& insert(size_t pos,const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			int end = _size ;
			while (end >=(int)pos)
			{
				_str[end + len] = _str[end];
				end--;
			}
			strncpy(_str + pos, str,len);
			_size += len;
			return *this;
		}

需要注意的时插入字符串的时候不能使用strcpy,而是使用strncpy,因为strcpy插入的时候把'\0'也插入进去了 

erase

erase函数是删除字符串任意位置的n个字符,删除前需要判断pos的合法性

1.删除pos位置之后的所有字符这时我们只需要将pos位置放一个'\0',然后修改size就可以了 

 2.pos位置及其之后的有效字符只需要删除一部分

string& erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			if (len + pos >= _size || len == npos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t begin = pos + len;
				while (begin <= _size)
				{
					_str[begin - len] = _str[begin];
					begin++;
				}
				_size -= len;
			}
			return *this;
		}

claer

clear函数的作用是将字符串清空,和_size修改为0.

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

swap

swap函数用于交换两个对象的数据,直接调用库里的模板函数将各个成员变量交换即可,但是需要注意的是要想在自己的命名空间里调用库里的函数需要加上::(作用域限定符)告诉编译器先在全局范围内查找

	void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

c_str 

c_str用于获取c类型的字符串

const char* c_str()const
		{
			return _str;
		}

访问字符相关的函数

operator[]

重载[]运算符是为了让string类可以像c字符一样,通过[]+下标的方式获取字符串相应的位置

1.可对可写

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

 2.只读

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

find和rfind

find函数: 

正向查找第一个匹配的字符串

首先判断所给出的pos位置的合法性,然后通过遍历的方式从pos位置开始向后查找目标字符,若找到返回下标,若没找到返回npos

	size_t find(char ch, size_t pos = 0)const
		{
			assert(pos < _size);
			for (int i = pos; i < _size; i++)
			{
				if (_str[i] == ch)
					return i;
			}
			return npos;
		}

 正向查找第一个匹配的字符串

首先判断pos的合法性,然后通过调用库函数strstr函数进行查找,若找到了返回第一次找到的字符串的起始位置,然后通过指针的相减就可以得到下标,若没找到返回nullptr,则我们返回npos

size_t find(char* str, size_t pos = 0)
		{
			const char* temp = strstr(_str + pos, str);
			if (temp)
			{
				return temp - _str;
			}
			else
			{
				return npos;
			}
		}

rfind函数: 

实现rfind函数我们可以将字符串逆置然后复用find函数进行查找,但需要注意的是下标的映射关系.

size_t rfind(char ch, size_t pos = npos)
		{
			string temp(*this);//拷贝构造对象
			reverse(temp.begin(), temp.end());
			if (pos >= _size)//给出的字符大于字符串的有效长度
			{
				pos = _size - 1;
			}
			pos = _size - 1 - pos;//将pos改为镜像对称的位置
			size_t ret = temp.find(ch, pos);//复用find函数
			if (ret != npos)
				return _size - 1 - ret;
			else
				return npos;//没找到
		}

查找一个字符串同样需要注意的是下标的映射关系

size_t rfind(char* str, size_t pos = npos)
		{
			string temp(*this);//拷贝构造对象
			reverse(temp.begin(), temp.end());
			if (pos >= _size)//给出的字符大于字符的有效长度
			{
				pos = _size - 1;
			}
			pos = _size - 1 - pos;//将pos改为镜像对称的位置
			size_t ret = temp.find(str, pos);//复用find函数
			if (ret != npos)
				return _size - 1 - ret;
			else
				return npos;//没找到
		}

substr 

substr实现的从一个字符串中截取一个子串下来,当len大于当前string类是,是从pos位置开始截取其后面的所有有效字符

string substr(size_t pos, size_t len = npos)
		{
			string s;
			size_t end = pos + len;
			if (len > _size || len == npos)
			{
				len = _size - pos;
				end = _size;
			}
			s.reserve(len);
			for (int i = pos; i < end; i++)
			{
				s += _str[i];
			}
			return s;
		}

关系运算符重载

 关系运算符有六个,但是我们只需要实现其中的两个然后通过复用就可以实现全部

	bool operator>(const string& s)
		{
			return strcmp(_str, s._str)>0;
		}
		bool operator==(const string& s)
		{
			return strcmp(_str, s._str) == 0;
		}
		bool operator>=(const string& s)
		{
			return *this > s || *this == s;
		}
		bool operator<(const string& s)
		{
			return !(*this >= s);
		}
		bool operator<=(const string& s)
		{
			return !(*this > s);
		}
		bool operator!=(const string& s)
		{
			return !(*this == s);
		}

<<和>>运算符重载和getline

<<运算符的重载

重载<<运算符是为了能让string对象可以像内置类型一样进行输出打印

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

>>运算符的重载

是实现>>运算符的重载是为了能让string类可以像内置类型那样进行输出

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

getline 

getline函数用于读取一行含有空格的字符串.实现原理和>>一样,不过getline是遇到'\n'才结束

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