【手撕STL】string类
string类
- 标准库中的string类
-
- string类
- string类的常用接口说明
- string类的模拟实现
-
- Member functions
-
- 构造函数
- 析构函数
- 拷贝构造（深拷贝）
- 赋值重载（深赋值）
- Capacity
-
- size
- capacity
- reserve
- resize
- clear
- Modifiers
-
- push_back
- append
- insert
- operator+=
- swap
- erase
- Element access
-
- operator[]
- Iterators
-
- begin
- end
- String operations
-
- c_str
- find
- Member constants
-
- npos
- Non-member function overloads
-
- operator+
- operator>>
- operator<<
- getline
- relational operators
- 写时拷贝
- string类中Linux与VS得区别
标准库中的string类
string类
- 字符串是表示字符序列的类
- 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
- string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型
- string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数
- 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
string类的文档介绍
注：
string类用utf-8编码，按单字节处理
u16string用utf-16编码
u32string用utf-32编码
wstring类按两字节处理
编码：
计算机中存储只有二进制0、1，用对应的ASCII表来表示文字（支持英文的）其中ASCII表是对256个值建立一个对应的表示值
在早期只有欧美国家使用计算机（早期的计算机中只能表示英文，不能表示其他国家的文字），后来全世界各个国家都开始用计算机了，需要建立自己的编码表
在Linux中常用utf-8、utf-16、utf-32
在Windows中常用gbk
总结：
- string是表示字符串的字符串类
- 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
- string在底层实际是：basic_string模板类的别名，typedef basic_string
- 不能操作多字节或者变长字符的序列。
在使用string类时，必须包含#include < string > 头文件以及using namespace std;
string类的常用接口说明
具体用法见string类的常见接口说明
- string类对象的常见构造
- string类对象的访问及遍历操作
#define _CRT_SECURE_NO_WARNINGS 1
#include总结：
迭代器是一个行为像指针的东西，有可能是指针，也有可能不是指针
迭代器可以用统一类似的方式去访问修改容器
begin（）返回的是第一个有效数据位置的迭代器，end（）返回的是最后一个有效数据的下一个位置的迭代器
rbegin（）返回的是最后个有效数据位置的迭代器，rend（）返回的是第一个有效数据的前一个位置的迭代器
所有的容器都支持用迭代器，所以迭代器才是容器通用的访问方式（vector/string这样的结构支持下标+[]去访问，而像list、map这样的就不支持了）
const对象要用const迭代器，只读，不能写
operator[]和at的区别：operator[]如果发生越界访问会报断言错误（assert），而at会报异常（需要捕获异常）
- string类对象的容量操作
#define _CRT_SECURE_NO_WARNINGS 1
#include
注意：
- size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
- clear()只是将string中有效字符清空，不改变底层空间大小。
- resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
- reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
- 在Windows中容量是以大约1.5倍增容的，在Linux中容量是以大约2倍增容的
- reserve的作用：如果知道需要多少空间，直接一次性开好，避免增容，提高效率
- resize的作用：既能开好空间，又能对这些空间初始化
- string类对象的修改操作
#define _CRT_SECURE_NO_WARNINGS 1
#include应用场景：
#define _CRT_SECURE_NO_WARNINGS 1
#include注意：
- 在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
- 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
- string类非成员函数
注：cin遇到空格和换行就会分割（或结束），而getline遇到空格不会分割（或结束）遇到换行才分割（或结束）
- string类对象的字符串的转换（在C++11适用）
#define _CRT_SECURE_NO_WARNINGS 1
#includestring类的模拟实现
string类的成员变量：
Member functions
构造函数
string(const char* str="")
:_size(strlen(str))
, _capacity(_size)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}
注：构造函数传参必须是const char*类型的，字符串是存放在代码段中的常量区的是不可修改的，因此如果想修改其中string类的对象时，需要将在堆上开辟一段空间用来存放字符串，这样可以实现string类的增、删、查、改
析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
注：在堆上开辟的空间，记得一定要释放，否则会出现内存泄漏
拷贝构造（深拷贝）
//深拷贝的现代写法
string(const string& s)
:_str(nullptr)
{
string tmp(s._str);
swap(tmp);
}
//深拷贝的传统写法
string(const string& s)
:_size(s._size)
,_capacity(s._capacity)
, _str (new char[s._capacity + 1])
{
//_str = new char[strlen(s._str)+1];
strcpy(_str, s._str);
}
注：
string类的拷贝构造是深拷贝
深拷贝：拷贝对象，新开一块空间跟原来对象一样大的空间，再把原来对象空间上的值拷贝过来
浅拷贝：指向同一块空间，析构两次，其中一个修改另外一个也会受影响
深拷贝的传统写法：首先在初始化列表中开辟出和s一样大小的空间，其次再将s中的内容拷贝到新创建的对象中
深拷贝的现代写法：首先创建一个string类的临时对象tmp并将s的内容拷贝到tmp中，然后将tmp和新创建的对象进行交换，最后tmp会自动调用析构函数
赋值重载（深赋值）
//赋值重载的现代写法
string& operator=(string s)
{
swap(s);
return *this;
}
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s._str);
swap(tmp);
}
return *this;
}
//赋值重载的传统写法
string& operator=(string s)
{
if (this != &s)
{
char* tmp = new char[strlen(s._str) + 1];
delete[] _str;
_str = tmp;
strcpy(_str, s._str);
}
return *this;
}
注：
赋值重载的传统写法：首先开辟一段能写下s._str的空间，然后将本身的空间是释放，再将tmp拷贝给本身，最后将s的内容拷贝给自己（注意先开辟空间在释放原来的，否则，开辟空间失败后还是释放了原来的空间_str）
赋值重载的现代写法：将赋值的对象拷贝（深拷贝）给s对象，然后将自己与s交换，最后释放s
Capacity
size
size_t size()const
{
return _size;
}
size 返回字符串有效字符长度
capacity
size_t capacity()const
{
return _capacity;
}
capacity 返回当前为字符串分配的存储空间的大小，以字节表示。
reserve
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n+1];
strcpy(tmp, _str);
::swap(_str, tmp);
_capacity = n;
delete[] tmp;
}
}
reserve为字符串预留空间
reserve(size_t n=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
resize
void resize(size_t n, char ch='\0')
{
if (n <= _size)
{
_size = n;
_str[_size] = '\0';
}
else
{
if (n > _capacity)
{
reserve(n);
}
for (size_t i = _size;i < n;i++)
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0';
}
}
resize将有效字符的个数该成n个，多出的空间用字符ch填充
resize(size_t n, char ch=’\0’)是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用’\0’来填充多出的元素空间，resize(size_t n, char ch=’\0’)用字符ch来填充多出的元素空间。
注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
clear
void clear()
{
_str[0] = '\0';
_size = 0;
}
clear 清空有效字符
Modifiers
push_back
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : (_capacity * 2);
reserve(newcapacity);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
push_back 在字符串后尾插字符ch
append
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);//扩容
}
strcpy(_str + _size, str);
_size += len;
}
append 在字符串后追加一个字符串
insert
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
int len = strlen(str);
if (len == 0)
return *this;
if (len + _size > _capacity)
reserve(len + _size);
int end = len+_size;
while (end >= pos+len)
{
_str[end] = _str[end-len];
end--;
}
for (size_t i = 0;i < strlen(str);i++)
{
_str[pos + i]= str[i];
}
_size += len;
return *this;
}
insert函数用于插入字符串时，首先也是判断pos的合法性，若不合法则无法进行操作，再判断当前对象能否容纳插入该字符串后的字符串，若不能则还需调用reserve函数进行扩容。插入字符串时，先将pos位置及其后面的字符统一向后挪动len位（len为待插入字符串的长度），给待插入的字符串留出位置，然后将其插入字符串即可。
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
size_t newcappacity = _capacity == 0 ? 4 : (_capacity * 2);
reserve(newcappacity);
}
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
end--;
}
_str[pos] = ch;
_size++;
return *this;
}
insert函数用于插入字符时，首先需要判断pos的合法性，若不合法则无法进行操作，紧接着还需判断当前对象能否容纳插入字符后的字符串，若不能则还需调用reserve函数进行扩容。插入字符的过程也是比较简单的，先将pos位置及其后面的字符统一向后挪动一位，给待插入的字符留出位置，然后将字符插入字符串即可。
operator+=
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
string& operator+=(const string& str)
{
*this += str._str;
return *this;
}
operator+= 在字符串后追加字符串str或者在字符串后追加字符ch
在string尾部追加字符时，s.push_back(ch) / s.append(1, ch) / s += 'ch’三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
swap
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
swap 交换字符串值
通过s的内容交换自身的内容，s是另一个字符串对象。 长度可能不同。在调用这个成员函数之后，这个对象的值就是调用之前s的值，s的值就是这个对象调用之前的值。
erase
string& erase(size_t pos=0, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len + pos >= _size)
{
_str[pos] = '\0';
_size = pos;
return *this;
}
strcpy(_str + pos, _str + pos + len);
_size -= len;
return *this;
}
erase函数的作用是删除字符串任意位置开始的n个字符。删除字符前也需要判断pos的合法性，进行删除操作的时候分两种情况：
1、pos位置及其之后的有效字符都需要被删除。
这时我们只需在pos位置放上’\0’，然后将对象的size更新即可。
2、pos位置及其之后的有效字符只需删除一部分。
这时我们可以用后方需要保留的有效字符覆盖前方需要删除的有效字符，此时不用在字符串后方加’\0’，因为在此之前字符串末尾就有’\0’了。
Element access
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];
}
operator[] 返回pos位置的字符，适用于const string类对象或 string类对象调用
Iterators
begin
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
const_iterator begin()const
{
return _str;
}
begin获取第一个字符的迭代器
end
typedef char* iterator;
typedef const char* const_iterator;
iterator end()
{
return _str + _size;
}
const_iterator end()const
{
return _str + _size;
}
end获取最后一个字符下一个位置的迭代器
String operations
c_str
const char* c_str()
{
return _str;
}
c_str 返回C格式字符串
c_str不管字符串的长度，遇到‘\0’就终止
find
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* sub, size_t pos = 0)
{
assert(pos < _size);
const char* p = strstr(_str, sub);
if (p == nullptr)
return npos;
else
return p - _str;
}
find函数：
正向查找第一个匹配的字符。
首先判断所给pos的合法性，然后通过遍历的方式从pos位置开始向后寻找目标字符，若找到，则返回其下标；若没有找到，则返回npos。（npos是string类的一个静态成员变量，其值为整型最大值）
正向查找第一个匹配的字符串。
首先也是先判断所给pos的合法性，然后我们可以通过调用strstr函数进行查找。strstr函数若是找到了目标字符串会返回字符串的起始位置，若是没有找到会返回一个空指针。若是找到了目标字符串，我们可以通过计算目标字符串的起始位置和对象sub字符串的起始位置的差值，进而得到目标字符串起始位置的下标。
Member constants
npos
static const size_t npos;//声明
const size_t string::npos = -1;//定义
npos size_t 的最大值（公共静态成员常量）
Non-member function overloads
operator+
string operator +(const string& s1, char ch)
{
string ret = s1;
ret += ch;
return ret;
}
string operator +(const string& s1, const char* str)
{
string ret = s1;
ret += str;
return ret;
}
operator+ 尽量少用，因为传值返回，导致深拷贝效率低
operator>>
istream& operator >>(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();//get()函数可以的到字符' '和'\n'
while (ch != '\n' && ch != ' ')
{
s += ch;
ch = in.get();
}
return in;
}
operator>> 输入运算符重载
operator<<
ostream& operator <<(ostream& out, const string& s)
{
for (size_t i = 0;i < s.size();i++)
{
cout << s[i];
}
return out;
}
operator<< 输出运算符重载
operator<< 不管字符数组中的内容是什么，_size是多少，就输出多少个有效字符
getline
istream& getline(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
while (ch != '\n' )
{
s += ch;
ch = in.get();
}
return in;
}
getline 获取一行字符串
relational operators
bool operator>(const string& s1, const string& s2)
{
size_t i1 = 0;
size_t i2 = 0;
while (i1 < s1.size() && i2 < s2.size())
{
if (s1[i1] > s2[i2])
return true;
else if (s1[i1] < s2[i2])
return false;
else
{
i1++;
i2++;
}
}
if (i1 == s1.size())
return false;
else
return true;
}
bool operator==(const string& s1, const string& s2)
{
size_t i1 = 0;
size_t i2 = 0;
while (i1 < s1.size() && i2 < s2.size())
{
if (s1[i1] > s2[i2])
return false;
else if (s1[i1] < s2[i2])
return false;
else
{
i1++;
i2++;
}
}
if (i1 == s1.size()&&i2==s2.size())
return true;
else
return false;
}
inline bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}
inline bool operator>=(const string& s1, const string& s2)
{
return s1 == s2 || s1 > s2;
}
inline bool operator<(const string& s1, const string& s2)
{
return !(s1>=s2);
}
inline bool operator<=(const string& s1, const string& s2)
{
return !(s1>s2);
}
relational operators 大小比较
写时拷贝
写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
注：
浅拷贝的问题（以两个对象公用一块空间为例）：
- 这块空间会在两个对象调用析构函数会被delete两次
- 一个对象修改时也会影响另外一个对象
写时拷贝（哪个对象去写数据，哪个对象在进行深拷贝）
写时拷贝的本质是如果拷贝对象了，没人去修改它，没有深拷贝，那么这个拷贝就提高了效率；否则跟string类的拷贝构造一样（只是写时拷贝多了一步浅拷贝）
注：
string类中的拷贝构造：在vs中用的是深拷贝；在Linux中用的是写时拷贝
string类中Linux与VS得区别
在VS中字符串长度小于16的都存在buf数组中，大于16的存放在_str指向的对空间中，VS这样做可以减少内存碎片，以时间换空间提高效率
VS中成员变量多出一个buf数组，而在Linux中只有_str指针