C++ -- string类模拟实现

脚踏车(crush)

已于 2023-04-10 18:18:48 修改

阅读量202

点赞数

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

于 2023-03-12 15:51:16 首次发布

本文链接：https://blog.csdn.net/m0_46343224/article/details/129476783

版权

c++ 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

本文详细介绍了如何在C++中模拟实现一个string类，包括成员变量如_char指针、_size和_capacity，以及构造函数、拷贝构造函数、reserve方法、resize方法等关键功能。文章还探讨了内存管理和字符串操作的细节，如插入、删除、查找和迭代器等。

摘要由CSDN通过智能技术生成

文章目录

C++ -- string类模拟实现

C++ – string类模拟实现

0. 成员变量

char* _str;
size_t _capacity;
size_t _size;
static const size_t npos;

1. 构造函数

string()
	:_str(new char[1])
	,_size(0)
	,_capacity(0)
{
	_str[0] = '\0';
}

为什么_str必须初始化new char[1],而不是new char,这两种写法不都一样吗？

一般情况下，都是初始化字符串，~string()时也是delete[] _str;

string(const char* s)
	:_size(strlen(s))
{
	_capacity = _capacity == 0 ? 4 : _size;
	_str = new char[_capacity + 1];
	strcpy(_str, s);
}

为什么_str = new char[ _capacity + 1],而不是new char[ _capacity]？

因为字符串都是以’\0’作为结束标志结束的，所以必须提前预留一个位置给’\0’

string(const char* s = "")
	:_size(strlen(s))
{
	_capacity = _size == 0 ? 4 : _size; 
	_str = new char[_capacity + 1]; 
	strcpy(_str, s);
}

string(const char* s = “”)这种带有缺省值的构造函数是可以同时满足string()和string(const char* s)的。

2. 拷贝构造函数

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

拷贝构造形式必须是类名(const 类名& 变量名)
操作：对没有空间的变量开辟和s空间一样大小的空间，然后拷贝数据到this指向的变量

3. reserve方法

void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1]; //防止new失败
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp; //_str指针变向
		_capacity = n;
	}
}

为什么不直接_str = new char[n + 1]呢？

防止new失败导致this->_str数据出错

_str = tmp是使用的赋值重载(operator=)吗？

不是的，_str 和tmp都是内置类型(指针类型)，这里只是改变了 _str指针的指向

4. resize方法

void resize(size_t n)
{
	if (n < _size) //缩容比capacity小就直接添加终止符号
	{
		_size = n;
		_str[_size] = '\0';
	}
	else
	{
		if (n > _capacity) //扩容
		{
			reserve(n);
		}
		//_size < n < _capacity:初始化
		size_t index = _size;
		while (index < n)
		{
			_str[index] = '\0';
			++index;
		}

		_size = n;
		_str[_size] = '\0';
	}
}

这里是分为三种情况的:
- n < _size ：直接对 _size做出调整
- n > _capacity ：扩容+初始化
- n > _size && n < _capacity : 不扩容只是初始化

5. insert方法

插入字符

string& insert(size_t pos, char c)
{
	assert(pos <= _size);
	if (_size + 1 > _capacity) //扩容
	{
		reserve(_capacity * 2);
	}

	/*size_t end = _size; //err
	while (end >= pos)  //size_t --> unsigned int --> -1=INT_MAX
	{
		_str[end] = _str[end - 1];
		--end;
	}*/

	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}

	_str[pos] = c;
	++_size;
	return *this;
}

操作：
- 检查插入下标
- 是否扩容
- 挪动数据+插入数据
为什么size_t end = _size;这种操作不行呢？

end是size_t类型，当end=-1时，会发生整形提升，end=INT_MAX了。

插入字符串

string& insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}

	size_t end = pos + len;
	while (end > pos + len - 1)
	{
		_str[end] = _str[end - len];
		--end;
	}
	strncpy(_str + pos, str, len);
	_size += len;
	return *this;
}

6. erase方法

string& erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);

	if (len == npos || pos + len > _size) 
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
	}
	return *this;
}

操作：
- 检查下标是否合法
- 判断删除长度：len+pos > _size直接终止；否则后面数据挪动

7. push_back方法

void push_back(char c)
{
	insert(_size, c); //复用insert(size_t pos, char c)
}

8. append方法

void append(const char* str)
{
	insert(_size, str); //复用insert(size_t pos, const char* str)
}

9. swap方法

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

10. find方法

size_t find(const char* str, size_t pos = 0) //默认是从下标为0处开始查找
{
	assert(pos < _size);
	char* p = strstr(_str + pos, str); //strstr --> c语言库函数 --> 找子串(功能)
	if (p == nullptr)
	{
		return npos;
	}
	else
	{
		return p - _str; //指针-指针
	}
}

11. []运算符重载

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

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

12. 析构函数

~string()
{
	delete[] _str;
	_str = nullptr;
	_size = _capacity = 0;
}

13. +=运算符重载

string& operator+=(char c)
{
	push_back(c); //复用push_back(char c)
	return *this;
}

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

14. 迭代器

typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
	return _str;
}

iterator end()
{
	return _str + _size;
}

const_iterator begin() const
{
	return _str;
}

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

15. 完整代码

#pragma once
#include <iostream>
#include <string.h>
#include <assert.h>
using namespace std;

namespace my_string
{
	class string
	{
	public:
		friend ostream& operator<<(ostream& out, const string& s);
		friend istream& operator>>(istream& out, const string& s);

		typedef char* iterator;
		typedef const char* const_iterator;
		//string()
		//	:_str(new char[1])
		//	,_size(0)
		//	,_capacity(0)
		//{
		//	_str[0] = '\0';
		//}

		//string(const char* s)
		//	:_size(strlen(s))
		//{
		//	_capacity = _capacity == 0 ? 4 : _size;
		//	_str = new char[_capacity + 1];
		//	strcpy(_str, s);
		//}

        string(const char* s = "")
			:_size(strlen(s))
		{
			_capacity = _size == 0 ? 4 : _size;
			_str = new char[_capacity + 1]; 
			strcpy(_str, s);
		}

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

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

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

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

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

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1]; //防止new失败
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp; //_str指针变向
				_capacity = n;
			}
		}

		void resize(size_t n)
		{
			if (n < _size) //缩容比capacity小就直接添加终止符号
			{
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				if (n > _capacity) //扩容
				{
					reserve(n);
				}
				//_size < n < _capacity:初始化
				size_t index = _size;
				while (index < n)
				{
					_str[index] = '\0';
					++index;
				}

				_size = n;
				_str[_size] = '\0';
			}
		}


		string& insert(size_t pos, char c)
		{
			assert(pos <= _size);
			if (_size + 1 > _capacity) //扩容
			{
				reserve(_capacity * 2);
			}

			/*size_t end = _size; //err
			while (end >= pos)  //size_t --> unsigned int --> -1=INT_MAX
			{
				_str[end] = _str[end - 1];
				--end;
			}*/

			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}

			_str[pos] = c;
			++_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);
			}
            
			size_t end = pos + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				--end;
			}
			strncpy(_str + pos, str, len);
			_size += len;
			return *this;
		}

		string& erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);

			if (len == npos || pos + len > _size) 
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			return *this; 
		}

		void push_back(char c)
		{
			insert(_size, c);
		}

		void append(const char* str)
		{
			insert(_size, str);
		}

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

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

		//template <class T> void swap (T& a, T& b);
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		size_t find(const char* str, size_t pos = 0)
		{
			assert(pos < _size);
			char* p = strstr(_str + pos, str);
			if (p == nullptr)
			{
				return npos;
			}
			else
			{
				return p - _str; //指针-指针
			}
		}

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

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

		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1]; //临对象接收防止new失败
				strcpy(tmp, s._str);
				delete[] _str;
				_str = tmp;
				_size = s._size;
				_capacity = s._capacity;
			}
			return *this;
		}

		void clear()
		{
			_str[0] = '\0';
			_size = 0; //_capacity不会变化
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

	private:
		char* _str;
		size_t _capacity;
		size_t _size;
		static const size_t npos;
	};

	const size_t string::npos = -1;

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

	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char c = in.get();
		char buf[128];
		size_t i = 0;
		while (c != ' ' && c != '\n')
		{
			buf[i++] = c;
			if (i == 127)
			{
				buf[127] = '\0';
				s += buf;
				i = 0;
			}

			c = in.get();
		}
		
		if (i != 0)
		{
			buf[i] = '\0';
			s += buf;
		}

		return in;
	}
}