深入浅出C++ ——string类深度剖析
文章目录
- 前言
- 一、string类简介
-
- 1. 标准库中的string类
- 2. string类的特点
- 二、string类常用接口
-
- 1. string类的默认成员函数
- 2. string类的迭代器及访问遍历操作
- 3. string类的容量操作
- 4. string类的修改操作
- 5. string类的字符串操作
- 6. string类的非成员函数重载
- 三、string结构的说明
- 四、深浅拷贝
- 五、STL中string类模拟实现
前言
STL
STL是C++中的优秀作品，有了它的陪伴，许多底层的数据结构以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速开发。
STL(standard template libaray-标准模板库)是C++标准库的重要组成部分(标准库的子集）。它不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架，STL把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。目前STL的主流版本有：原始版本、PJ版本、RW版本、SGI版本。
STL的六大组件
1. 仿函数
2. 算法
3. 迭代器
4. 空间配置器
5. 容器
6. 配接器
一、string类简介
C语言中，字符串是以'\0'结尾的一些字符的集合。 为了操作方便，C标准库中提供了一些 str 系列的库函数，但是这些库函数与字符串是分离开的，使用时还要包含头文件string 类表示字符串序列。
//C
char ch[] = "hello";
//CPP
string s= "hello";
1. 标准库中的string类
- 字符串是表示字符序列的类
- 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
- string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型）。
- string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并char_traits和allocator作为basic_string的默认参数。
- 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
以上内容来自：www.cplusplus.com string类文档的介绍，在STL的学习中，推荐大家看这个文档，对每个类都有详细的介绍。
2. string类的特点
- string 是表示字符序列的字符串类。
- 该类的接口与常规容器的接口基本相同，添加了一些专门用来操作string对象的常规操作的接口。
- string在底层实际是basic_string模板类的别名。
typedef basic_string - 不能操作多字节或者变长字符的序列。
- 使用string类时，必须包含#include头文件以及using namespace std;
二、string类常用接口
1. string类的默认成员函数
| 函数名称 | 功能说明 |
|---|---|
| string( ) | 构造空的string类对象，即空字符串 |
| string(const char* s) | 用s指向的字符串来构造string类对象 |
| string(const string& s) | 拷贝构造函数，将一个新的string对象初始化为对象s |
| operator = (const string& str) | 赋值重载函数，为已经存在字符串分配一个新值替换其当前内容 |
string s1; //构造函数
string s2("hello bit"); //构造函数
string s3(s2); //拷贝构造函数
string s4 = "hello bit"; //构造+拷贝构造 被编译器优化变为直接构造
string s5(s4, 3, string::npos); //拷贝构造s4（从第三个字符到最后一个字符）
//string::npos是string类的静态成员
//-1在内存中补码全1，npos类型是size_t相当于unsigned int，是整形最大值
string str1, str2
str1 = "Test string: ";
str2 = 'x';
str2 = str1 ; //赋值重载函数
2. string类的迭代器及访问遍历操作
| 函数名称 | 功能说明 |
|---|---|
| begin+ end | begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器 |
| rbegin + rend | rbegin获取最后一个字符的迭代器 + rend获取第一个字符上一个位置的迭代器 |
| operator[ ] | 返回pos位置的字符的引用 |
| 范围for | C++11支持更简洁的范围for的新遍历方式 |
| back | 返回对字符串最后一个字符的引用 |
| front | 返回对字符串第一个字符的引用 |
string类的三种遍历方式
string s1;
string s2("hello world");
// 1、下标+[]
for (size_t i = 0; i < s2.size(); ++i)
{
// 底层是调用 s2.operator[](i)
cout << s2[i] << endl;
s2[i] = 'x';
cout << s2[i] << endl;
}
// 2、迭代器
string::iterator it = s2.begin();
while (it != s2.end()) //只能用!=
{
cout << *it << " "; //可读可写
it++;
}
// 反向迭代器
string s3("123456");
string::reverse_iterator rit = s3.rbegin();
while (rit != s3.rend())
{
cout << *rit << " "; //6 5 4 3 2 1
++rit;
}
// 3、范围for
for (auto& e : s3) //引用
{
e += 1;
}
for (auto e : s3)
{
cout << e << " ";
}
- 下标+[ ]和at()
下标+ [ ] 和 at( ) 的用法相同，但是 [ ] 越界断言报错，at 抛异常报错
- 迭代器遍历
- [begin(), end()) ; end() 返回的不是最后一个数据位置的迭代器，返回是最后一个位置下一个位置，一般是
'\0' - C++中凡是给迭代器一般都是给的[ ) 左闭右开的区间
- 迭代器是类似指针一样东西
- 当对象是const类型时，要使用 string::const_iterator迭代器可以保证权限不被放大
- 迭代器意义：像string、vector支持[ ]遍历，但是list、map等等容器不支持[ ]，只能用迭代器遍历，所以：迭代器是一种统一使用的方式
3.C++11 提供范围for遍历
范围for写起来简洁，依次取容器中的数据，自动赋值给e，自动判断结束。
3. string类的容量操作
| 函数名称 | 功能说明 |
|---|---|
| size | 返回字符串有效字符长度 |
| length | 返回字符串有效字符长度 |
| capacity | 返回空间总大小 |
| empty | 检测字符串释放为空串，为空返回true，否则返回false |
| clear | 清空有效字符 |
| reserve | 为字符串预留空间，改变capacity |
| resize | 将有效字符的个数改为n个，多出的空间用字符c填充，改变size |
- size()与length()方法底层实现原理完全相同('\0’不是有效字符，是标识字符），引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()
- clear()只是将string中有效字符清空，不改变底层空间大小
resize(size_t n)与resize(size_t n, char c)都是将字符串中有效字符个数改变到n个。不同的是当字符个数增多时，resize(n)用’\0’来填充多出的元素空间。resize在对象中插入n个字符，默认字符是’\0’,resize(size_t n, char c)用字符c来填充多出的元素空间。resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。reserve(size_type n = 0)为string预留空间，不改变有效元素个数，改变capacity。但是当reserve的参数小于string的底层空间总大小时，reserve不会改变容量大小。- 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
- reserve开空间，扩展capacity。resize 开空间+初始化，改变size，有可能扩展capacity,并且初始化空间。
string类容量操作案例
string s("hello world!");
cout << s.size() << endl; //12
cout << s.length() << endl; //12
cout << s.capacity() << endl; //15
cout << s << endl; //hello world!
// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
s.clear();
cout << s.size() << endl; //0
cout << s.capacity() << endl; //15
// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
// “aaaaaaaaaa”
s.resize(10, 'a');
cout << s.size() << endl; //10
cout << s.capacity() << endl; //15
// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
// "aaaaaaaaaa\0\0\0\0\0"
// 注意此时s中有效字符个数已经增加到15个
s.resize(15);
cout << s.size() << endl; //15
cout << s.capacity() << endl; //15
cout << s << endl; //aaaaaaaaaa
// 将s中有效字符个数缩小到5个
s.resize(5);
cout << s.size() << endl; //5
cout << s.capacity() << endl; //15
cout << s << endl; //aaaaa
4. string类的修改操作
| 函数名称 | 功能说明 |
|---|---|
| operator+= | 在字符串后追加字符/字符串 |
| append | 在字符串后追加一个字符串 |
| push_back | 在字符串后尾插字符c |
| insert | 在指定位置插入字符串的拷贝 |
| erase | 删除字符串的一部分 |
| swap | 用另一个字符串对象的内容交换容器的内容 |
-
在string尾部追加字符时，
s.push_back( c )/s.append(1, c)/s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。 -
尽量少用insert，因为底层实现是数组，头部或中间插入需要挪动数据。
-
string类有尾插没有头插。
-
优先使用string类中的swap函数，它是交换string类中的成员函数。
算法库中的swap涉及拷贝构造和赋值运算符重载，更为复杂一些。
string类修改操作案例
string s1;
s1.push_back('h');
s1.push_back('i');
s1.append("world");
string s2("!!!!");
//s1.append(s2);
// 实际中最喜欢用这个+=
s1 += s2;
s1.insert(3, "yyyy");
//s1.insert(300, "yyyy"); 位置不合法，报错
s1.erase(0, 1); //从第0个字符开始向后删除一个字符
s1.erase(3); //从第3个字符开始向后删除到结尾
string s2 = "123";
string s3 = "456";
s2.swap(s3);//string类的交换函数
cout << s2 << " " << s3 << endl;//456 123
swap(s2, s3);//算法库中的交换函数
cout << s2 << " " << s3 << endl;//123 456
5. string类的字符串操作
| 函数名称 | 功能说明 |
|---|---|
| c_str | 使用 c_str() 方法转换 string 类型到 char* 类型时，需要为char*添加 const 关键字 |
| find + npos | 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置 |
| rfind | 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置 |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回，默认截取到字符串结尾 |
string类字符串操作案例
string s1 = "hello";
cout << s1.c_str() << endl; // hello
size_t pos1 = s1.find("l");
cout << pos1 << endl; //2
size_t pos2 = s1.rfind("l");
cout << pos2 << endl; //3
cout << s1.substr(pos1) << endl; //llo
string s3("hello world");
cout << s3 << endl; // 实际上底层是调用 operator<<(cout, s3)
cout << s3.c_str() << endl; // 实际上底层是调用 operator<<(cout, const char*)
cout << s3 << endl; // 直到size才停止
cout << s3.c_str() << endl; // 遇到'\0'会停止
//获取文件名的后缀
string filename = "test.cpp";
size_t pos = filename.rfind('.');
if (pos != string::npos)
{
string suff = filename.substr(pos, filename.size() - pos);
cout << suff << endl;
}
6. string类的非成员函数重载
| 函数名称 | 功能说明 |
|---|---|
| operator+ | 尽量少用，因为传值返回，导致深拷贝效率低 |
| relational operators | 大小比较 |
| operator>> | 输入运算符重载 |
| operator<< | 输出运算符重载 |
| getline | 获取一行字符串 |
scanf和cin连续输入多个数的时候，使用空格或者换行间隔；getline遇到换行才中止，遇到空格不结束。
三、string结构的说明
vs下string的结构
- 当字符串长度小于16时，使用内部固定的字符数组来存放。
- 当字符串长度大于等于16时，从堆上开辟空间。
- 大多数情况下字符串的长度都小于16，string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
g++下string的结构
g++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，指向堆空间的指针，用来存储字符串。
写时拷贝(本质是延时拷贝，谁去写，谁做深拷贝，没人写就不需要深拷贝)是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数（避免了资源重复释放造成的错误）：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象是资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
四、深浅拷贝
浅拷贝：
- 也称位拷贝，编译器只是将对象中的值拷贝过来。
- 如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
深拷贝：
- 给每个对象独立分配资源，保证多个对象之间不会因共享资源而多次释放造成程序崩溃问题。
- 在STL源码中采用的是深拷贝，我们在看源码或者string类模拟实现的时候，要注意避免浅拷贝的情况。
string s1="hello，world";
string s2(s1);
五、STL中string类模拟实现
模拟实现参考自侯捷老师的《STL源码剖析》
namespace MyString
{
//管理字符串的数组，可以增删查改,字符串数组的结尾有'\0' 并且带有迭代器
class string
{
public:
//******************string类的默认成员函数*****************//
//***构造函数***//
//缺省不能给nullptr，避免无参默认构造解引用报错。
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
//***拷贝构造函数***//
void swap(string& tmp)
{
::swap(_str, tmp._str);
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);
}
string(const string& s) //用tmp构造s的空间，再交换
:_str(nullptr) //没有这一句，tmp析构的时候会崩掉，delete是可以delete空指针，会检查
, _size(0)
, _capacity(0)
{
string tmp(s._str); //先调构造函数
swap(tmp); //this->swap(tmp);
}
// 旧版写法
/*
string(const string& s)
:_str(new char[s._capacity+1])
, _size(s._size)
, _capacity(s._capacity)
{
strcpy(_str, s._str);
}*/
//***赋值运算符重载***//
string& operator=(string s) //注意传值传参，传值拷贝,深拷贝
{
swap(s); //this的内容交给了s，s析构自动释放
return *this;
}
/*旧版写法
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;
}*/
//***析构函数***//
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
//******************string类的迭代器及访问遍历操作*****************//
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
//const修饰this指针，代表const对象去调用，保证权限不被放大
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
//只读
//前面的const保证是只读的，后面的const代表const对象去调用
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
//可读可写
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
//******************string类的容量操作*****************//
//成员函数的const修饰的是*this，本质上保护成员变量在函数体内不会被改变
//相当于是this指向的对象成员被保护，不能修改，不修改成员变量的函数，都应该加const
//但是本身就是修改数据的接口，如：push_back/insert不能加const
//1、只读接口函数 +const
//2、只写函数接口 不+const
//3、可读可写接口 +const版本和 不+const版本，也就是说具体加不加const要看接口的功能性质。
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
bool empty()const
{
return 0 == _size;
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
// 开空间，扩展capacity
void reserve(size_t n)
{
if (n > _capacity) // 如果新容量大于旧容量，则开辟空间
{
char* tmp = new char[n + 1];
//有效字符中包含\0，不能用strcpy，因为strcpy遇到\0会停止
strncpy(tmp, _str, _size);
// 释放原来旧空间,然后使用新空间
delete[] _str;
_str = tmp;
_capacity = n;
}
}
// 开空间+初始化，扩展capacity,并且初始化空间。size也要动
void resize(size_t n, char ch = '\0')
{
if (n > _size)// 如果n大于底层空间大小，则需要重新开辟空间
{
reserve(n);
for (size_t i = _size; i < n; ++i)
{
_str[i] = ch;
}
_str[n] = '\0';
_size = n;
}
else
{
_str[n] = '\0';
_size = n;
}
}
//******************string类的修改操作*****************//
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)//满了就扩容
{
reserve(_size + len);
}
strcpy(_str + _size, str);//strcat(_str, str); 需要找\0，效率低
_size += len;
//insert(_size, str);
}
void append(const string& s)
{
append(s._str);
}
void append(size_t n, char ch)
{
reserve(_size + n);
for (size_t i = 0; i < n; ++i)
{
push_back(ch);
}
}
void push_back(char ch)
{
// 满了就扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
//insert(_size, ch);
}
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)// 满了就扩容
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
size_t end = _size + 1;
while (end > pos) // 挪动数据，考虑pos为0
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = ch;
++_size;
return *this;
}
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
char* end = _str + _size;
while (end >= _str + pos)
{
*(end + len) = *end;
--end;
}
strncpy(_str + pos, str, len);//避免把\0拷贝进来
_size += len;
return *this;
}
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;
}
}
const char* c_str() const
{
return _str;
}
size_t find(char ch, size_t pos = 0) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; ++i)
{
if (ch == _str[i])
{
return i;
}
}
return npos;
}
size_t find(const char* str, size_t pos = 0) const
{
assert(str);
assert(pos < _size);
const char* ptr = strstr(_str + pos, str);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
string substr(size_t pos, size_t len = npos) const
{
assert(pos < _size);
size_t realLen = len;
if (len == npos || pos + len > _size)
{
realLen = _size - pos;
}
string sub;
for (size_t i = 0; i < realLen; ++i)
{
sub += _str[pos + i];
}
return sub;
}
private:
char* _str;
size_t _capacity;
size_t _size;
public:
// const static 语法特殊处理 直接可以当成定义初始化
const static size_t npos = -1;
};
//******************string类的非成员函数重载*****************//
bool operator<(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator<=(const string& s1, const string& s2)
{
return (s1 < s2 || s1 == s2);
}
bool operator>(const string& s1, const string& s2)
{
return !(s1 <= s2);
}
bool operator>=(const string& s1, const string& s2)
{
return !(s1 < s2);
}
bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}
ostream& operator<<(ostream& out, const string& s)
{
for (auto ch : s)
{
out << ch;
}
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();//如果s再定义的时候是有初始化的，要清空
char ch;
ch = in.get();//in>>ch ；不能这么获取，否则遇到空格或者换行就停止
const size_t N = 32;
char buff[N];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
buff[i] = '\0';
s += buff;
return in;
}
istream& getline(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
in >> ch;
}
return in;
}
}