C++入门--string类的实现

最新推荐文章于 2024-04-04 19:55:45 发布
最新推荐文章于 2024-04-04 19:55:45 发布
阅读量1.4k 收藏 19
点赞数 6
分类专栏： C++初阶学习 文章标签： c++ 学习 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74288306/article/details/132129569
版权

目录

1.string类常用函数实现

（1）string类成员变量定义

namespace llh
{
	class string
	{
	private:
		size_t size;//string类的大小
		size_t capacity;//string类的存储容量
		char* _str;
	};
}

我们定义string类的成员变量有size、capacity、_str，配合我们实现插入、删除、扩容等修改操作函数，并且把我们自己实现的string类成员函数封装在命名空间里面，避免和标准库里面的string类类型、函数冲突。

（2） string类默认构造函数实现

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

我们在实现默认构造函数时，①使用""空字符串作为缺省参数，常量字符串末尾有'\0'，是跟库里面string类默认构造函数无参调用以及string类其他变量初始化配合，_str = new char[_capacity + 1];中capacity+1是不传参调用时存储'\0'；②构造函数使用初始化列表进行初始化，初始化列表中成员的初始化顺序与成员变量声明顺序应保持一致。

（3） string类拷贝构造函数实现

		//拷贝构造函数
		//拷贝构造函数
		string(const string& s)
		{
			if (this != &s)
			{
				_str = new char[s._capacity + 1];
				_size = s._size;
				_capacity = s._capacity;
				//strcpy(_str, s._str);
				//拷贝构造的string类中包含'\0'，且'\0'后还有字符
				//strcpy只能拷贝到'\0'位置，剩余字符不能拷贝
				memcpy(_str, s._str, _size + 1);
			}
		}

使用string类对象s进行拷贝构造时（1）如果进行浅拷贝（即值拷贝），编译器只是将对象中的值拷贝过来，这时候两个string类对象会使用同一块空间，此时发生的危害：①相互影响。一个string类对象修改空间的数据会影响另一个string类对象的数据内容②同一块空间会被析构两次，程序崩溃；（2）所以string类要进行深拷贝，_str = new char[s._capacity + 1];开辟相同的空间，memcpy(_str, s._str, _size + 1);把数据拷贝到新开辟得到空间中，内置类型变量_size、_capacity直接进行赋值，这时候两个对象使用不同的空间，其他数据相同。

（4）string类析构函数

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

使用delete操作符释放string类对象指向的空间，_size = _capacity = 0使用string类大小和存储容量清除为0。

（5）string类c_str()函数实现

		//string类返回字符串指针的函数
		const char* c_str()const
		{
			return _str;
		}

_str为私有成员变量，需要通过函数调用才能进行访问。

（6）string类size()函数实现

		size_t size()const
		{
			return _size;
		}

_size为私有成员变量，需要通过函数调用才能进行访问。

（7）string类operator[]函数实现

		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[]运算符重载，获取string类pos位置的字符，可以进行string类修改；const string类对象调用const修饰operator[]运算符，只能读取string类pos`位置的字符，不可以进行string类修改。

（8）string类迭代器的实现

		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类begin()迭代器为指针，指向string类第一个字符，end()迭代器为指针，指向string类最后一个有效字符的下一个位置②const类型的string类对象对数据内容进行访问，需要使用const类型的迭代器③迭代器封装在类域里面，使用迭代器需要在前面hhl::string::const对string类的数据才能进行访问。

（9）string类reserve函数实现

		void reserve(size_t n = 0)
		{
			//只允许进行扩容
			if (n > _capacity)
			{
				cout << "reserve->" << _capacity << endl;
				char* tmp = new char[n + 1];
				_capacity = n;
				//strcpy(tmp, _str);
			//拷贝构造的string类中包含'\0'，且'\0'后还有字符
			//strcpy只能拷贝到'\0'位置，剩余字符不能拷贝
				memcpy(tmp, _str, n + 1);
				delete[] _str;
				_str = tmp;
			}
		}

实现reserve函数的过程：①对n进行判断，只进行扩容不进行缩容②开辟n+1大小的空间，多出的一个位置存储'\0'③把原有的数据拷贝到新的空间，释放掉原来的空间，让_str指向新的空间。

（10）string类push_back函数实现

		void push_back(char c)
		{
			if (_size == _capacity)
			{
				//二倍扩容
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = c;
			++_size;
			_str[_size] = '\0';
		}

①在插入字符之前，判断string类字符个数_size是否和存储容量相等，如果相等需要扩容②在扩容的时候，无参构造对象有效字符数为0，需要指定开辟的空间大小，其余情况进行原有容量的二倍扩容③插入字符后，++_size;并且_str[_size] = '\0';在最后添加'\0'进行限制。

（11）string类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字符串是否需要扩容，这次我们进行按需扩容②使用strcpy函数将字符串str拷贝string类对象末尾，strcpy函数会将str字符串中的'\0'一起拷贝过去，不需要单独进行限制，最后更新string类数据个数。

（12）string类operator+=运算符重载函数实现

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

实现operator+=函数的原理push_back函数、append函数的原理是一样的，我们在这里直接进行对push_back 函数、append函数进行复用。

（13）string类insert函数实现

		void insert(size_t pos, size_t n, char c)
		{
			assert(pos <= _size);
			if (_size + n > _capacity)
			{
				//扩容到_size+n
				reserve(_size + n);
			}
			size_t end = _size;
			//挪动数据
			//当插入0位置时，end在结束时为-1，
			//由于end为无符号整型，会整型提升为整数的最大值，会发生越界访问的错误,程序崩溃
			while (end >= pos && end != npos)
			{
				_str[end + n] = _str[end];
				end--;
			}
			//插入n个字符c
			for (int i = 0; i < n; i++)
			{
				_str[i + pos] = c;
			}
			_size += n;
		}
		void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				//扩容到_size+len
				reserve(_size + len);
			}
			size_t end = _size;
			//挪动数据
			//当插入0位置时，end在结束时为-1，
			//由于end为无符号整型，会整型提升为整数的最大值，会发生越界访问的错误,程序崩溃
			while (end >= pos&&end!=npos)
			{
				_str[end + len] = _str[end];
				end--;
			}
			//插入字符串str
			for (int i = 0; i < len; i++)
			{
				_str[pos + i] = str[i];
			}
			_size += len;
		}

增加的成员变量：

//在string里面定义静态共有成员变量
	public:
		static size_t npos;
//在类外面进行初始化
	size_t string::npos = -1;

①判断插入字符数据是否需要扩容，以及pos位置是否合法②在挪动数据的时候，pos位置为0时，end在结束的时候为-1，因为end为size_t类型会整型提升为整型最大值，程序因越界访问直接崩溃。解决办法：①设置end变量类型为int类型，while循环判断框里的pos强转为0（库里面pos变量为无符号整型，同标准库里面的保持一致）③设置一个公有静态成员无符号整型变量npos，并且初始化为-1，附加一个判断条件end!=npos③进行字符数据的插入，_size += len;更新string对象数据个数。

（14）string类erase函数实现

		void erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			//要删除的长度很长，或字符串很短
			if (len == npos || pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t end = pos + len;
				while (end<=_size)
				{
					_str[pos++] = _str[end++];
				}
				_size -= len;
			}
		}

判断pos位置是否合法，如果pos位置之后要删除的数据个数很大，直接在pos位置加'\0'进行限制；或者正常进行挪动数据覆盖进行删除（把‘'\0'一起挪动）。

（15）string类find函数实现

		size_t find(char c, size_t pos = 0)
		{
			assert(pos < _size);
			for (size_t i = 0; i < _size; i++)
			{
				if (_str[i] == c)
				{
					return i;
				}
			}
			return npos;
		}
		size_t find( const char* s,size_t pos = 0)
		{
			assert(pos < _size);
			//pos位置开始
			const char* ptr = strstr(_str+pos, s);
			if (ptr)
			{
				//指针减指针为之间的字符个数，也为子串的起始位置
				return ptr-_str;
			}
			else
			{
				return npos;
			}
		}

查找字符串使用strstr子串查找函数进行查找，若查找成功，返回字符串第一次出现的位置，ptr-_str得到string类的下标位置，若查找失败返回空指针。

（16）string类substr函数实现

		string substr(size_t pos = 0, size_t len=npos)
		{
			assert(pos < _size);
			string tmp;
			//判断拷贝长度
			size_t n = len;
			//if (pos + len > _capacity)
			if (len==npos||pos + len > _size)
			{
				n = _size - pos;
			}
			//把子串的数据拷贝string类tmp
			for (size_t i = 0; i < n; i++)
			{
				tmp += _str[pos + i];
			}
			return tmp;
		}

①判断需要拷贝的string类字符串长度，如果过长，从pos位置拷贝到string类末尾②把子串的数据拷贝string类tmp，并且返回tmp

（17）string类resize函数模拟实现

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

判断是减少string类数据个数，还是增加数据个数。①若是减少string类数据个数，直接在对应的位置添加'\0'（不用进行缩容，考虑到后面还需要插入数据，反复进行扩容缩容，代价太大），_size = n;更新数据个数②若是增加string类数据个数，先进行扩容（若是存储容量足够，不需要扩容，否则就进行扩容，已在reserve函数中实现），插入字符c，_size = n;_str_size] = '\0'; 进行字符串限制和数据更新。

（18）string类流插入operator<<非成员函数模拟实现

	ostream& operator<<(ostream& out, string& s)
	{
		for (int i = 0; i < s.size(); i++)
		{
			out << s[i];
		}
		return out;
	}

①把operator<<函数实现成非成员函数，是为了保证第一个参数ostream& out②在实现该函数时，没有直接out << s.c_str() << endl;输出，string类不看'\0'而终止，而是以_size数据个数为终止输出。

(19)string类string类流提取operator>>非成员函数模拟实现

//定义为类成员函数
	void clear()
	{
		_str[0] = '\0';
		_size = 0;
	}
//定义为非成员函数
	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch = in.get();
		
		while (ch == ' ' ||ch == '\n')
		{
			ch = in.get();
		}
		char buff[128];
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			//使用一个128字节大小的数组，把读取到的字符存放数组
			//如果buff数组到127字符，一次性加载到string类对象
			//此时还有字符没有读取完，继续存放在buff数组,直到读取完毕
			//最后再把字符串加载到string类末尾
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			buff[i++] = ch;
			ch = in.get();
		}
		if (i != 0)
		{
		//当读取到buff数组的字符时，大于0小于127时
		//进行最后一次追加拷贝
			buff[i] = '\0';//进行字符串拷贝限制
			s += buff;
		}
	}

①对string类对象输入的情况，需要使用clear函数清除原有string类数据，重新对string类对象输入②istream流不能读取空格和'\n'，需要使用istream流中的get函数③考虑到拷贝数据个数太多，一个一个进行对string类拷贝需要，需要进行多次扩容；而不使用reserve函数进行开辟足够的空间，若空间开小了，达不到减少扩容的效果，若空间开大了，提取数据个数较小时，会造成空间浪费，所以选择128字节大小buff字符数组存储，进行适时拷贝。

(20)string类operator=运算符重载函数

传统写法实现：

		//传统写法
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				_str = new char[s._capacity + 1];
				_size = s._size;
				_capacity = s._capacity;
				memcpy(_str, s._str, _size + 1);
			}
			return *this;
		}

开辟和s对象的空间大小，进行数据拷贝
在这里插入图片描述

现代写法版本一：

		//现代写法
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				string tmp(s);
				swap(tmp);
			}
			return *this;
		}

现代写法版本二：

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

使用拷贝构造函数构造一个临时对象tmp，然后*this和tmp进行私有变量值交换，因为tmp是临时对象，在函数销毁时会自动调用析构函数，对tmp现在(this原来指向)的空间进行销毁！

(21)string类关系运算符重载

operator<函数

		//版本一
		bool operator<(const string& s)
		{
			size_t i1 = 0;
			size_t i2 = 0;
			while (i1 < _size && i2 < s._size)
			{
				if (_str[i1++] < s._str[i2++])
				{
					return true;
				}
				else
				{
					return false;
				}
			}
			return _size < s._size;
		}
		//版本二简洁写法
		bool operator<(const string& s)const
		{
			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
			return ret == 0 ? _size < s._size : ret < 0;
		}

版本一和版本二原理一样，先比较数据个数较小的string类的部分字符串，若是比较的数据内容相同，则判断数据个数大小，返回真值。

operator==函数

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

函数复用实现

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

2.string常用接口类函数实现源码

string.h文件

#pragma once
#include<iostream>
#include<string>
#include<string.h>
#include<assert.h>
using namespace std;
namespace hhl
{
	class string
	{
		//friend ostream& operator<<(ostream& out, string& s);
	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);
			//memcpy(_str, str, _size + 1);
		}
		//拷贝构造函数
		string(const string& s)
		{
			if (this != &s)
			{
				_str = new char[s._capacity + 1];
				_size = s._size;
				_capacity = s._capacity;
				//strcpy(_str, s._str);
				//拷贝构造的string类中包含'\0'，且'\0'后还有字符
				//strcpy只能拷贝到'\0'位置，剩余字符不能拷贝
				memcpy(_str, s._str, _size + 1);
			}
		}
		//传统写法
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				_str = new char[s._capacity + 1];
				_size = s._size;
				_capacity = s._capacity;
				memcpy(_str, s._str, _size + 1);
			}
			return *this;
		}
		//现代写法
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				string tmp(s);
				swap(tmp);
			}
			return *this;
		}
		string& operator=(string tmp)
		{
			swap(tmp);
			return *this;
		}
		//string类返回字符串指针的函数
		const char* c_str()const
		{
			return _str;
		}
		size_t size()const
		{
			return _size;
		}
		//析构函数
		~string()
		{
			_size = _capacity = 0;
			delete[] _str;
			_str = nullptr;
		}
		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 = 0)
		{
			//只允许进行扩容
			if (n > _capacity)
			{
				cout << "reserve->" << _capacity << endl;
				char* tmp = new char[n + 1];
				_capacity = n;
				//strcpy(tmp, _str);
			//拷贝构造的string类中包含'\0'，且'\0'后还有字符
			//strcpy只能拷贝到'\0'位置，剩余字符不能拷贝
				memcpy(tmp, _str, n + 1);
				delete[] _str;
				_str = tmp;
			}
		}
		void push_back(char c)
		{
			if (_size == _capacity)
			{
				//二倍扩容
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = c;
			++_size;
			_str[_size] = '\0';
		}
		void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			//for (size_t i = 0; i < len; i++)
			//{
			//	_str[_size + i] = str[i];
			//}
			//strcpy(_str + _size, str);
			memcpy(_str + _size, str, len + 1);
			_size += len;
		}
		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}
		void insert(size_t pos, size_t n, char c)
		{
			assert(pos <= _size);
			if (_size + n > _capacity)
			{
				//扩容到_size+n
				reserve(_size + n);
			}
			size_t end = _size;
			//挪动数据
			//当插入0位置时，end在结束时为-1，
			//由于end为无符号整型，会整型提升为整数的最大值，会发生越界访问的错误,程序崩溃
			while (end >= pos && end != npos)
			{
				_str[end + n] = _str[end];
				end--;
			}
			//插入n个字符c
			for (int i = 0; i < n; i++)
			{
				_str[i + pos] = c;
			}
			_size += n;
		}
		void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				//扩容到_size+len
				reserve(_size + len);
			}
			size_t end = _size;
			//挪动数据
			//当插入0位置时，end在结束时为-1，
			//由于end为无符号整型，会整型提升为整数的最大值，会发生越界访问的错误,程序崩溃
			while (end >= pos && end != npos)
			{
				_str[end + len] = _str[end];
				end--;
			}
			//插入字符串str
			for (int i = 0; i < len; i++)
			{
				_str[pos + i] = str[i];
			}
			_size += len;
		}
		//void erase(size_t pos, size_t len = npos)
		//{
		//	assert(pos < _size);
		//	//要删除的长度很长，或字符串很短
		//	if (len == npos || pos + len >= _size)
		//	{
		//		_str[pos] = '\0';
		//		//_str[_size] = '\0';
		//		_size=pos;
		//	}
		//	else
		//	{
		//		//进行覆盖移动
		//		for (size_t i = 0; i < _size-(pos+len); i++)
		//		{
		//			_str[pos+i] = _str[pos + i+len];
		//		}
		//		_str[_size - len] = '\0';
		//		_size -= len;
		//	}
		//}
		void erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			//要删除的长度很长，或字符串很短
			if (len == npos || pos + len >= _size)
			{
				_str[pos] = '\0';
				//_str[_size] = '\0';
				_size = pos;
			}
			else
			{
				size_t end = pos + len;
				while (end <= _size)
				{
					_str[pos++] = _str[end++];
				}
				_size -= len;
			}
		}
		size_t find(char c, size_t pos = 0)
		{
			assert(pos < _size);
			for (size_t i = 0; i < _size; i++)
			{
				if (_str[i] == c)
				{
					return i;
				}
			}
			return npos;
		}
		size_t find(const char* s, size_t pos = 0)
		{
			assert(pos < _size);
			//pos位置开始
			const char* ptr = strstr(_str + pos, s);
			if (ptr)
			{
				//指针减指针为之间的字符个数，也为子串的起始位置
				return ptr - _str;
			}
			else
			{
				return npos;
			}
		}
		string substr(size_t pos = 0, size_t len = npos)
		{
			assert(pos < _size);
			string tmp;
			//判断长度
			size_t n = len;
			//if (pos + len > _capacity)
			if (len == npos || pos + len > _size)
			{
				n = _size - pos;
			}
			//把需要的数据拷贝string类tmp
			for (size_t i = 0; i < n; i++)
			{
				tmp += _str[pos + i];
			}
			return tmp;
		}
		void resize(size_t n, char ch = '\0')
		{			
			if (n < _capacity)
			{
				_str[n] = '\0';
				_size = n;
			}
			else
			{
				reserve(n);
				for (size_t i = _size; i <n; i++)
				{
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '\0';
			}
		}
		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}
		//	// "hello" "hello"   false
		//	// "helloxx" "hello" false
		//	// "hello" "helloxx" true
		//版本一
		//bool operator<(const string& s)
		//{
		//	size_t i1 = 0;
		//	size_t i2 = 0;
		//	while (i1 < _size && i2 < s._size)
		//	{
		//		if (_str[i1++] < s._str[i2++])
		//		{
		//			return true;
		//		}
		//		else
		//		{
		//			return false;
		//		}
		//	}
		//	return _size < s._size;
		//}
		//版本二简洁写法
		bool operator<(const string& s)const
		{
			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
			return ret == 0 ? _size < s._size : ret < 0;
		}
		bool operator==(const string& s)const
		{
			return _size == s._size &&
				memcpy(_str, s._str, _size);
		}
		bool operator>(const string& s)const
		{
			return !(*this < s && *this == s);
		}
		bool operator<=(const string& s)const
		{
			return !(*this > s);
		}
		bool operator>=(const string& s)const
		{
			return !(*this < s);
		}
		bool operator!=(const string& s)const
		{
			return !(*this == s);
		}
	private:
		char* _str;
		size_t _capacity;//string类的存储容量
		size_t _size;//string类的大小
	public:
		static size_t npos;
		//const static size_t npos = -1;
		//整型可以这样使用，其他类型不可以，不建议这样使用
};
	size_t string::npos = -1;
	ostream& operator<<(ostream& out, string& s)
	{
		//out << s.c_str() << endl;
		for (int i = 0; i < s.size(); i++)
		{
			out << s[i];
		}
		return out;
	}
	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch = in.get();
		
		while (ch == ' ' ||ch == '\n')
		{
			ch = in.get();
		}
		char buff[128];
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			//使用一个128字节大小的数组，把读取到的字符存放数组
			//如果buff数组到127字符，一次性加载到string类对象
			//此时还有字符没有读取完，继续存放在buff数组,直到读取完毕
			//最后再把字符串加载到string类末尾
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			buff[i++] = ch;
			ch = in.get();
		}
		if (i != 0)
		{
			buff[i] = '\0';
			s += buff;
		}
	}
}
吾与C
关注
  • 6
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++中的string类（C++字符串）入门完全攻略
08-25
主要给大家介绍了关于C++中string类（C++字符串）入门的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用C++具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
STL入门快速入门教程-----学习C++
05-01
STL重要部分，包含了许多数据结构，有vector（动态增加的数组），queue（队列），stack（堆栈）……甚至也包括string，它也可以看做为一种容器，并且适用所有的容器可用的方法。 7：算法（algorithms）部分。STL重要...
c++学习之string实现
qq_61422622的博客
08-29 1376
这里给出标准官方的string实现，可以看到设计还是较为复杂的，有成员函数，迭代器，修饰符，容量，元素访问，字符串操作等，将字符尽可能的需求都设计出来，我们这里实现string中比较常用且重要的。
【C++】string 类的实现
honortech的博客
05-03 903
【C++】string 类的实现
c++-----string类及模拟实现———字符串
最新发布
2301_80687320的博客
04-04 652
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数， 但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可 能还会越界访问。一、string是什么？1. string是表示字符串的字符串类2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。3. string在底层实际是：basic_string模板类的别名，typedef basic_string string;
C++中的string类用法简介
热门推荐
liitdar的博客
08-21 30万+
string是C++标准库的一个重要的部分，主要用于字符串处理。可以使用输入输出流方式直接进行string操作，也可以通过文件等手段进行string操作。同时，C++的算法库对string类也有着很好的支持，并且string类还和c语言的字符串之间有着良好的接口。
C++实现string类
cliu1_16的博客
01-25 393
默认构造函数中，为ptr申请一个字节的堆内存，这样任何情况下，ptr都不为nullptr，避免了ptr是否为nullptr的情况，在随时访问的时候，就可以少写很多if判断。
C++ 自己动手简单实现字符串String类
魔筝炼药师
03-29 4740
实现一个自己的String类是一道考验C++基础知识的好题。能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！ 在这个类中包括了指针类成员变量m_pData，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。 仔...
【C++】深度剖析string类的底层结构及其模拟实现
m0_70980326的博客
04-13 1937
深度剖析string类的底层结构及其模拟实现
c++快速入门1
08-04
C++提供了比C更高级的特性，如类、模板、异常处理等，但同时也保留了C语言的基本语法和输入输出功能。在这个快速入门指南中，我们将探讨C++的基础知识，包括基本语法、数据类型、输入输出、变量、运算符、控制结构、...
C++转JAVA入门总结
04-08
2. string类 3. 数组 4. 循环分支 5. 工具类（数据容器、日期、正则表达式……） 6. JAVA流、文件、IO 7. JAVA异常 8. JAVA继承 1. 抽象类与抽象方法 2. JAVA接口 3. JAVA泛型编程 4. JAVA序列化 5.JAVA网络与多线程...
c++string类的实现
11-23
1)代码注释很详细的，非常适合学习STL的 2）string类经常用到find find_first_of find_first_not_of find_last_of find_last_not_of substr replace等，以及联合使用来达到java中的split和trim 3) 有些函数返回的是MyString& 、Char& 等(引用)，MyString、Char 等（传值）这得看你返回的对象是函数的局部变量还是全局变量（或者类当前对象成员变量）；前者只能返回一个MyString、Char 等；后者强烈建议返回MyString& 、Char& 等(引用)；
C++重写String类
05-26
C++重写String类C++重写String类C++重写String类C++重写String类
标准C++中的string类的用法总结
默默的博客
05-24 2万+
相信使用过MFC编程的朋友对CString这个类的印象应该非常深刻吧？的确，MFC中的CString类使用起来真的非常的方便好用。但是如果离开了MFC框架，还有没有这样使用起来非常方便的类呢？答案是肯定的。也许有人会说，即使不用MFC框架，也可以想办法使用MFC中的API，具体的操作方法在本文最后给出操作方法。其实，可能很多人很可能会忽略掉标准C++中string类的使用。标准C++中提供的str
C++自定义实现string类型
qq_51004011的博客
07-26 1314
对于C++中独有的一种类型，string类型不管在使用还是维护，都特别的方便。那么今天我们就来自定义实现一个string类型。
C++ STL：string类的模拟实现
weixin_43908419的博客
03-14 571
本文介绍了C++ STL库中string类的模拟实现
C++的String类简单实现
FreeGo~
11-03 207
String类实现，构造函数，初始化函数，析构函数，重载=,+=运算符,定义友元函数+,<<运算符,SubStr子串函数。 #include<iostream> #include<cstring> using namespace std; class String { private: char* str; int le...
String类的C++实现
王云腾的专栏
04-28 2788
String类的C++实现是一个C++面向对象的经典例子，下面就来看看String类是如何实现的： String.h String.cpp 一个更为完整的String类C++实现： String.h String.cpp 写时拷贝（Copy On Write） 在C++程序中，经常会遇到多个对象具有相同值的情况。这个时候完全没有必要将这些值分开存储，而可以让这些对象共享同一分值。比如下面的字符串对象的例子：
C++实现一个String类
于大博
06-19 955
构造函数，析构函数，拷贝构造函数(copy constructor)，重载赋值操作符(copy assignment operator) 首先是至少能够准确的写出这几个函数的声明。 class String { public: String(); String(const char *); //旧写法： //String(const S...
C++ -- STL文件解析
08-27
STL是指标准模板库（Standard Template Library），它是C++语言的一部分，提供了一系列的模板类和函数，用于支持通用的数据结构和算法。STL的目标是提供高效、可重用和可扩展的组件，以便开发人员能够更轻松地编写高...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值