模拟实现string（传统写法与现代写法）

最新推荐文章于 2022-08-22 22:00:24 发布
最新推荐文章于 2022-08-22 22:00:24 发布
阅读量1.5k 收藏 4
点赞数 8
分类专栏： Cpp 文章标签： c++ string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45928272/article/details/115209832
版权

目录

1. 简易string（无增删查改）

开始必须重新定义一个命名空间，把我们自定义的string放进命名空间里。

假如不考虑增删查改，我们先可以做一个简单的string，几乎下意识的就写出了这样的构造函数

string(char* str)
			:_str(str)
		{}

这是非常不合理的，假如外面传入的是一个常量字符串。

string s("1234");

假如要修改常量字符串的话，会直接中断。
那我们就开一个和他同样大小的空间，再把字符拷贝进去。使用new开辟后面还可以动态增长。

namespace zjn
{
	class string
	{
	public:
		string(char* str)
			:_str(new char[strlen( str)+1])
		{
			strcpy(_str, str);
		}
		~string()
		{
			delete[] _str;
		}

	private:
		char* _str;
	};
}

有时我们也会定义无参的string。那么这样写可以吗，我们配合一个接口c_str进行验证

         string()
			:_str(nullptr)
		{
			;
		}
const char* c_str()
{
         return _str;
}
int main()
{
    zjn::string s1("1234");
	zjn::string s2;
	cout << s1.c_str() << endl;
	cout << s2.c_str ()<< endl;
	return 0;
	}

cout是自动识别类型，是因为他重载了各种类型的函数，打印的原理无非就是遇到‘\0’停止，可是在s2由于我们构造的时候使用nullptr构造的，所以cout会解引用进行访问，就会崩溃。（析构函数时delet[]所包含的free(NULL)并不会报错）
在这里插入图片描述
所以正确的做法应该是

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

其实只要写成默认构造函数就好了。这样就不用写两个构造函数

		string(char* str="")
			:_str(new char[strlen( str)+1])
		{
			strcpy(_str, str);
		}

1.1 深浅拷贝

在学习拷贝构造的时候，我们讲到一个stack对象的拷贝，自动生成的构造函数只是浅拷贝，两个指针指向的是同一块区域，所以执行析构函数的时候会将同一块资源释放两次。
在这里插入图片描述
在这里插入图片描述
所以默认生成的满足不了需求，必须自己写一个拷贝构造函数来实现深拷贝。
在这里插入图片描述

在这里插入图片描述

#include<iostream>
#include<assert.h>
#pragma warning(disable:4996)
using namespace std;

namespace zjn
{
	class string
	{
	public:
		
		string(char* str="")
			:_str(new char[strlen( str)+1])
		{
			strcpy(_str, str);
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		const char* c_str()
		{
			return _str;
		}
		string(const string& s)
			:_str(new char[strlen(s._str)+1])
		{
			strcpy(_str,s._str);
		}
		
		char&  operator[](size_t i)
		{
			assert(i < _size);
			return _str[i];
		}
		//释放原空间，然后深拷贝
		string& operator=(const string& s)
		{
			if (this!=&s)
			{
				delete[] _str;
				//不能直接strcpy因为空间可能不够
				_str = new char[strlen(s._str) + 1];
				strcpy(_str, s._str);
			}
			return *this;
		}
	private:
		char* _str;
	};
}
int main()
{
	zjn::string s1("1234");
	zjn::string s2;
	zjn::string s3(s1);
	s3[1] = 'x';
	cout << s1.c_str() << endl;
	cout << s2.c_str ()<< endl;
	return 0;
}

2. string的传统写法

一个真正的string是要支持增删查改的，所以必须要有size和capcacity。
size和capacity是内置类型几乎不需要注意什么地方

2.1 四个默认成员函数

		/*string(char* str)
			:_str(new char[strlen(str)+1])
			,_size(strlen( str))
			, _capacity(_size)
		{}*/
		string(char* str="")
		{
			_str=new char[strlen(str)+1];
			_size = strlen(str);
			_capacity = _size;
			strcpy(_str, str);
		}
		string(const string& s)
		{
			_size = s._size;
			_capacity = s._capacity;
			_str = new char[strlen(s._str) + 1];
			strcpy(_str, s._str);
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		string& operator=(const string& s)
		{
			if (this != &s){
			   delete[] str;
              _str = new char[strlen(s._str) + 1];
			  _capacity = s._capacity;
			  _size = s._size;
			}
			return *this;
		}
  • 默认构造函数：当默认构造函数选择为为参数列表声明时，最好不要写有依赖关系的，因为实际初始化的顺序只和声明的顺序有关。所以我们直接选择写在函数体内
  • 拷贝构造函数：需要深拷贝实现，即重新开一段空间，把数据拷贝过来
  • 重载赋值函数：需要注意自己给自己赋值的情况，释放原空间进行深拷贝，假如是自己给自己赋值的话，原空间释放，指针指向新开的一段空间，strlen时遇到’\0’停止，那段空间是随机值。

3. string的现代写法

3.1 构造函数与析构函数

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

         ~string()
		{
			delete[] _str;
			_str = nullptr;
			_capacity = _size=0;
		}
  • 构造函数与析构函数没有什么差别。

3.2 拷贝构造

一开始是这么写的

		string(const string& s)
		{.
		    //局部对象拥有相同的str，用于和this._str进行交换
			string temp(s._str);
		   std::swap(_str,temp._str);
		   std::swap(_size,temp._size);
		   std::swap(_capacity,temp._capacity);
		   
		}

很明显是有错误的，因为_str没有初始化是一个野指针。当与temp._str进行交换时，_str指向temp._str那块空间。temp._str指向那块随机空间，当出了函数体，调用析构函数，清理资源_str，free掉temp._str，就会报错，即free了一个野指针。

        string(const string& s)
			:_str(nullptr)
			,_size(0)
			,_capacity(0)
		{
		   string temp(s._str);
		   std::swap(_str,temp._str);
		   std::swap(_size,temp._size);
		   std::swap(_capacity,temp._capacity);
		}

那么我们将它初始化成nullptr就好了。

3.3 赋值重载

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

在这里插入图片描述
交换了之后，出了函数体，调用析构，刚好也会清理掉不要的"worldx"那块资源。

其实还有一种更简洁的写法

      //参数不能加const因为我们会修改s,不能传引用因为我们修改了s，传引用外面的也会修改
      
		string& operator=( string s)
		{
		    std::swap(_str, s._str);
		    std::swap(_size, s._size);
		    std::swap(_capacity, s._capacity);
			return *this;
		}

s就代替了之前的temp对象，且s也是一个局部对象，也会调用析构函数。
可以看到存在了大量的swap代码复用，我们可以将swap写成一个函数。然后对所有代码进行修改。


		string(const char* str="")
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_size + 1];
			strcpy(_str, str);
		}
		
		// std中的swap并不好
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size,s._size);
			std::swap(_capacity, s._capacity);
		}

		//拷贝构造
		//string s1(s2);
		string(const string& s)
			:_str(nullptr)
			, _capacity(0)
			, _size(0)
		{
			string temp(s._str);
			swap(temp);
		
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_capacity = _size=0;
		}
		string& operator=( string s)
		{
		    swap(s);
			return *this;
		}

这就是一个有资源管理的string的现代写法。

3.4 std中的swap与string中的swap

那么为什么不直接调用库中的swap交换两个对象，而是用库中的swap一个个交换属性，最后将他们封装成一个专门的swap呢？
swap(s1,s2);
s1.swap(s2);
这两种差异是特别大的。
std中的swap是一个由函数模板推演而来的模板函数。其中经历了一次拷贝构造，两次赋值。代价太大，效率会大打折扣。
在这里插入图片描述

4. 修改

         //[]重载
		char& operator[](size_t i)
		{
			assert(i < _size);
			return _str[i];
		}
		//[]重载(const对象调用)
		const char& operator[](size_t i)const
		{
			assert(i < _size);
			return _str[i];
		}
		//迭代器
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str+_size;
		}
		//迭代器(const对象)
		typedef const char* const_iterator;
		const_iterator begin()const
		{
			return _str;
		}
		const_iterator end()const
		{
			return _str + _size;
		}
	    //范围for
	   for (auto& e : s)
	    {
		e += 1;
	    }
  • 重载[]：需要注意，i需要小于size，size作为下表的话是’\0’的位置。
  • string 的迭代器实际就是一个指针。typedef为iterator是为了和其它接口保持一致，假如你是一个链表就不能继续使用指针了，因为指针指向那个节点，解引用之后是一个结构体，并不是节点的值。所以在链表中迭代器实际是这样定义的。
struct ListIterator
	{
		operator*();
		operator++();
		Node* node;
	};

重载他的*和++来达到目的。

  • 范围for：会自动转换为迭代器,也就是说自动调用begin(),与end()。

5. 增加

          void resize(size_t n, char ch='\0')
			{
			
			//_size变小，capacity不变，直接在n处放'\0'
			if (n<_size)
			{
			_str[n] ='\0';
			_size = n;
			}
			else
			{
				if (n>_capacity)
				{
					reserve(n);
				}
				//1 2 3 4 
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
					
				}
				_str[n] = '\0';
				_size = n;
				
			}
			}
         //增加就可能会引起扩容
         void reserve(int  n)
		    {
			if (n > _capacity)
			{
				//需要temp不然直接delete的话字符串的内容会丢失
				char* temp = new char[n + 1];
				strcpy(temp, _str);
				delete[] _str;
				_str = temp;
				_capacity = n;
			}
		}
		//字符尾插
		string& push_back(char ch)
		{
			if (_size == _capacity)
			{
				reserve(2 * _capacity);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
			return *this;
		}
		//字符串拼接
		void append(const char* str)
		{
			int len = strlen(str);
			if (len + _size> _capacity)
			{
				reserve(len + _size);
			}
			//忘记strcpy,参数忘记+_size
			strcpy(_str+_size, str);
			_size += len;
	
		}
         //字符+=
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		//字符串+=
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
			
		}
		//string对象+=
		string& operator+=(const string& s)
		{
			append(s._str);
			return *this;
		}
		//插入字符
		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
                size_t newcapacity = _capacity == 0 ? 8 : 2 * _capacity;
				reserve(newcapacity);
			}
			/*	逻辑没有问题，但是当pos等于0时，要把第一位往前挪，end--就会变成-1，才能由于类型为size_t他就会变为整形最大值。
			    假如把end变为int类型也避免不了，因为pos为size_t,身为int类型的end会类型提升为size_t,依旧是整形最大值。
				那把end变成int类型，再把pos显示的转为int(pos不要直接改成int与库不相符)，这样是可以的。
			    size_t end = _size;
				while(end>=pos)
				{
					_str[end + 1] = _str[end];
					end--;
				}*/
			//虽然_size是'\0',但是_size+1不会越界因为假如空间不够前面会扩容，数组是有这么大空间的，只不过没有存字符。
			//这样当pos等于0时，end为1字符已经全部挪走，end--为0，此时不会再进入循环，也就不会变成-1了。
         		size_t 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);
			int len = strlen(str);
			if (_size + strlen(str) > _capacity)
			{
				reserve(_size+len);
			}
			int end = _size + len;
			//画图分析
			//避免类型提升
			while (end  >= (int)pos+len)
			{
				_str[end] = _str[end - len];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
			return *this;
			
		}
  • reserve：只要增加就可能会有扩容的场景。
  • push_back：追加一个字符
  • append：拼接一个字符串。
  • +=：分别有字符，字符串，string三种函数
  • insert：push_back,append,+=可以复用这个插入函数，但是要注意类型提升问题。

6. 删除

//删除，和库类似，我们给一个npos缺省值
		void erase(size_t pos, size_t len = npos)
		{
			//从pos起，删除len个字符。
			assert(pos < _size);
			//len为npos的时候会溢出
			//if (pos+len>_size)
			//
			//假如要求删的超过字符串，a b c d,要求从c删除100个，就把d置成'\0'就行了。
			if (len == npos || pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				//直接拷过去，然后覆盖，'\0'也会拷贝过去
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}

		}
  • erase，注意溢出，直接使用strcpy覆盖。

7. 查找

        //查找字符，缺省默认从第一个位置开始
		size_t find(char ch, size_t pos = 0)
		{
			for (size_t i = 0; i < _size; i++)
			{
				if (ch == _str[i])
				{
					return i;
				}
			}
			return npos;
		}
		//查找子串
		size_t find(const char* sub, size_t pos = 0)
		{
			//在_str+pos这个字符串里找sub
			const char* ret = strstr(_str + pos, sub);
			if (nullptr == ret)
			{
				return npos;
			}
			else
			{
				return ret - _str;
			}
		}
  • find: 一个查找字符，一个查找子串，缺省值都是从第一个位置开始查找

8. 重载的全局函数

//大于重载
	bool operator>(const string& s1, const string& s2)
	{
		size_t l1=0, l2 = 0;
		while (l1 < s1.size() && l2 < s2.size())
		{
			if (s1[l1] == s1[l2])
			{
				l1++;
				l2++;
			}
			else
			{
				if (s1[l1]>s2[l2])
				{
					return true;
				}
				else
				{
					return false;
				}
			}
		}
		//假如有一个长一个短
		if (l1 < s1.size())
		{
			return true;
		}
		else if (l2 < s2.size())
		{
			return false;
		}
		else
		{
			return false;
		}
	}
	//==重载
	bool operator==(const string& s1, const string& s2)
	{
		size_t l1 = 0, l2 = 0;
		while (l1 < s1.size() && l2 < s2.size())
		{
			if (s1[l1] == s1[l2])
			{
				l1++;
				l2++;
			}
			else
			{
				return false;
			}
		}
		//假如有一个长一个短
		if (l1 < s1.size())
		{
			return false;
		}
		else if (l2 < s2.size())
		{
			return false;
		}
		else
		{
			return true;
		}

	}
	//输出
	std::ostream& operator<<(std::ostream& out, const string& s)
	{
		for (size_t i = 0; i < s.size(); i++)
		{
			out << s[i] ;
		}
		return out;

	}
	//输入
	std::istream& operator>>(std::istream& in,  string& s)
	{
		
		char ch;
		while (1)
		{
			//这样不行，默认空格为下一个，不能123这样输，只能1 2 3
			//in >> ch;
			in.get(ch);
			if ( ch==' '||ch=='\n')
			{
				break;
			}
			else
			{
				s += ch;
			}
		}
		return in;
	}

最终代码

#include<iostream>
#include<assert.h>

#pragma warning(disable:4996)


namespace zjn
{
	class string
	{
	public:
		//传统写法
		构造
		//string(const char* str = "")
		//{
		//	_size = strlen(str);
		//	_capacity = _size;
		//	_str = new char[_capacity + 1];
		//	strcpy(_str, str);
		//}
		析构
		//~string()
		//{
		//	delete[] _str;
		//	_str = nullptr;
		//	_capacity = _size = 0;
		//}
		拷贝构造
		//string(const string& s)
		//{
		//	_str = new char[strlen(s._str) + 1];
		//	strcpy(_str, s._str);
		//	_capacity = s._capacity;
		//	_size = s._size;
		//}
		赋值重载
		//string& operator=(const string& s)
		//{
		//	if (this != &s)
		//	{
		//		delete[] _str;
		//		_str = new char[strlen(s._str) + 1];
		//		strcpy(_str, s._str);
		//		_size = s._size;
		//		_capacity = s._capacity;
		//	}
		//	return *this;
		//}
		//构造
		string(const char* str = "")
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_size + 1];
			strcpy(_str, str);
		}

		 //std中的swap并不好
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		//拷贝构造
		//string s1(s2);
		string(const string& s)
			:_str(nullptr)
			, _capacity(0)
			, _size(0)
		{
			string temp(s._str);
			swap(temp);

		}
		//析构
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_capacity = _size = 0;
		}
		//赋值
		string& operator=(string s)
		{
			swap(s);
			return *this;
		}
		size_t size()const
		{
			return _size;
		}
		//重载[]
		//返回值忘记引用了
		
		char& operator[](size_t i)
		{
			assert(i < _size);
			return _str[i];
		}
		const char& operator[](size_t i)const
		{
			assert(i < _size);
			return _str[i];
		}
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		typedef const char* const_iterator;
		const_iterator begin()const
		{
			return _str;
		}
		const_iterator end()const
		{
			return _str + _size;
		}
		//增
		//扩容+初始化。
		//当前n<capacity的话，不改变capacity，只改变size。n>capacity，改变size改变capacity。
			void resize(size_t n, char ch='\0')
			{
			
				//_size变小，capacity不变，直接在n处放'\0'
			if (n<_size)
			{
			_str[n] ='\0';
			_size = n;
			}
			else
			{
				if (n>_capacity)
				{
					reserve(n);
				}
				//1 2 3 4 
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
					
				}
				_str[n] = '\0';
				_size = n;
				
			}
			}
		//扩容
		void reserve(size_t  n)
		{
			if (n > _capacity)
			{
				//需要temp不然直接delete的话字符串的内容会丢失
				char* temp = new char[n + 1];
				strcpy(temp, _str);
				delete[] _str;
				_str = temp;
				_capacity = n;
			}
		}
		//字符尾插
		void push_back(char ch)
		{
			/*if (_size == _capacity)
			{
			reserve(2 * _capacity);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';*/
			insert(_size, ch);

		}
		void append(const char* str)
		{
			//int len = strlen(str);
			//if (len + _size> _capacity)
			//{
			//	reserve(len + _size);
			//}
			忘记strcpy,参数忘记+_size
			//strcpy(_str+_size, str);
			//_size += len;
			insert(_size, str);

		}
		//字符+=
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		//字符串+=,参数忘记const
		string& operator+=(const char* str)
		{
			append(str);
			return *this;

		}
		//string对象+=
	    string& operator+=(const string& s)
		{
			append(s._str);
			return *this;
		}
		//插入字符
		void insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
			    //假如capacity为0一开始开8个对象类型(char)空间
				size_t newcapacity = _capacity == 0 ? 8 : 2 * _capacity;
				reserve(newcapacity);
			}
			/*	逻辑没有问题，但是当pos等于0时，要把第一位往前挪，end--就会变成-1，才能由于类型为size_t他就会变为整形最大值。
				假如把end变为int类型也避免不了，因为pos为size_t,身为int类型的end会类型提升为size_t,依旧是整形最大值。
				那把end变成int类型，再把pos显示的转为int(pos不要直接改成int与库不相符)，这样是可以的。
				size_t end = _size;
				while(end>=pos)
				{
				_str[end + 1] = _str[end];
				end--;
				}*/
			//虽然_size是'\0',但是_size+1不会越界因为假如空间不够前面会扩容，数组是有这么大空间的，只不过没有存字符。
			//这样当pos等于0时，end为1字符已经全部挪走，end--为0，此时不会再进入循环，也就不会变成-1了。
			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				end--;
			}
			_str[pos] = ch;
			_size++;
			

		}
		//插入字符串
		void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			int len = strlen(str);
			if (_size + strlen(str) > _capacity)
			{
				reserve(_size + len);
			}
			int end = _size + len;
			//画图分析
			//避免整形提升
			while (end >= (int)pos + len)
			{
				_str[end] = _str[end - len];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
			

		}
		//删除，和库类似，我们给一个npos缺省值
		void erase(size_t pos, size_t len = npos)
		{
			//从pos起，删除len个字符。
			assert(pos < _size);
			//len为npos的时候会溢出
			//if (pos+len>_size)
			//
			//假如要求删的超过字符串，a b c d,要求从c删除100个，就把d置成'\0'就行了。
			if (len == npos || pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				//直接拷过去，然后覆盖，'\0'也会拷贝过去
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}

		}
		//查找字符，缺省默认从第一个位置开始
		size_t find(char ch, size_t pos = 0)
		{
			for (size_t i = 0; i < _size; i++)
			{
				if (ch == _str[i])
				{
					return i;
				}
			}
			return npos;
		}
		//查找子串
		size_t find(const char* sub, size_t pos = 0)
		{
			//在_str+pos这个字符串里找sub
			const char* ret = strstr(_str + pos, sub);
			if (nullptr == ret)
			{
				return npos;
			}
			else
			{
				return ret - _str;
			}
		}


	private:
		char* _str;
		size_t _capacity;
		size_t _size;
		//声明
		static const size_t npos;
	};
	//定义初始化
	const size_t string::npos = -1;
	//大于重载
	bool operator>(const string& s1, const string& s2)
	{
		size_t l1=0, l2 = 0;
		while (l1 < s1.size() && l2 < s2.size())
		{
			if (s1[l1] == s1[l2])
			{
				l1++;
				l2++;
			}
			else
			{
				if (s1[l1]>s2[l2])
				{
					return true;
				}
				else
				{
					return false;
				}
			}
		}
		//假如有一个长一个短
		if (l1 < s1.size())
		{
			return true;
		}
		else if (l2 < s2.size())
		{
			return false;
		}
		else
		{
			return false;
		}
	}
	//==重载
	bool operator==(const string& s1, const string& s2)
	{
		size_t l1 = 0, l2 = 0;
		while (l1 < s1.size() && l2 < s2.size())
		{
			if (s1[l1] == s1[l2])
			{
				l1++;
				l2++;
			}
			else
			{
				return false;
			}
		}
		//假如有一个长一个短
		if (l1 < s1.size())
		{
			return false;
		}
		else if (l2 < s2.size())
		{
			return false;
		}
		else
		{
			return true;
		}

	}
		//大于等于
	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);
	}
	//输出
	std::ostream& operator<<(std::ostream& out, const string& s)
	{
		for (size_t i = 0; i < s.size(); i++)
		{
			out << s[i] ;
		}
		return out;

	}
	//输入
	std::istream& operator>>(std::istream& in,  string& s)
	{
	     //防止对一个原本就有数据的对象输入
		s.resize(0);
		char ch;
		while (1)
		{
			//这样不行，默认空格为下一个，不能123这样输，只能1 2 3
			//in >> ch;
			in.get(ch);
			if ( ch==' '||ch=='\n')
			{
				break;
			}
			else
			{
				s += ch;
			}
		}
		return in;
	}
	
}
楠c
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
模拟实现string以及一些接口
02-27
模拟实现string以及一些接口
高逼格之String... 的写法
凌云之陟
09-28 910
以前看java源码的时候经常能看见String…这种写法，今天在读mybatis的源码的时候又看见了，于是拿来研究了一下，先看mybatis中的源码： private static void register(String type, String...databaseProductNames) { TYPE_NAME.put(type, asList(databaseProduc
Java方法中参数String...你需要知道的事
CowboyStyle的博客
03-02 6451
String…的含义 String… args 为类型后面三个点（eg：String …），是从Java 5开始，Java语言对方法参数支持的一种新写法，叫可变长度参数列表；表示此处接受的参数为0到多个Object类型的对象，或者是接受一个String[] 类型的参数。 String…的使用 在使用的时候，对于test(String…strings)，你可以直接用test()去调用，表示无参调用，也可以用去test(“abc”)，也可以用test(new String[]{“abc”,”abd”})，但你不
String...的用法
热门推荐
Keep on moving!
01-08 8万+
一、前言 在项目中，在检查参数是否为空的工具类中，出现了一个函数的参数列表是这种写法，于是学习了一下这种用法的使用。个人觉得这种处理还是很不错的，使得代码更加简洁。 二、用法 String…是java5新加入的功能，表示的是一个可变长度的参数列表。 其语法就是类型后跟…，表示此处接受的参数为0到多个Object类型的对象，或者是一个Object[]。 例如我们有一个方法叫做test(String…...
java中String...这种写法的意义
每天积累一点点
10-10 795
今天在xwork2的源码文件中看见了这样的一种写法： public static String format(String msg, String... args) {} String... args 这种形式叫可变长度参数列，表示此处接受的参数为0到多个Object类型的对象，或者是一个Object[]数组。 如：传递参数时可以有一下几种方式：     String[] tp = {"d
方法参数String ... strings写法
luoxue0345的博客
09-18 1083
类型后面三个点（eg：String ...），是从Java 5开始，Java语言对方法参数支持的一种新写法，叫可变长度参数列表。 其语法就是：类型X ... 参数名，表示此处接受的参数为0个到多个类型X的对象，或者是一个类型X数组。 例如：我们有一个方法叫做test(String ... strings)，那么你还可以写方法test()，但你不能写test(String[] strings)，这样会出编译错误，系统提示出现重复的方法。 在使用的时候，对于test(String ... strings.
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
模拟实现string类深浅拷贝
01-08
从构造，析构以及拷贝构造的方面理解string类的底层实现。 源代码获取： https://github.com/akh5/C-/blob/master/STL/Mystring.cpp string的底层通过字符指针char*通过构造函数申请对应大小的空间，并将指针指向其...
C++中string的模拟实现
09-01
主要为大家详细介绍了C++中string的模拟实现，感兴趣的小伙伴们可以参考一下
String类的写法
han_shi_lei的博客
03-24 935
String类的传统写法： #include <iostream> #include <assert.h> class String{ String(const char* str = ""){ if (nullptr == str){ assert(false); return; } _str = new char[strlen(str) + 1...
第三题代码.txt（吉林大学 C++ 上机实验 参考代码）
06-01
C++的一般编译器都定义和封装了字符串功能，请模仿定义string类的实现，可以实现并支持如下功能： （1）string s = “吉林大学”； （2）string t = s; （3）string m； m = t； （4）m.legnth() 函数测量字符串的长度 （5）m.cat(string const &)连接字符串
Java的可变参数，参数后面三个点
沸沸腾的专栏
04-18 2893
private void removeTempFiles(String... fileNames) { for (String fileName : fileNames) { try { new File(fileName).delete(); } catch (Exception e) { }
冰冰学习笔记：string类的简单模拟
bingbing_bang的博客
08-22 281
string类的模拟实现，通过模拟掌握string的用法及原理
STL中string类的用法及其模拟实现
weixin_45897952的博客
04-28 593
目录 一、string类的默认存储字符类型： 二、string类的使用： 1.创建对象 2.三种遍历sting的方式： 2.1.for+[]的方式： 2.2.迭代器： 2.3.范围for遍历（其实也是依赖类中的迭代器进行遍历元素） 3.插入数据的方式： 4.删除数据 5.reserve和resize（扩容操作） 5.1.resize: 5.2.reserve： 5.3.疑问(resize和reserve两种平台下的扩容规律)？ 6.c_str() 7.在字符串中找出子串 8.
【C++】string类的模拟实现
qq_53893431的博客
07-04 265
经管跑路人的C++笔记
模拟实现String类----传统写法
z_xiao_xue的博客
07-08 1046
面试时经常会遇到一道题，就是写一个简单的String类，很多人不假思索的就给出了下面这样的写法class String { String(char* str) :_str(new char[strlen(str)]) {} String(const String& s) :_str(s._str) {} String operator=(const String& s) {
c++ String类及深浅拷贝（传统写法与现代写法）code
Ferlan的博客
09-09 337
主要内容：模拟实现String类的默认成员函数，增删查改，及各类运算符重载等。 #define _CRT_SECURE_NO_WARNINGS 1 #include&amp;amp;lt;iostream&amp;amp;gt; #include&amp;amp;lt;string.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; #include&amp;amp;lt;asse
string类及其简单模拟实现
weixin_45231718的博客
03-13 238
一.string类 1.string是表示字符串的类。该类的接口与常规容器基本相同，再添加了一些专门用来操作字符串的操作。 二.string类常见的对象构造 1.string():构造空的字符串。 2.string（const char *s）:用c-string来构造string类对象 3.string (const string &s):拷贝构造函数 三.string类常用操作 1.s...
C++_多态（深入理解虚函数表）
qq_45928272的博客
05-13 4724
多态 多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。 比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票 怎么构成多态 并没有构成多态，形参p对象，全部调用了Person类的成员函数。 多态与重写 这时候就需要使用虚函数来构成多态。 梳理一下，多态的条件： 继承类中，需要对虚函数进行重写。 基类的指针或者引用都去调用这个虚函数 而重写的条件 3. 父子类中的函数都是虚函数。 4. 函数名参数返回值都要相
c++string类的模拟实现
最新发布
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您...这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

楠c

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

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

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

打赏作者

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

抵扣说明：

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

余额充值