resize

resize的特点是扩容加初始化，如果所给的长度小于空间大小就会删除多余的数据。前面我们实现了reserve，但有这样一个问题，如果reserve的长度小于空间就会导致缩容，而我们知道，string中缩容用的是shrink_to_fit，而reserve并不会导致缩容。

测试：

size_t capacity()const
		{
			return _capacity;
		}

 可以看到出现了容量小于size的情况，这样在拷贝的时候就会越界并在析构时出错，我们加上判断就可以了。

void reserve(size_t n)
		{
			if (n > _size)
			{
				char* tmp = new char[n + 1];

				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}

 

对比reserve，它们的共同点都是不对capacity产生影响，这种以时间换空间的做法会增加对资源的消耗，除此之外，resize的初始化分三种情况：

n

size

n>size

我们实现前先看段代码：

 这段代码说明了什么问题呢？

答：resize的初始化是在原有数据的基础上初始化的，之所以举这个例子是因为不给第二个参数会默认给初始化，通过调试可以发现前10个数据其实是，希望大家能注意这一点。

我们可以用memset和遍历的方式初始化，当然不要忘了补上

void resize(size_t n, char ch = '')
		{
			if (n  _capacity)
				{
					reserve(n);//复用
				}
				memset(_str + _size, ch, n - _size);
				/*size_t i = _size;
				while (i 

 insert

插入接口分三个部分：
判断扩容

移动数据

插入并更正size

先看看插入单个字符 

void insert(size_t pos, char ch)
		{
			assert(pos _capacity)
				{
					reserve(_capacity * 2);//知道每次进多少数据
				}
				size_t end = _size;
				while (end >= pos)
				{
					_str[end + 1] = _str[end];
					--end;
				}
				_str[pos] = ch;
				++_size;
		}

测试数据：

	s1.insert(0,'x');

为什么呢？

原来我们用的是无符号整形，当end变为0时再进入循环并自减就会来到-1(整形的最大值),这样就会导致又进入循环发生不可预知的错误。

---

那我们将无符号改为int不就行了吗？

理论上是可以的，但是这样做不符合库的规范。如果仅让end变为int也不行，编译器在对两个不同类型数据进行判断时，会进行隐式转换，而unsigned int与int比较会转换为两个unsigned int的比较，所以依然不行。

---

那该怎么做呢？

既然是end出了问题，就重源头下手，不要老想着加判断或分开处理这样的方式，这是一种牺牲可读性的做法，后期维护时可能会一头雾水。

 误删了一大段代码发现程序还能跑起来，这个时候我们一定不要动它

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

库里面的接口是这样写的：

string& insert (size_t pos, size_t n, char c);

一般我们只插入单个字符，所以想要插入多个字符串，我们可以通过下面的接口实现。

void insert(size_t pos, const char* s)

		{
			assert(pos  _capacity)//扩容
			{
				reserve(_size + len);
			}
			size_t end = _size+len;
			while (end > len+pos -1)
			{
				_str[end] = _str[end -len];
				end--;
			}
			strncpy(_str + pos, s, len);//不拷贝
            _size += len;
		}

这里需要减1比较难以理解，可以假设当pos＝_size时，无法进入循环体移动位置，最终导致被覆盖出错。不用>=判断是因为如果变量都为0可能会造成刚才为负数的情况，这种判断条件最多是右边为负数，由于无符号的特性，此时跳出循环，相当于什么都不做，符合逻辑。 

 对之前的尾插函数复用 

        void push_back(char ch)
		{
			insert(_size, ch);
		}
		void append(const char* s)
		{
			insert(_size, s);
		}

测试结果：

erase

介绍erase之前我们先来看看如何定义缺省npos

npos是一个静态常量成员函数，而静态成员函数是在类外初始化的

private:
static const size_t npos;
//内外
const size_t string::npos = -1;

需要知道的是，对于静态常整形，可以在类里指定一个缺省值

		static const size_t n = -1;

可以看到，删除数据有三种情况，但可以归为两类：部分删除和删除指定位置之后的所有数据

	string& erase(size_t pos, size_t len = npos)
		{
       		assert(pos = _size)//全删
			{
				_str[pos] = '';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);//部分删
					_size -= len;
			}
            return *this;//可以返回可以不返回
		}

注意这里判断len==pos的理由是如果用npos+pos可能会导致值溢出，这样就会重置其值可能导致判断错误。 

测试结果：

swap

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

从这一点看出来使用string类的swap效率是远远高于库里的swap的，std::swap需要创建临时对象，实现三次深拷贝，而string::swap只需对三个内置类型的成员变量进行交换就可以了。 

find

对于单个查找我们可以这样实现：

size_t find(char ch, size_t pos = 0) const//单个查找
		{
			assert(pos 

查找字符串我们可以用strstr函数进行查找 

 strstr的查找规则是如果找到就用指针返回第一个出现的下标，负责返回空指针。

	size_t find(const char* s, size_t pos = 0)const//字串
		{
			assert(pos 

cout&&cin

cout

与c_str不同，cout是打印string中的size个数据，他不会遇到就终止打印。

还有一点，不是所有cout重载都要变成友元，如果实现了对应获取成员变量的函数则无需添加友元，保护其封装性。

std::ostream& operator

( 这里用std::和自己实现的结果一样)注意这里用”和””所表达意思完全不同，单引号是解析成一个字符常量(占用1size空间)，双引号为字符串结束标志，在我们附加world的时候用双引号作为结束标志则会被覆盖掉(没有意义)。可以在world前加使其只输出hello。而c语言风格的不做区别，有直接停止输出。

结论：当作为字符常量时，cout输出size大小的数据

cin

std::istream& operator>>(std::istream& in,string& s)
	{
		char ch;
		in >> ch;
		while (ch != ' ' && ch != 'n')
		{
			s+=ch;
			in >> ch;
		}
		return in;
	}

上面的程序可以运行，但是无法结束循环，这是为什么呢？

cin作为流提取，会将空格和换行符等一些空白字符当作间隔符区分不同数据，所以并不会读取它们。为了读取这两种字符，我们可以使用istream中的get函数

	char ch = in.get();
		while (ch != ' ' && ch != 'n')
		{
			s+=ch;
			ch = in.get();
		}
		return in;

除此之外，我们还需要用一个清理函数清理上一次输入的值

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

对于输入一个很大的数据，我们可以提前开好空间来减少扩容

我们可以创建一个局部变量buff来储存数据，由于是手动输入数据，用这样的方式相比reserve更加灵活(出了作用域自动销毁）。

std::istream& operator>>(std::istream& in,string& s)
	{
		s.clear();
		char ch = in.get();
		char buff[128];
		size_t i = 0;
		while (ch != ' ' && ch != 'n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[127] = '';
				s += buff;
				i = 0;
			}
			ch = in.get();
			if (i != 0)
			{
				buff[i] = '';
				s += buff;
			}
		}
		return in;
	}

这里buff终止位置加是为了添加到数组的时候不至于越界。

string大小

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

在vs环境下，模拟实现的string只有12字节，而库里的string存在一个_buf数组存储16个空间，之前我们在讲string时也说过，这样空间换时间的做法提高了程序的效率。

string.h完整代码

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
#include
using std::cout;
using std::endl;
using std::cin;
namespace zzl
{
	class string
	{
	public:
		//string()
		//	:_str(new char[1])//匹配析构
		//	,_size(0)
		//	,_capacity(0)
		//{
		//	_str[0] = '';
		//}
		string(const char* str = "")//""也可以
			:_size(strlen(str))
		{
			_capacity = _size==0? 3:_size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		~string()
		{
			delete[] _str;
			_capacity = _size = 0;
		}
		string(const string& s)
			:_size(s._size)
			,_capacity(s._capacity)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}
		void swap(string& s)//交换
		{
			std::swap(_str, s._str);
			std::swap(_capacity,s._capacity);
			std::swap(_size,s._size);
		}
		size_t find(char ch, size_t pos = 0) const//单个查找
		{
			assert(pos (const string& s) const
		{
			return strcmp(_str, s._str) > 0;
		}
		bool operator>=(const string& s) const
		{
			//return *this > s || *this == s;
			return *this > s || s == *this;
		}

		bool operator= s);
		}

		bool operator s);
		}

		bool operator!=(const string& s) const
		{
			return !(*this == s);
		}
		//扩容
		void reserve(size_t n)
		{
			if (n > _size)
			{
				char* tmp = new char[n + 1];

				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void resize(size_t n, char ch = '')
		{
			if (n  _capacity)
				{
					reserve(n);//复用
				}
				memset(_str + _size, ch, n - _size);
				/*size_t i = _size;
				while (i _capacity)
				{
					reserve(_capacity * 2);//注意capacity不能为0(构造已给初始值)
				}
				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* s)

		{
			assert(pos  _capacity)//扩容
			{
				reserve(_size + len);
			}
			size_t end = _size+len;
			while (end > len+pos -1)//涉及的移动
			{
				_str[end] = _str[end -len];
				end--;
			}
			strncpy(_str + pos, s, len);//不拷贝
			_size += len;
		}
		void erase(size_t pos, size_t len = npos)
		{
			assert(pos = _size)//全删
			{
				_str[pos] = '';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);//部分删
					_size -= len;
			}
		}
		void push_back(char ch)
		{
			//if (_size + 1 > _capacity)
			//{
	
			//	reserve(_capacity == 0 ? 3: _capacity * 2);//复用
			//}
			//_str[_size] = ch;//处插入
			//_size++;
			//_str[_size] = '';
			insert(_size, ch);
		}
		void append(const char* s)
		{
			/*int len = strlen(s);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, s);
			_size += len;*/
			insert(_size, s);
		}
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		string& operator+=(const char* s)
		{
			append(s);
			return *this;
		}
		void clear()
		{
			_str[0] = '';
			_size = 0;//一般不缩容
		}
	private:
		 char* _str;
		size_t _size;
		size_t _capacity;

		static const size_t npos;
		//static const size_t n = -1;
	};
	const size_t string::npos = -1;
	std::ostream& operator>(std::istream& in,string& s)
	{
		s.clear();
		char ch = in.get();
		char buff[128];
		size_t i = 0;
		while (ch != ' ' && ch != 'n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[127] = '';
				s += buff;
				i = 0;
			}
			ch = in.get();
			if (i != 0)
			{
				buff[i] = '';
				s += buff;
			}
		}
		return in;
	}
}

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net