成员变量和查看接口

  string类中有三个成员变量分别记录有效元素个数、容量和字符串。而静态变量npos=1表示整型的最大值，且只能在类外部进行赋值

成员变量：

private:size_t _size;	//个数size_t _capacity; //容量char* _str;		//字符数组
public:const static size_t npos; //表示整形最大值

迭代器（读和读写）

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;
}

operator[]（读和读写）

  const成员函数前面的返回值也必须加上const，this->_str 不能被修改，而指针是内置类型，指针不能被修改，但是指针指向区域内容却可以被修改，因此返回值前面加上 const

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

c_str()

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

size()

size_t size() const
{return _size;
}

构造函数

用字符串构造

  注意，无参时我们给缺省值，给空串，里面不能带 空格，空格也是有效字符。new 开空间的时候，要开字符串长度 +1个，strlen() 函数只会记录有效字符个数，我们需要多卡一个空间给 \0 字符

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

用对象构造（两种方法）

  方法 1 用 memcpy 库函数，而不是 strcpy ，对于 “abc \0 def” 这种字符串，strcpy没办法处理，遇到 \0 就终止了，而 memcpy 是按内存中字节拷贝的
  方法 2 的话，调用了 swap() 库函数，且复用了用字符串构造函数，这里还需注意必须初始化 _str ，它是指针类型的，编译器不会自动初始化，那么和 tmp 交换后，析构 tmp 就会析构一段非法空间，而报错

//方法 1
string(const string& s)
{_str = new char[s._capacity + 1];memcpy(_str, s._str, s._size + 1);_size = s._size;_capacity = s._capacity;
}
//方法 2
string(const string& s):_size(0),_capacity(0),_str(nullptr)
{string tmp(s._str);swap(tmp);
}

析构

~string()
{delete[] _str;_str = nullptr;_size = _capacity = 0;
}

赋值运算符重载

  方法一比较原始，实现方法和 reserve() 函数一样，先开一样大小的空间，然后拷贝数据，再销毁原来空间，更新 _str，_capacity，_size
  方法二调用库里面的 swap() 函数便能轻松解决，那么思考为什么我们不直接交换 swap(*this, tmp) ？先看库里面 swap() 函数实现，不难发现里面的对象交换需要相互赋值，而赋值又要调用 operator()，而 operator() 里面又会调用 swap() 依次进行就变成了死递归

//方法一
string& operator=(const string& s)
{if (this != &s){char* tmp = new char[s._capacity + 1];memcpy(tmp, s._str, s._size+1);delete[] _str;_str = tmp;_size = s._size;_capacity = s._capacity;}return *this;
}
//方法二
string& operator=(string tmp)
{//std::swap(*this,tmp);//这样写死递归std::swap(_str, tmp._str);std::swap(_size, tmp._size);std::swap(_capacity, tmp._capacity);return *this;
}

扩容和调整

  扩容我们采取异地扩容的方式，考虑到 reserve() 函数外部也可以用，因此加个判断，异地扩容后记得把原来空间释放掉

reserve()

void reserve(size_t n)
{	//异地扩容if (n > _capacity){char* tmp = new char[n + 1];memcpy(tmp, _str, _size + 1);delete[] _str;_str = tmp;_capacity = n;}
}

resize()

  空间变小的话，我们还是不改变 _capacity，把 _size 改了，再赋上 \0 就行，空间大了的话，我们就异地扩容，再给要改变的 ch 加上缺省值 \0

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

clear()

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

增删查改

push_back()

	void push_back(const char ch){//扩容×2if (_size == _capacity){//有可能用空串初始化的reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;++_size;_str[_size] = '\0';}

append()

	void append(const char* str){size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}//strcpy(_str + _size, str);memcpy(_str + _size, str, len + 1);_size += len;}

operator+=()

  直接复用前面两个函数 push_back() 和 append() ，调用这两个函数，再考虑空间够不够，不够就扩容再尾插

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

insert()（字符和字符串）

  首先，检查一下插入位置的合法性，然后这意一下，end 是无符号类型，考虑 pos为0 时会造成死循环，end减为 -1 却是整形最大值，因此我们前面设置的静态变量 npos 便发挥了作用。最后注意边界问题，是否需要扩容

	void insert(size_t  pos, size_t n, char ch){assert(pos <= _size);if (_size + n > _capacity){reserve(_size + n);}size_t end = _size;_size += n;//end是无符号类型，考虑pos为0时 的死循环while (end >= pos && end != npos){_str[end + n] = _str[end];end--;}for (size_t i = 0; i < n; i++){_str[pos + i] = ch;}}void insert(size_t pos, const char* str){assert(pos <= _size);size_t len = strlen(str);if (len + _size > _capacity){reserve(len + _size);}size_t end = _size;_size += len;while (end >= pos && end != npos){_str[end + len] = _str[end];end--;}for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}}

erase()

  删除字符的个数我们给缺省值，方便边界判断。考虑 pos 的合法性后，再处理边界问题，删除工作就是不断从后往前迭代

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[end-len] = _str[end];++end;}_size -= len;}
}

find() （字符和字符串）

  没有找到找到就返回 npos ，缺省值从 0 开始找，找字符串有很多中算法，KMP，BF … 这里我们直接调用 strstr() 库函数简单实现就行

size_t find(char ch, size_t pos = 0)
{assert(pos < _size);for (size_t i = pos; i < _size; i++){if (_str[i] == ch){return i;}}return npos;
}
size_t find(const char* str, size_t pos = 0)
{assert(pos < _size);const char* ptr = strstr(_str + pos, str);if (ptr){return ptr - _str;}else {return npos;}
}

substr()

  检查 pos 合法性后，我需要计算切割字符串的长度。注意我们返回的是一个临时的 string 类，开好空间，然后调用 operator+= 函数，它会自动处理后面的 \0

string substr(size_t pos=0, size_t len = npos)
{assert(pos < _size);size_t n = len;if (len == npos || pos + len >= _size){n = _size - pos;}string tmp;tmp.reserve(n);for (size_t i = pos; i < pos + n; i++){tmp += _str[i];}return tmp;
}

string大小比较

operator<()

  由于字符串比较情况种类较多，比如 “abc” “abcd” 这种情况， 库函数 strcmp，memcmp 便不再适用， 它们适用于相同长度的字符串比较，长度不同容易出现越界问题，这里我们直接自己实现

bool operator<(const string& s) const
{size_t lt1 = 0;size_t lt2 = 0;while (lt1 < _size && lt2 < s._size){if (_str[lt1] < s._str[lt2]) {return true;}else if (_str[lt1] > s._str[lt2]) {return false;}else {lt1++;lt2++;}}return _size < s._size;
}

operator==()

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

复用

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 || *this == s;
}
bool operator!=(const string& s) const
{return !(*this == s);
}

IO流

operator<<()

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

operator>>()

  插入前要处理，缓冲区前面的空格和换行，用循环解决掉空格和换行字符。进行流插入的时候，我们设置一个中将数组，让插入数据先放在buff数组中，避免调用多次 operator+= 函数而引起多次扩容判断，最后再处理后面的 \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'){buff[i++] = ch;if (i == 127){//加上'\0'以免+=出问题buff[i] = '\0';s += buff;i = 0;}ch = in.get();}if (i != 0){buff[i] = '\0';s += buff;}return in;
}