代码收藏家 使用String类模拟实现字符串操作（二）
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
size<n<capacity
n>size
我们实现前先看段代码：
这段代码说明了什么问题呢？
答：resize的初始化是在原有数据的基础上初始化的，之所以举这个例子是因为不给第二个参数会默认给\0初始化，通过调试可以发现前10个数据其实是\0，希望大家能注意这一点。
我们可以用memset和遍历的方式初始化，当然不要忘了补上\0
void resize(size_t n, char ch = '\0')
{
if (n <= _size)
{
_size = n;
_str[n] = '\0';
}
else
{
if (n > _capacity)
{
reserve(n);//复用
}
memset(_str + _size, ch, n - _size);
/*size_t i = _size;
while (i < n)
{
_str[i] = ch;
i++;
}*/
_size = n;
_str[_size] = '\0';
}insert
插入接口分三个部分：
判断扩容移动数据
插入并更正size
先看看插入单个字符
void insert(size_t pos, char ch)
{
assert(pos <= _size);// '\0'可以插
if (_size+1>_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 <= _size);
size_t len = strlen(s);
if (_size + len > _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);//不拷贝\0
_size += len;
}这里需要减1比较难以理解，可以假设当pos＝_size时，无法进入循环体移动\0位置，最终导致被覆盖出错。不用>=判断是因为如果变量都为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);
if (len == npos || pos + len >= _size)//全删
{
_str[pos] = '\0';
_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 < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
}查找字符串我们可以用strstr函数进行查找
strstr的查找规则是如果找到就用指针返回第一个出现的下标，负责返回空指针。
size_t find(const char* s, size_t pos = 0)const//字串
{
assert(pos < _size);
char* ptr = strstr(_str + pos, s);
if (ptr!=nullptr)
{
return ptr - _str;//位移量
}
else return npos;//find不匹配返回npos
}
cout&&cin
cout
与c_str不同，cout是打印string中的size个数据，他不会遇到\0就终止打印。
还有一点，不是所有cout重载都要变成友元，如果实现了对应获取成员变量的函数则无需添加友元，保护其封装性。
std::ostream& operator<<(std::ostream& out,const string& s)
{
for (auto ch : s)//实现了begin()和end()
{
out << ch;
}
/* for (size_t i = 0; i <s.size(); i++)
{
out << s[i];
}*/
return out;
}
}
( 这里用std::和自己实现的结果一样)注意这里用'\0'和"\0"所表达意思完全不同，单引号是解析成一个字符常量(占用1size空间)，双引号为字符串结束标志，在我们附加world的时候用双引号作为结束标志则会被覆盖掉(没有意义)。可以在world前加\0使其只输出hello。而c语言风格的不做区别，有\0直接停止输出。
结论：当\0作为字符常量时，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] = '\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] = '\0';
s += buff;
i = 0;
}
ch = in.get();
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
}
return in;
}这里buff终止位置加\0是为了添加到数组的时候不至于越界。
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<iostream>
#include<assert.h>
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] = '\0';
//}
string(const char* str = "\0")//""也可以
:_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 < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
}
size_t find(const char* s, size_t pos = 0)const//字串
{
assert(pos < _size);
char* ptr = strstr(_str + pos, s);
if (ptr!=nullptr)
{
return ptr - _str;//位移量
}
else return npos;//find不匹配返回npos
}
const char* c_str()const//外部不加const，指针可以改变
{
return _str;//返回常量字符串
}
char& operator[](size_t pos)
{
assert(pos < _size);//\0不存有效数据
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
string& operator=(const string& s)
{
if (this != &s)
{
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;//指向堆区
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
size_t size()const
{
return _size;
}
size_t capacity()const
{
return _capacity;
}
//模拟迭代器打印
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str+size();
}
//const
const_iterator begin()const
{
return _str;
}
const_iterator end()const
{
return _str + size();
}
void Print(const string& s)const
{
for (int i = 0; i < s.size(); i++)
{
cout << s[i] << " ";
}
cout << endl;
for (auto& ch : s)//const
{
cout<< ch << ' ';
}
cout << endl;
}
bool operator==(const string& s)const
{
return !strcmp(_str, s._str);
//return strcmp(_str, s._str) == 0;
}
bool operator>(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<(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);
}
//扩容
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 = '\0')
{
if (n <= _size)
{
_size = n;
_str[n] = '\0';
}
else
{
if (n > _capacity)
{
reserve(n);//复用
}
memset(_str + _size, ch, n - _size);
/*size_t i = _size;
while (i < n)
{
_str[i] = ch;
i++;
}*/
_size = n;
_str[_size] = '\0';
}
}
void insert(size_t pos, char ch)
{
assert(pos <= _size);// '\0'可以插
if (_size+1>_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 <= _size);
size_t len = strlen(s);
if (_size + len > _capacity)//扩容
{
reserve(_size + len);
}
size_t end = _size+len;
while (end > len+pos -1)//涉及\0的移动
{
_str[end] = _str[end -len];
end--;
}
strncpy(_str + pos, s, 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';
_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;//\0处插入
//_size++;
//_str[_size] = '\0';
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] = '\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::ostream& out,const string& s)
{
for (auto ch : s)
{
out << ch;
}
/*for (size_t i = 0; i <s.size(); i++)
{
out << s[i];
}*/
return out;
}
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] = '\0';
s += buff;
i = 0;
}
ch = in.get();
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
}
return in;
}
}
