【c++】string模拟实现

最新推荐文章于 2024-11-09 13:08:09 发布
最新推荐文章于 2024-11-09 13:08:09 发布
阅读量1.1k 收藏 23
点赞数 10
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyqzjw/article/details/136564397
版权

string类的接口

namespace zjw
{
	class string
	{public:
		typedef char* iterator;
		typedef   const char* const_iterator;
	private:
		char* _str;
		int _size;
		int _capacity;



	};

这里的迭代器直接使用原生指针来封装。
_str为指向string数组的首地址的指针。
_size为string数组的大小。
_capacity为string数组的容量

基本函数

实现 函数返回string的首地址；
实现 函数返回string的尾地址；
实现 函数返回string的大小；
实现 函数返回string的容量；

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



		}
	size_t size()
		{
			return _size;
		
		
		
		
		}
	size_t capacity()
		{
			return _capacity;

		
		}

如果一个string类不能被修改的话，就无法调用非const的成员函数
在这里插入图片描述

	const_iterator begin() const
		{
			return _str;



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



		}

默认构造以及析构函数

	string(const char* str = "")
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		~string()
		{ 
			delete[]_str;
			_str = nullptr;
			_size = _capacity = 0;

		
		
		
		
		}

这里有一个问题，就是默认构造传的缺省参数可以是nullptr 吗？？
答案是不行的，因为strlen要将str解引用找’\0’,如果传nullptr的话，对空指针解引用就会出错。
这里也不可以传单字符‘\0’,因为这里的str是const char* 类型，而’\0’是char 类型

运算符重载下标访问函数

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

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



		}

下标为_size的地方存的是’\0’,所以不用访问，pos<_size,为了让const迭代器不修改对于下标的值，修改上面得到下面，对上面进行函数重载

reserve函数

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

			}
		
		
		
		
		
		}

在这里插入图片描述
注意：这里多开一个是为了存’\0’;

push_back()函数

	void push_back(char ch)
		{
			if (_capacity == _size)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);

			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';


		
		
		
		
		}

原来下标是_size的地方是‘\0’,然后之间在_size的地方放入ch,_size++,染后在补一个’\0’;要插入数据的一半都要扩容

append函数

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

			}
			strcpy(_str + _size, str);
			_size += len;
			//_str[_size] = '\0';

		}

尾插一个字符串，如果string的大小+要插入的字符串大小>_capacity,就扩容到_size + len，刚好，strcpy会从str开始直到遇到‘\0’一个字节一个字节拷贝到_str + _size（原字符串’\0’的地方），这里会把str字符串后面的‘\0’也拷贝过来。

运算符重载+=字符以及+=字符串

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

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

		



		}

在这里传引用返回是因为_str指向的空间是在堆上开的，出函数不会被销毁，所以可以传引用返回

insert函数(插入字符)

void insert(size_t pos, char ch)
		{
			assert(pos<=_size);
			if (_capacity == _size)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);

			}
			size_t end = _size;
			while (end >=pos)
			{

				_str[end+1] = _str[end];
				end--;


			}
			_str[pos] = ch;
			_size++;

		
		
		
		
		
		}

上面这个写法可以吗？？
是不可以的
在这里插入图片描述
怎么修改呢？？

	void insert(size_t pos, char ch)
		{
			assert(pos<=_size);
			if (_capacity == _size)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);

			}
			size_t end = _size+1;
			while (end >pos)
			{

				_str[end] = _str[end-1];
				end--;


			}
			_str[pos] = ch;
			_size++;

		
		
		
		
		
		}

这样就可以了，我们从’\0’的下一个位置开始end,此时end结束的条件是=0，所以不会陷入循环，这里和顺序表的insert很像，可以参考顺序表那里。

earse函数

	void earse(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			if (len == npos || pos > _size-len)
			{
				_str[pos] = '\0';
				_size = pos;
				

			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;

			}
			
		
		
		
		
		
		
		}

删除从pos位置开始的len个字符长度的字符，如果len大于剩下的字符，就全删了，这里给的缺省值为npos=-1，可以认为是很大的数，绝对超过了pos后面的字符数，我们要在string里面声明一个npos,在类外面定义初始化。
在这里插入图片描述

如果len==npos或者len+pos>_size,就始要将pos开始后面的字符串全删除，我们直接在pos位置放’\0’即可，
_size=pos;
如果没有超过字符串
在这里插入图片描述

insert（插入字符串）

void insert(size_t pos, const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);

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

			}
			strncpy(_str + pos, str, len);
			_size += len;


		}

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/9d88ba8502954c0dbd884890654c612a.png

void test6()
	{
		string str;
		str.push_back('a');
		str.push_back('a');
		str.push_back('b');
		str.insert(2, "hello");
		cout << str.c_str();




	}

swap

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

}

	void test12()
	{   string str1;
		string str2;
		str1 += "hello";
		str2+="nihao";
		cout << "str1:"<<str1 << endl;
		cout << "str2:"<<str2 << endl;
		str1.swap(str2);
		cout << "str1:" << str1 << endl;
		cout << "str2:" << str2 << endl;

	}

在这里插入图片描述

这里我们自己实现的swap是类成员函数，但是#include< algorithm >这个头文件库里面也有一个swap,swap全局也有一个非成员函数swap

在这里插入图片描述

我们可以发现算法库中的swap需要完成三次的拷贝，以及一次析构（临时变量c的析构）,而string里面定义一个全局的swap,就是为了防止调用算法库里面的swap,因为会先在全局找，然后会在展开的库里找，而全局的swap实现只需要调用类里面的swap即可

	void swap(string& x, string& y)
	{
		x.swap(y);
		cout << "没使用库里的" << endl;
	
	}

	void test13()
	{
		string str1;
		string str2;
		str1 += "hello";
		str2 += "nihao";
		cout << "str1:" << str1 << endl;
		cout << "str2:" << str2 << endl;
		swap(str1, str2);//检测是调用库里的，还是全局的
		cout << "str1:" << str1 << endl;
		cout << "str2:" << str2 << endl;
	
	
	}

在这里插入图片描述

赋值以及拷贝构造

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

根据调试发现
在这里插入图片描述

老版本赋值

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

			




			

		}

find函数（查找字符）

	size_t find(char ch, size_t pos = 0)
		{

			for (int i = pos; i < _size; i++)
			{
				if (_str[i] == ch)
					return i;



			}
			return npos;





		}

从pos位置开始查找，如果pos使用缺省，则从第一个位置开始查找，从pos位置开始遍历，如果找到返回下标，如果找不到返回npos

	void test7()
	{
		string str;
		str.push_back('a');
		str.push_back('a');
		str.push_back('b');
		str.insert(2, "hello");
		cout << endl;
		int ret = str.find('b', 0);
		cout << ret;


	}

在这里插入图片描述

find函数（查找子串）

		size_t find(const char* sub, size_t pos = 0) const
		{
			assert(pos < _size);//下标为_size的是‘\0’
			const char* ptr = strstr(_str + pos, sub);
			if (ptr != nullptr)//找到了，但是strstr返回的是找到子串的起始地址-字符串起始地址就是子串相对起始位置的长度
			{
				return ptr - _str;

			}
			else
			{
				return npos;
			}





		}

	void test8()
	{
		string str;
		str += "beijing huanyingni zhangjiawang";
		int ret = str.find("zhangjiawang");
		cout << ret;




	}

在这里插入图片描述

substr函数

string substr(size_t pos = 0, size_t len = npos) const
		{
			string substr;

			if (pos > _size - len)
			{
				for (int i = pos; i <= _size; i++)
				{
					substr += _str[i];
				}


			}
			else
			{

				for (int i = pos; i < pos + len; i++)
				{
					substr += _str[i];
				}
				substr += '\0';

			}
			return substr;





		}

从pos位置开始取，取len个长度，分两种情况，如果从pos开始还没取到len长，就结束，就取到结尾，遍历pos到_size，string substr 保存遍历的值.
第二种，遍历pos到pos+len，string substr 保存遍历的值.最后记得加‘\0’;
在这里插入图片描述

运算符重载比较函数

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



	}
	bool operator>(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str());



	}
	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  !(s1 == s2);



	}

注意这里为什么要搞成全局的呢？？

	void test10()
	{
		string str1;
		string str2;
		str1 += "abc";
		str2 += "aba";

		cout << (str1 == str2) << endl;
		cout << ("aba" == str2) << endl;//2
		cout << (str2== "aba") << endl;




	}

因为第二种的话不满足类成员做左操作数，全局的话就可以，而第三个是会搞一个类型转换.

	void test10()
	{
		string str1;
		string str2;
		str1 += "abc";
		str2 += "aba";

		cout << (str1 == str2) << endl;
		cout << ("aba" == str2) << endl;
		cout << (str2== "aba") << endl;
		 cout << (str1>str2) << endl;
		 cout << (str1 >=str2) << endl;
		 cout << (str1<str2) << endl;
		 cout << (str1 <=str2) << endl;
		 cout << (str1!=str2) << endl;




	}

在这里插入图片描述

运算符重载流插入

	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto e : s)//遍历一个一个输出
		{
			out << e;
		}
		return out;






	}

有返回值是为了可以连续流插入

运算符重载流提取

版本一：

	istream& operator>>(istream& in, string& s)
	{
		
		char ch;

		
		in >> ch;//读取字符到ch
		while (ch != ' ' && ch != '\n')//读到‘ ’或‘\n’结束输入
		{s += ch;//将ch加进去
	    in >> ch;//循环读取


		}
		
return in;




	}

这样写会有一个问题，就是cin和scanf一样默认‘\n’和‘ ’是分割符不会进行读取，所以ch不会是空格或换行，所以陷入死循环.
在这里插入图片描述
版本2：
c语言中可以用getchar来读取，而c++中存在get就可以读空格

istream& operator>>(istream& in, string& s)
	{
		
		char ch;

		
		in.get(ch);
		
		
		while (ch != ' ' && ch != '\n')
		{

		
		
			s += ch;
			in.get(ch);


		}
		
			
			
		

		return in;




	}

	void test11()
	{
		string str1;
		string str2;
		cin >> str1;//>>str2;//>>str2;
		cout << str1;
		//cout << str1.capacity();




	}

在这里插入图片描述

版本3
由于我们在s+=ch，会出现频繁扩容，影响效率，我们应该怎么解决呢？？
我们可以提前开好空间，但是不知道应该开多大.假如说我们开128个

	istream& operator>>(istream& in, string& s)
	{
		
		char ch;

		
		in.get(ch);
		
		s.reserve(128);

		while (ch != ' ' && ch != '\n')
		{

		
		
			s += ch;
			in.get(ch);


		}
		
			
			
		

		return in;




	}

	void test11()
	{
		string str1;
		string str2;
		cin >> str1;//>>str2;//>>str2;
		//cout << str1;
		cout << str1.capacity();




	}

在这里插入图片描述
两个数据开128就会有极大的浪费，多一点还好
在这里插入图片描述
版本4

	istream& operator>>(istream& in, string& s)
	{
		s.clear();//可能我们s里面之前有数据，但是流提取是要覆盖的

		char ch;

		ch = in.get();
		
		char buff[128];
		int i = 0;
		while (ch != ' ' && ch != '\n')
		{

			buff[i++] = ch;
			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();


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

		return in;




	}

这里感觉可以类比冯诺依曼体系，buff就相当于内存，先将输入的值放在内存buff里面，等到装满了，在一次性给s,减少搬运次数.避免了一次空间开的很大，而数据只有几个
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

clear

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

		}

c_str

将const string* 转化为const char*

	const char* c_str() const
		{
			return _str;



		}

cout不能直接处理自定义类型string,但是可以使用c_str将string转成常量字符串，内置类型就可以直接打印

源码

.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
#include<assert.h>
#include<iostream>
#include<algorithm>
namespace zjw
{
	class string
	{
	public:
		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;



		}
		string(const char* str = "")
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		~string()
		{
			delete[]_str;
			_str = nullptr;
			_size = _capacity = 0;





		}
		size_t size()
		{
			return _size;




		}
		size_t capacity()
		{
			return _capacity;


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



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



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

			}





		}
		void push_back(char ch)
		{
			if (_capacity == _size)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);

			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';






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

			}
			strcpy(_str + _size, str);
			_size += len;
			//_str[_size] = '\0';

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



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





		}
		void insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_capacity == _size)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);

			}
			size_t end = _size + 1;
			while (end > pos)
			{

				_str[end] = _str[end - 1];
				end--;


			}
			_str[pos] = ch;
			_size++;






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



		}
		void earse(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			if (len == npos || pos > _size - len)
			{
				_str[pos] = '\0';
				_size = pos;


			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;

			}







		}
		bool empty()
		{

			return _size == 0;

		}
		void resize(size_t n, char ch = '\0')
		{

			if (n <= _size)
			{
				_str[n] = '\0';
				_size = n;

			}
			else
			{
				reserve(n);
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;

				}
				_size = n;





			}






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

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

			}
			strncpy(_str + pos, str, len);
			_size += len;


		}
		size_t find(char ch, size_t pos = 0)
		{

			for (int i = pos; i < _size; i++)
			{
				if (_str[i] == ch)
					return i;



			}
			return npos;





		}
		size_t find(const char* sub, size_t pos = 0) const
		{
			assert(pos < _size);
			const char* ptr = strstr(_str + pos, sub);
			if (ptr != nullptr)
			{
				return ptr - _str;

			}
			else
			{
				return npos;
			}





		}
		string substr(size_t pos = 0, size_t len = npos) const
		{
			string substr;

			if (pos > _size - len)
			{
				for (int i = pos; i <= _size; i++)
				{
					substr += _str[i];
				}


			}
			else
			{

				for (int i = pos; i < pos + len; i++)
				{
					substr += _str[i];
				}
				substr += '\0';

			}
			return substr;





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





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

			




			

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

		}
		friend istream& operator>>(istream& in, string& s);
	public:
		static const int  npos;




	private:
		char* _str;
		int _size;
		int _capacity;



	};
	const int string::npos = -1;
	void swap(string& x, string& y)
	{
		x.swap(y);
		cout << "没使用库里的" << endl;
	
	}
	istream& operator>>(istream& in, string& s)
	{
		s.clear();

		char ch;

		ch = in.get();
		
		char buff[128];
		int i = 0;
		while (ch != ' ' && ch != '\n')
		{

			buff[i++] = ch;
			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();


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

		return in;




	}
	//istream& operator>>(istream& in, string& s)
	//{
	//	
	//	char ch;

	//	
	//	in.get(ch);
	//	
	//	s.reserve(128);

	//	while (ch != ' ' && ch != '\n')
	//	{

	//	
	//	
	//		s += ch;
	//		in.get(ch);


	//	}
	//	
	//		
	//		
	//	

	//	return in;




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



	}
	bool operator>(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str());



	}
	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  !(s1 == s2);



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






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

	//	}
	//	return in;
	//
	//
	//
	//
	//}
	void test1()
	{
		string str;
		str += 'a';

		str += 'b';
		str += "beijing";


		string::iterator it = str.begin();
		while (it != str.end())
		{
			cout << *it << " ";
			it++;

		}





	}
	void test2()
	{
		string str;
		str.push_back('a');
		str.push_back('a');
		str.push_back('b');
		str.push_back('a');
		str.push_back('a');
		string::iterator it = str.begin();
		while (it != str.end())
		{
			cout << *it << " ";
			it++;

		}
		cout << str[2];





	}
	void test3()
	{
		string str;
		str.append("stringbj");
		for (auto& e : str)
		{
			cout << e << " ";
		}


	}
	void print_string(const string it)
	{
		string::const_iterator res = it.begin();
		while (res != it.end())
		{
			cout << *res << " ";
			++res;



		}




	}
	void test4()
	{
		string str;
		str += "abc";
		str.append("stringbj");
		string::iterator it = str.begin();
		while (it != str.end())
		{
			cout << *it << " ";
			it++;

		}
		//str.insert(0, 'g');
		for (auto& e : str)
		{
			cout << e << " ";
		}
		cout << endl;
		// str.earse(1,string::npos);*/
		/* for (auto e : str)
		 {
			 cout << e << " ";
		 }*/
		 // print_string(str);



	}
	void test5()
	{
		string str;
		str.push_back('a');
		str.push_back('a');
		str.push_back('b');
		str.resize(10);
		/* string::iterator it = str.begin();
		 while (it != str.end())
		 {
			 cout << *it << " ";
			 it++;

		 }*/
		cout << str.c_str();







	}
	void test6()
	{
		string str;
		str.push_back('a');
		str.push_back('a');
		str.push_back('b');
		str.insert(2, "hello");
		cout << str.c_str();




	}
	void test7()
	{
		string str;
		str.push_back('a');
		str.push_back('a');
		str.push_back('b');
		str.insert(2, "hello");
		cout << endl;
		int ret = str.find('b', 0);
		cout << ret;


	}
	void test8()
	{
		string str;
		str += "beijing huanyingni zhangjiawang";
		int ret = str.find("zhangjiawang");
		cout << ret;




	}
	void test9()
	{
		string str;
		str += "beijing huanyingni zhangjiawang";
		string op = str.substr(0, 10);
		cout << op.c_str();




	}
	void test10()
	{
		string str1;
		string str2;
		str1 += "abc";
		str2 += "aba";

		cout << (str1 == str2) << endl;
		cout << ("aba" == str2) << endl;
		cout << (str2== "aba") << endl;
		 cout << (str1>str2) << endl;
		 cout << (str1 >=str2) << endl;
		 cout << (str1<str2) << endl;
		 cout << (str1 <=str2) << endl;
		 cout << (str1!=str2) << endl;




	}
	void test11()
	{
		string str1;
		string str2;
		cin >> str1;//>>str2;//>>str2;
		//cout << str1;
		cout << str1.capacity();




	}
	void test12()
	{   string str1;
		string str2;
		str1 += "hello";
		str2+="nihao";
		cout << "str1:"<<str1 << endl;
		cout << "str2:"<<str2 << endl;
		str1.swap(str2);
		cout << "str1:" << str1 << endl;
		cout << "str2:" << str2 << endl;

	}
	void test13()
	{
		string str1;
		string str2;
		str1 += "hello";
		str2 += "nihao";
		cout << "str1:" << str1 << endl;
		cout << "str2:" << str2 << endl;
		swap(str1, str2);
		cout << "str1:" << str1 << endl;
		cout << "str2:" << str2 << endl;
	
	
	}
	void test14()
	{
		
		string str2;
		
		str2 += "nihao";
		string str1(str2);
	
	
	
	}
	
}

.cpp

#include"标头.h"

int main()
{
  zjw::test11();
}
#小多子
关注
专栏目录
C++string模拟实现
zc331的博客
09-14 1325
C++中的string相当于是一个类模板，包含在头文件string中，具体实现在这个头文件中名为std的namespace中，所以一般在直接使用string时，展开std；那么模拟实现string时，首先要将实现的内容放在一个自己定义的命名空间里面，在这个命名空间里面再定义自己的string类；这里实现string吗，模板的主要接口功能。
C++ string模拟实现
m0_72625526的博客
08-12 2260
既然要模拟实现string底层那就得先理解为什么我写的string和库string里面不会冲突。1 头文件查找路径当我们用双引号""包围头文件时，编译器会首先在当前目录下查找这个头文件。这意味着它会优先找到我们自己定义的头文件（比如string.h），而不是标准库中的头文件。因为标准库的头文件通常在其他系统目录中，所以不会发生冲突。2 避免名字冲突虽然使用双引号包含头文件可以让编译器优先使用我们自定义的头文件，但如果我们在头文件中定义了一个与标准库相同名称的类或函数，仍然可能导致混淆或冲突。
C++string模拟实现增删查改功能
weixin_41368411的博客
04-21 1621
一.reserve函数 1.1功能 改变当前sting对象空间容量的大小，如果需要改变的容量大小大于string对象的实际容量，就重新申请空间，扩容，否则就不需要扩容。 1.2返回值 无返回值 1.3实现逻辑 （1）判断需要扩容的容量n是否大于当前对象的实际容量 （2）在堆上申请大小n为的空间 （3）将对象中的字符串拷贝到在堆上新开辟的空间上，并释放该字符串指向的堆上的空间 （4）改变当前对象的实际容量值 实现代码如下所示 //增容改变空间大小，只有当要增容的空间大小大于当前对象
C++ string详解+模拟实现
m0_50655389的博客
03-14 917
在本篇文章中，我们主要介绍了 C++ 中的string 类的使用以及如何进行模拟实现。string 类是 C++ 标准库提供的一个重要组件，用于处理字符串，具有丰富的功能和便利的接口。我们首先介绍了 string 类的基本用法，紧接着详细讲解了string 类的模拟实现。在这个过程中，我们深入分析了 string 类的内部实现原理，包括字符串的存储结构、构造函数和析构函数的实现等。通过模拟实现 string 类，我们可以加深对C++ 中类的设计和实现的理解，同时也能提升我们的编程能力。
模拟实现string【C++】
2301_80058734的博客
06-28 2545
在文件mystring.h和中都定义上一个命名空间mystring把mystring.h中类的声明放进命名空间，把mystring中的函数实现也放进命名空间不同源文件的同名的命名空间经过编译链接之后可以合成在一起。
c++模拟实现string类
北川_的博客
01-11 1895
目录string类简介模拟实现成员变量成员函数构造函数拷贝构造赋值重载析构函数迭代器普通迭代器const迭代器重载运算符[ ]代码 string类简介 标准库类型string表示可变长的字符序列，使用string类型必须首先包含string头文件。作为标准库的一部分，string定义在命名空间std中。 模拟实现 成员变量 char* _str; size_t _size; size_t _capacity; //不包含最后做标识的'\0' static const size_t npos; _s
C++ —— 模拟实现string类
weixin_59913110的博客
11-07 1571
本篇博客分享了笔者如何模拟实现string类的过程。其中包括最常用、最实用的接口。例如流插入、提取运算符重载、下标运算符重载、常用的构造函数、析构函数……
C++ string类模拟实现
qq_64105689的博客
09-09 1179
1.创建string类 2.默认成员函数的模拟实现 2.1 Constructor(构造函数) 函数实现： 2.2 Destructor(析构函数) 函数实现： 2.3 拷贝构造函数 函数实现： 2.4 Operator=(赋值运算符的重载) 函数实现： 测试代码： 3.Capacity(容量) 函数实现： 测试代码： 4.Element access(元素访问) 测试代码： 5.Iterators(迭代器) 函数实现： 测试代码： 6.Madifiers(修
C++string的实现
qq_53558968的博客
07-03 4703
文章目录前言一、string类的特点二、string类的常用接口2.1 4大默认成员函数2.2 容量操作：2.3 string类对象的访问及遍历操作2.4 string类对象的修改操作2.5 判断的接口2.6 string类非成员函数三、string类的实现3.1 考虑成员变量该有什么3.1.1 为什么使用size_t3.2 4大默认成员函数的实现3.2.1 几个错误&&深浅拷贝3.2.2 拷贝构造和赋值现代写法3.2.3 C++11 noexcept， 移动构造和移动赋值3.
C++ string类的实现
m0_60447315的博客
08-21 3387
C++ string类实现
C++ string类的模拟实现
08-11
C++ string类的模拟实现
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
详解C++中String类模拟实现以及深拷贝浅拷贝 在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们...
C++_用 using 语句继承基类的构造函数
最新发布
学海无涯
11-09 241
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
常用的c++特性--＞day02
m0_69093426的博客
11-06 687
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1720
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 300
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
【Effective C++】阅读笔记5
gma999的博客
11-07 911
Effective C++ 面向对象和模板相关章节
C++模拟实现String类基础功能详解
"C++中的String类是一个非常常用的数据结构，用于处理文本字符串。本文将探讨如何简单地实现一个基础版的String类，虽然不能与标准库中的std::string完全相同，但足以涵盖一些核心功能，如构造函数、拷贝构造函数、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

#小多子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

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

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值