【C++】---string的模拟

一、string类实现

为了将自己命名的string类和库里面的string类区分开来，我们用命名空间namespace yjl 区分开
string类里面有成员函数:（1）_ str:字符串内容（2）_ size:字符串大小（3）_ capacity:字符串容量、

namespace yjl
{
	class string
	{
    private:
        char* _str;
	    size_t _size;
	    size_t _capacity;
    };
}

1.string类的构造函数

分配空间时，要多分配1个字节的空间，这1个字节是留给’\0’的，_size最大为申请字节数-1，_capacity最大也为申请字节数-1

// 方法1：在初始化列表里面调用太多的strlen！！！效率不高!
/*string(const char* str=" ")
			:_size(strlen(str))
			,_str(new char[strlen(str)+1])
			,_capacity(strlen(str))  // 在初始化列表里面调用太多的strlen！！！
		{

		}*/
		// 1.构造函数
		//string(const char* str = nullptr) //这里的str不能给nullptr，因为strlen（nullptr）会出错！
		//string(const char* str = "\0")// 不能是'\0'因为'\0'是char类型，不能赋值给char* 类型的！而"\0"就是空串！ 可以
		string(const char* str = " ")// 官方的写法！空串里面就默认有一个'\0'
			:_size(strlen(str))

		{
			_str = new char[_size + 1];
			_capacity = _size;
			strcpy(_str, str);
		}

2.swap（）函数

使用库里的swap函数交换*this和s的内容：包括_str字符串内容、_size字符串大小和_capacity字符串容量

// swap的模拟：
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

3.拷贝构造函数

（1）传统写法：

// 17.拷贝构造函数
		// (1) 传统写法：(必须是深拷贝)
		// s1(s2)
		string(const string& s)
		{
			// 因为是深拷贝，所以要用new新开辟一块空间
			_str = new char [s._capacity+1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}

（2）现代写法：

	// (2)现代写法：
		// s1(s2)
		string(const string& s)
		{
			string tmp = s._str;// 直接调用构造函数，让构造函数来完成 空间的开辟 和 拷贝！

			//string tmp (s._str);

			swap(tmp);
		}

4.赋值运算符重载

（1）传统写法：

// (1)传统写法：
		// s1=s2
		string& operator=(const string& s)
		{
			// 开多大的空间，要看你要把谁赋值给别人。这里就是s2!
			char* tmp = new char[s._capacity];
			strcpy(tmp,s._str);

			delete[] s._str;

			_str = tmp;
			// 更新参数
			_size = s._size;
			_capacity = s._capacity;
			return *this;
		}

（2）现代写法：

	// (2)现代写法：复用，拷贝构造
	// (在写 赋值 的现代写法之前，你还要写一个拷贝构造函数的现代写法，因为他要复用)
		// s1=s2
		string& operator=(const string& s)
		{
			string tmp(s);// 重载赋值函数 调用 拷贝构造，不会陷入死循环！
			// 只有拷贝构造自己调用拷贝构造才会陷入死循环！
			swap(tmp);
			return *this;
		}

5.析构

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

6.迭代器

分两种：普通迭代器（可读可写）和const迭代器（只读）

（1）普通迭代器：

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

（2）const迭代器：

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

7.operator[ ]

也分为普通operator[ ]（可读可写）和const operator[ ]（只读）

char要加&，如果不加，那么return就是传值返回，返回的是_str[i]的拷贝，即临时对象，而临时对象具有常性，不能被修改，只能读；如果要对_str进行修改的话，char要加&，用传引用返回

（1）普通：

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

（2）const：

// (3)[]的模拟：返回的是字符(有const，只读！！！)
		const char& operator[](size_t pos)const
		{
			assert(pos < _size);
			return _str[pos];
		}

8.size

//(2) size()函数的实现！(求string对象的大小)
		size_t size()const // 最好写成const，不仅普通对象可以调用，const对象也可以调用！
		{
			return _size;
		}

9.c_str（）

		// 6.c_str(将 字符串 转化  字符)
		const char* c_str()
		{
			return _str;
		}

10.reserve（）

// 7.reserve 扩容（1）new新空间（2）拷贝字符串（3）释放旧空间（4）指向新空间（5）更新_capacity
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				// 1.new新空间
				char* tmp = new char[n + 1];
				// 2.拷贝字符串
				strncpy(tmp, _str, _size + 1);
				// 3.释放旧空间
				delete[] _str;
				// 4.指向新空间
				_str = tmp;
				// 5.更新_capacity
				_capacity = n;
			}
		}

11.resize（）

开空间+初始化，扩展_capacity，_size也要修改

（1）当n<_size，无需增容

（2）当n>_size，分两种情况
①_size < n <_capacity，无需增容，直接将_size到n位置置为val
②n >_capacity，需增容，并将_size到n位置置为val
n>_size的这两种情况只有是否增容的区别，其他没有区别，可以合二为一

        void resize(size_t n, char val = '\0')//如果没有显式给出val，val为\0
		{
			//1.当n<_size，无需增容
			if (n < _size)
			{
				_size = n;//直接更新_size
				_str[_size] = '\0';//将_size位置置为\0
			}
			//2.当n>_size，分两种情况
			//（1）_size < n <_capacity，无需增容，直接将_size到n位置置为val
			//（2）n >_capacity，需增容，并将_size到n位置置为val
			//这两种情况只有是否增容的区别，其他没有区别
			else
			{
				if (n > _capacity)
				{
					reserve(n);
				}
 
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = val;
				}
 
				_str[n] = '\0';//将n的位置置\0
				_size = n;//更新_size
			}
		}

12.push_back（）

// 8.push_back的模拟！(追加的是一个 字符！)
		void push_back(const char ch)
		{
			// 扩容2倍
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';

		}

13.append（）

// 9.append的模拟！(追加的是一个 字符串！)
		void append(const char* str)
		{
			// 弹性扩容，直接计算str大小
			int n = strlen(str);
			if ((n + _size) > _capacity)
			{
				reserve(n + _size);// 要多少就扩多少！
			}
			strcpy(_str + _size, str);
			_size += n;
		}

14.operator+=（）

//(1)operator+=重载:字符
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		//(2)operator+=重载:字符串
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

15.insert（）

// 11.insert的模拟：
		// (1)字符
		void insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			// 扩容
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			// 法1：
			 下面这个while循环是挪pos后面位置的字符
			//int end = _size;// 你只要记住是 有符号(int) 自动转为 无符号(size_t) 就行了
			//while (end >= (int)pos) // 这里的无符号和有符号进行比较或者运算的时候，
			//					// 直接把这个end的int直接转换成无符号(size_t)，无符号的时候如果pos等于0就会陷入无限循环!
			//{
			//	_str[end + 1] = _str[end];
			//	end--;
			//}
			/*_str[pos] = ch;
			_size++;*/

			// 法2：
			int end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}
			_str[pos] = ch;
			_size++;
		}

		// (2)字符串：
		void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			int len = strlen(str);
			if (len + _size > _capacity)
			{
				reserve(len + _size);
			}
			int end = len + _size;
			// 这个只是挪动pos后面数据的过程！
			while (end > pos)
			{
				_str[end] = _str[end - len];
				--end;
			}
			// 插入
			strncpy(_str + pos, str, len);
			_size = len+_size;
		}

16.erase（）

// 12.erase的模拟：
		void erase(size_t pos, size_t len = -1)
		{
			assert(pos < _size);
			if (len == -1 || len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}

		}

17.find（）

// 14.find的模拟
		// (1)查找字符！
		size_t find(char ch, size_t pos)const// pos的意义就是：从哪个位置开始查找！
		{
			assert(pos <= _size);
			for (size_t i = pos; i < _size; i++)
			{
				if (_str[i] == ch) 
				{
					return i;
				}
				else
				{
					return -1;
				}
			}
		}
		// (2)查找字符串！
		size_t find(char* str, size_t pos)const// pos的意义就是：从哪个位置开始查找！
		{
			assert(pos < _size);
			const char* p = strstr(_str + pos, str);
			if (p)
			{
				return p-_str;
			}
			else
			{
				return -1;
			}
		}

18.operator>

        bool operator>(const string& s)
		{
			return strcmp(_str, s._str) < 0;
		}

19.operator==

	    bool operator==(const string& s)
		{
			return strcmp(_str, s._str) == 0;
		}

20.operator>=

	    bool operator>=(const string& s)
		{
			return (*this > s) || (*this == s);
		}

21.operator<

	    bool operator<(const string& s)
		{
			return !(*this >= s);
		}

22.operator<=

	    bool operator<=(const string& s)
		{
			return !(*this > s);
		}

23.operator!=

	    bool operator!=(const string& s)
		{
			return !(*this == s);
		}

24.clear（）

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

25.substr的模拟：(从字符串中截取一段长度len的子字符串！)

// substr的模拟：(从字符串中截取一段长度len的子字符串！)
		string substr(size_t pos, size_t len = -1)
		{
			string sub;
			// (1)截取的长度len远超于字符串的总长度_size
			if (len >= _size - pos)
			{
				for (size_t i = pos; i < _size; i++)
				{
					sub += _str[i];
				}
			}
			else
			{
				//for (size_t i = pos; i < _size - pos; i++)
				for (size_t i = pos; i < pos+len; i++)//应该打印的是len个长度的！
				{
					sub += _str[i];
				}
			}

			return sub;
		}

26.getline函数的模拟：

// getline函数的模拟：
	istream& getline(istream& in, string& s)
	{
		//1.先清理
		s.clear();
		char ch;
		// in>>ch
		ch = in.get();

		char buff[128];

		size_t i = 0;
		while (ch != '\n')
		{
			buff[i++] = ch;
			// buff[0,126]

			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;

				i = 0;//
			}

			ch = in.get();// 

		// 走到此处：遇到了'\n' && 没有进去if(i==127)没有把数组填充满！
		if (i > 0)// 
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}

27.operator<<

// 重载 <<
	ostream& yjl::operator<<(ostream& out, const yjl::string& _str)
	{

		for (size_t i = 0; i < _str.size(); i++)
		{
			out << _str[i];
		}
		return out;
	}

28.operator>>

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

完整代码段：

string.h（头文件）

#pragma once
#include<string.h>
#include<iostream>
#include<assert.h>
namespace yjl
{


	class string
	{
		friend ostream& operator<<(ostream& out, const yjl::string& _str);
	private:
		char* _str;
		size_t _size;
		size_t _capacity;


	public:
		/*string(const char* str=" ")
			:_size(strlen(str))
			,_str(new char[strlen(str)+1])
			,_capacity(strlen(str))  // 在初始化列表里面调用太多的strlen！！！
		{

		}*/



		typedef char* iterator;

		// 1.构造函数
		//string(const char* str = nullptr) //这里的str不能给nullptr，因为strlen（nullptr）会出错！
		//string(const char* str = "\0")// 不能是'\0'因为'\0'是char类型，不能赋值给char* 类型的！而"\0"就是空串！ 可以
		string(const char* str = " ")// 官方的写法！空串里面就默认有一个'\0'
			:_size(strlen(str))

		{
			_str = new char[_size + 1];
			_capacity = _size;
			strcpy(_str, str);
		}

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


		// 3.下标+[]：遍历
		// (1)capacity模拟
		size_t capacity()
		{
			return _capacity;
		}
		//(2) size()函数的实现！(求string对象的大小)
		size_t size()const // 最好写成const，不仅普通对象可以调用，const对象也可以调用！
		{
			return _size;
		}


		// (3)[]的模拟：返回的是字符(有const，只读！！！)
		const char& operator[](size_t pos)const
		{
			assert(pos < _size);
			return _str[pos];
		}
		// (4)可读可写
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		// 4.模拟迭代器：
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}

		// 5.const 迭代器的模拟
		iterator begin()const
		{
			return _str;
		}
		iterator end()const
		{
			return _str + _size;
		}

		// 6.c_str(将 字符串 转化  字符)
		const char* c_str()
		{
			return _str;
		}

		// 7.reserve 扩容（1）new新空间（2）拷贝字符串（3）释放旧空间（4）指向新空间（5）更新_capacity
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				// 1.new新空间
				char* tmp = new char[n + 1];
				// 2.拷贝字符串
				strncpy(tmp, _str, _size + 1);
				// 3.释放旧空间
				delete[] _str;
				// 4.指向新空间
				_str = tmp;
				// 5.更新_capacity
				_capacity = n;
			}
		}

		

		// 8.push_back的模拟！(追加的是一个 字符！)
		void push_back(const char ch)
		{
			// 扩容2倍
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';

		}

		// 9.append的模拟！(追加的是一个 字符串！)
		void append(const char* str)
		{
			// 弹性扩容，直接计算str大小
			int n = strlen(str);
			if ((n + _size) > _capacity)
			{
				reserve(n + _size);// 要多少就扩多少！
			}
			strcpy(_str + _size, str);
			_size += n;
		}
		// 10.
		//(1)operator+=重载:字符
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		//(2)operator+=重载:字符串
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}
		// 11.insert的模拟：
		// (1)字符
		void insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			// 扩容
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			// 法1：
			 下面这个while循环是挪pos后面位置的字符
			//int end = _size;// 你只要记住是 有符号(int) 自动转为 无符号(size_t) 就行了
			//while (end >= (int)pos) // 这里的无符号和有符号进行比较或者运算的时候，
			//					// 直接把这个end的int直接转换成无符号(size_t)，无符号的时候如果pos等于0就会陷入无限循环!
			//{
			//	_str[end + 1] = _str[end];
			//	end--;
			//}
			/*_str[pos] = ch;
			_size++;*/

			// 法2：
			int end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}
			_str[pos] = ch;
			_size++;
		}

		// (2)字符串：
		void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			int len = strlen(str);
			if (len + _size > _capacity)
			{
				reserve(len + _size);
			}
			int end = len + _size;
			// 这个只是挪动pos后面数据的过程！
			while (end > pos)
			{
				_str[end] = _str[end - len];
				--end;
			}
			// 插入
			strncpy(_str + pos, str, len);
			_size = len+_size;
		}

		// 12.erase的模拟：
		void erase(size_t pos, size_t len = -1)
		{
			assert(pos < _size);
			if (len == -1 || len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}

		}

		// 13.swap的模拟：
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		// 14.find的模拟
		// (1)查找字符！
		size_t find(char ch, size_t pos)const// pos的意义就是：从哪个位置开始查找！
		{
			assert(pos <= _size);
			for (size_t i = pos; i < _size; i++)
			{
				if (_str[i] == ch) 
				{
					return i;
				}
				else
				{
					return -1;
				}
			}
		}
		// (2)查找字符串！
		size_t find(char* str, size_t pos)const// pos的意义就是：从哪个位置开始查找！
		{
			assert(pos < _size);
			const char* p = strstr(_str + pos, str);
			if (p)
			{
				return p-_str;
			}
			else
			{
				return -1;
			}
		}

		// 15.substr的模拟：(从字符串中截取一段长度len的子字符串！)
		string substr(size_t pos, size_t len = -1)
		{
			string sub;
			// (1)截取的长度len远超于字符串的总长度_size
			if (len >= _size - pos)
			{
				for (size_t i = pos; i < _size; i++)
				{
					sub += _str[i];
				}
			}
			else
			{
				//for (size_t i = pos; i < _size - pos; i++)
				for (size_t i = pos; i < pos+len; i++)//应该打印的是len个长度的！
				{
					sub += _str[i];
				}
			}

			return sub;
		}

		// 16.清理
		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}

		

		 17.拷贝构造函数
		 (1) 传统写法：(必须是深拷贝)
		 s1(s2)
		//string(const string& s)
		//{
		//	// 因为是深拷贝，所以要用new新开辟一块空间
		//	_str = new char [s._capacity+1];
		//	strcpy(_str, s._str);
		//	_size = s._size;
		//	_capacity = s._capacity;
		//}
		// 
		// (2)现代写法：
		// s1(s2)
		string(const string& s)
		{
			string tmp = s._str;// 直接调用构造函数，让构造函数来完成 空间的开辟 和 拷贝！

			//string tmp (s._str);

			swap(tmp);
		}


		 18.赋值= 重载
		 (1)传统写法：
		 s1=s2
		//string& operator=(const string& s)
		//{
		//	// 开多大的空间，要看你要把谁赋值给别人。这里就是s2!
		//	char* tmp = new char[s._capacity];
		//	strcpy(tmp,s._str);

		//	delete[] s._str;

		//	_str = tmp;
		//	// 更新参数
		//	_size = s._size;
		//	_capacity = s._capacity;
		//	return *this;
		//}
		// (2)现代写法：复用，拷贝构造(在写 赋值 的现代写法之前，你还要写一个拷贝构造函数的现代写法，因为他要复用)
		// s1=s2
		string& operator=(const string& s)
		{
			string tmp(s);// 重载赋值函数调用拷贝构造，不会陷入死循环！只有拷贝构造自己调用拷贝构造才会陷入死循环！
			swap(tmp);
			return *this;
		}

	};

	// 1.重载 <<
	ostream& yjl::operator<<(ostream& out, const yjl::string& _str)
	{

		for (size_t i = 0; i < _str.size(); i++)
		{
			out << _str[i];
		}
		return out;
	}

	// 2.getline函数的模拟：
	istream& getline(istream& in, string& s)
	{
		//1.先清理
		s.clear();
		char ch;
		// in>>ch
		ch = in.get();

		char buff[128];

		size_t i = 0;
		while (ch != '\n')
		{
			buff[i++] = ch;
			// buff[0,126]

			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;

				i = 0;
			}

			ch = in.get();
		}

		// 走到此处：遇到了'\n' && 没有进去if(i==127)没有把数组填充满！
		if (i > 0)// 
		{
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}

	void test_string1()
	{
		string s1 = "hello world";
		string s2;
		cout << s1 << endl;

		for (size_t i = 0; i < s1.size(); i++)
		{
			cout << s1[i]++ << " ";
		}
		cout << endl;

		for (size_t i = 0; i < s1.size(); i++)
		{
			cout << s1[i] << " ";
		}
		cout << endl;
	}

	void test_string2()
	{
		string s1 = "hello world";
		string::iterator it1 = s1.begin();
		while (it1 != s1.end())
		{
			cout << *it1 << " ";
			it1++;
		}
		cout << endl;
		// 范围for
		for (auto e : s1)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test_string3()
	{
		string s1("hello world");
		s1.push_back('1');
		s1.push_back('2');
		s1.push_back('3');
		s1.push_back('4');
		cout << s1 << endl;

		//string s2("xxx");
		s1.append("xxx");

		cout << s1 << endl;
		s1 += "10,9,8,7";
		cout << s1 << endl;
		s1 += '6';
		cout << s1 << endl;

	}

	void test_string4()
	{
		string s1 = "hello world";
		s1.insert(0, 'x');

		cout << s1 << endl;

		s1.insert(4, "ccc");
		cout << s1 << endl;
	}

	void test_string5()
	{
		string s1 = "hello world";
		s1.erase(0, 5);
		cout << s1 << endl;

	}

	void test_string6()
	{
		string s1 = "hello world";
		string s2 = "hello bite";
		cout << s1 << endl;
		cout << s2 << endl;

		swap(s1, s2);
		cout << s1 << endl;
		cout << s2 << endl;
	}

	void test_string7()
	{
		string s1 = "hello world";
		size_t ret1=s1.find('o', 0);
		cout << ret1 << endl;

		//size_t ret2=s1.find("ld", 0);??????????????
	}

	void test_string8()
	{
		 下面演示一下由于浅拷贝(值拷贝)出现的错误问题
		//string s;
		//string s1 = "hello world";
		//s = s1.substr(2, 5); // 这一步 = (赋值)是浅拷贝
		 s1调用substr函数后的返回值(包括地址)直接浅拷贝给了s
		 所以局部变量s的_str和substr的_str的地址是一样的，指向同一空间，在局部变量s析构的时候会与substr的_str冲突
		//
		//cout << s << endl;



		//string s;
		string s1 = "hello world";
		string s = s1.substr(2, 5);
		
		cout << s << endl;
	}
	// 有疑问没解决！拷贝构造函数！！！
	void test_string9()
	{
		string s2 = "hello bite";
		string s1(s2);

		cout << s1 << endl;
	}

	void test_string10()
	{
		string s1 = "hello bite";
		string s2 = s1;
		cout << s2 << endl;
	}
}

2.源文件：

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>

#include <iostream>
using namespace std;

#include "string.h"
int main()
{

	//yjl::test_string2();
	//yjl::test_string1();
	//yjl::test_string3();

	//yjl::test_string4();
	//yjl::test_string5();
	//yjl::test_string6();
	//yjl::test_string7();
	//yjl::test_string8();
	yjl::test_string9();
	//yjl::test_string10();
	return 0;
}

---

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！