目录
2.2.1 函数 size , length , capcacity , empty，clear 的使用
1. 标准库中的string类
string是C++标准库的一个重要的部分，主要用于字符串处理。可以使用输入输出流方式直接进行string操作，也可以通过文件等手段进行string操作。同时，C++的算法库对string类也有着很好的支持，并且string类还和c语言的字符串之间有着良好的接口。
- string是表示字符串的字符串类
- 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
- string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>string;
- 不能操作多字节或者变长字符的序列。
注意：在使用string类时，必须包含#include<string>头文件以及using namespace std;
2.string的常用接口
string的文档链接：<string> - C++ Reference (cplusplus.com)
2.1. string类对象的常见构造
| (constructor)函数名称 | 功能说明 |
| string() （重点） | 构造空的string类对象，即空字符串 |
| string(const char* s) （重点） | 用C-string来构造string类对象 |
| string(size_t n, char c) | string类对象中包含n个字符c |
| string(const string&s) （重点） | 拷贝构造函数 |
string的所以构造列：
2.2. string类对象的容量操作
| 函数名称 | 功能说明 |
| size（重点） | 返回字符串有效字符长度 |
| length | 返回字符串有效字符长度 |
| capacity | 返回空间总大小 |
| empty （重点） | 检测字符串是否为空串，是返回true，否则返回false |
| clear （重点） | 清空有效字符 |
| reserve （重点） | 为字符串预留空间** |
| resize （重点） | 将有效字符的个数改成n个，多出的空间用字符c填充 |
2.2.1函数 size , length , capcacity , empty，clear 的使用
2.2.2 reserve函数
将字符串容量调整为计划的大小变化，使其长度不超过 n 个字符。如果 n 大于当前的容量，则该函数会导致容器将其容量增加到 n 个字符（或更大）。
此函数对字符串长度没有影响，也无法更改其内容（只开空间）。且开的空间大小是根据编译器来决定如何扩容。
string中reserve按照:(i*16-1)的规律，i>=1，取 capicity = (i*16-1)>=N，并使得 capicity 离 N最近。
注意：reserve和reverse看着很像，但是用法完全不同，reverse是逆置字符串的函数
2.2.3 resize函数
将字符串的大小调整为 n 个字符长度。
如果 n 小于当前字符串长度，则当前值将缩短为其前 n 个字符，并删除超出n个之后的字符。
如果 n 大于当前字符串长度，则通过在末尾插入所需数量的字符以达到 n 的大小来扩展当前内容。如果指定了 c，则新元素将初始化为 c 的副本，否则，它们是值初始化字符（空字符）。
注意：
1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一
致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。
注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于
string的底层空间总大小时，reserver不会改变容量大小。
2.3. string类对象的访问及遍历操作
| 函数名称 | 功能说明 |
| operator[] （重 点） | 返回pos位置的字符 |
| begin+ end | begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器 |
| rbegin + rend | begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器 |
| 范围for | C++11支持更简洁的范围for的新遍历方式 |
2.3.1.迭代器
迭代器总共有四种：正向迭代器（iterator）、反向迭代器（reverse_iterator）、只读迭代器（const_iterator）、只读反向迭代器（const_reverse_iterator）；
当我们有针对const修饰的对象时，则必须使用只读迭代器const_iterator
正向迭代器
string s1("hello world");
//auto it = s1.begin(); 也能使用 auto
string::iterator it = s1.begin(); // 正向迭代器，正向遍历
// s1.begin() 指向的是字符串的起始字符 'h'
// s1.end() 指向的是字符串的末尾位置的后一位 '\0'
while (it != s1.end())
{
cout << *it << " "; // 这里不是指针，只是具有指针的功能， *it 就是它的内容
//*it++;这里写可以改变迭代器指向的位置内容，但是const迭代器不能这样写
++it;
}
cout << endl;
cout << *it << endl; //这里再次使用 *it 就会崩溃，
//因为迭代器在使用后就会被系统释放，不能再继续使用
反向迭代器
string s1("hello world");
//auto rit = s1.rbegin(); //也可用auto
string::reverse_iterator rit = s1.rbegin(); //反向迭代器，倒着遍历
while (rit != s1.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
2.3.2范围for
for(当前需要查找的遍历：需要遍历的容器)
常见范围 for 书写形式:
1.只读：for(const auto& 变量：需要遍历容器)
2.可读可写：for(auto& 变量：需要遍历的容器)
string s = "123456";
for (auto& ch : s)
{
//ch++;加上这行代码会使s变为 2 3 4 5 6 7
cout << ch << " ";//最终会打印出1 2 3 4 5 6
}
cout << endl;
string s1 = "123456";
for (const auto& ch : s1)
{
//ch++;加了const这行代码就不能使用
cout << ch << " ";//最终会打印出1 2 3 4 5 6
}
cout << endl;范围for的底层本质也是迭代器
2.4. string类对象的修改操作
| 函数名称 | 功能说明 |
| push_back | 在字符串后尾插字符c |
| append | 在字符串后追加一个字符串 |
| operator+= (重点) | 在字符串后追加字符串str |
| c_str(重点) | 返回C格式字符串， |
| find + npos(重点) | 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置,若不存在，返回npos |
| rfind | 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置,若不存在，返回npos |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回 |
2.4.1.append函数
注意：
1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般
情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好
2.4.2. c_str 函数
- c_str()函数返回一个指向正规C字符串的指针常量, 内容与本string串相同。生成一个const char*指针，指向以空字符终止的数组。
- 这是为了与c语言兼容，在c语言中没有string类型，故必须通过string类对象的成员函数c_str()把string 对象转换成c中的字符串样式。
- 注意：一定要使用strcpy()函数 等来操作方法c_str()返回的指针。
2.4.3. find() 函数
npos是一个常数，表示size_t的最大值（Maximum value for size_t）。许多容器都提供这个东西，用来表示不存在的位置.
注意：在使用npos用于string进行比较时，需要加上string::
2.4.4. substr函数
- 用途：一种构造string的方法
- 形式：s.substr(pos, n)
- 解释：返回一个string，包含s中从pos开始的n个字符的拷贝（pos的默认值是0，n的默认值是s.size() - pos，即不加参数会默认拷贝整个s）
- 补充：若pos的值超过了string的大小，则substr函数会抛出一个out_of_range异常；若pos+n的值超过了string的大小，则substr会调整n的值，只拷贝到string的末尾
2.4.5. insert函数
//在原串下标为pos的字符前插入字符串str
basic_string& insert (size_type pos, const basic_string& str);
//str从下标为pos1开始数的n个字符插在原串下标为pos的字符前
basic_string& insert (size_type pos, const basic_string& str, size_type pos1, size_type n);
//在原串下标为pos的字符前插入n个字符c
basic_string& insert (size_type pos, size_type n, char c);
2.4.6 erase 函数
basic_string & erase(size_type pos=0, size_type n=npos);
即从给定起始位置pos处开始删除, 要删除字符的长度为n, 返回值修改后的string对象引用
iterator erase(const_iterator position)
删除迭代器位置处的单个字符, 并返回下个元素的迭代器
iterator erase(const_iterator first, const_iterator last)
删除迭代器[first, last)区间的所有字符,返回一个指向被删除的最后一个元素的下一个字符的迭代器.
2.5.string类非成员函数
| 函数 | 功能说明 |
| operator+ | 尽量少用，因为传值返回，导致深拷贝效率低 |
| operator>> | 输入运算符重载 |
| operator<< | 输出运算符重载 |
| getline | 获取一行字符串 |
| relational operators | 大小比较（> , < , >= , <= , == 等） |
2.5.1 getline函数
c++中 string 虽然可以使用 cin 和 >> 运算符来输入字符串，但它可能会导致一些需要注意的问题。
当 cin 读取数据时，它会传递并忽略任何前导白色空格字符（空格、制表符或换行符）。一旦它接触到第一个非空格字符即开始阅读，当它读取到下一个空白字符时，它将停止读取。
为了解决这个问题，可以使用一个叫做 getline 的 C++ 函数。此函数可读取整行，包括前导和嵌入的空格，并将其存储在字符串对象中。
3.string的模拟实现
namespace LJ
{
class string
{
public:
//迭代器
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;
}
/*string(const char* str)
:_str(new char[strlen(str) +1 ])
,_size(0)
,_capacity(0)
{
strcpy(_str, str);
}
string()
:_str(new char[1])
, _size(0)
, _capacity(0)
{
_str[0] = '\0';
}*/
//或者
//string(const char* str= "\0")
/*string(const char* str= " ")
:_str(new char[strlen(str) + 1])
, _size(0)
, _capacity(0)
{
strcpy(_str, str);
}*/
//或者
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
~string()
{
delete[] _str;
_size = 0;
_capacity = 0;
}
//不能这样初始化空对象
/*string()
:_str(nullptr)
, _size(0)
, _capacity(0)
{}*/
//传统写法
//string(const string& s)
// :_str(new char[s._capacity + 1])
// , _size(s._size)
// , _capacity(s._capacity)
//{
// strcpy(_str, s.c_str());
//}
//
//string& operator=(const string s)
//{
// //先判断是不是s = s这种情况
// if (this != &s)
// {
// //防止new失败
// char* tmp = new char[s._capacity + 1];//new失败直接抛异常
// strcpy(tmp, s._str);
//
// delete[] _str;
// _str = tmp;
// _size = s._size;
// _capacity = s._capacity;
// }
// return *this;
//}
//现代写法
//s2(s1)
//深拷贝，如果不写，默认拷贝构造是按字节拷贝(浅拷贝)
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);
swap(_str, tmp._str);
swap(_size, tmp._size);
swap(_capacity, tmp._capacity);
}
//s1 = s3 不写默认也是按字节拷贝
//string& operator=(const string& s)
//{
// //先判断是不是s = s这种情况
// if (this != &s)
// {
// string tmp(s);
// swap(_str, tmp._str);
// swap(_size, tmp._size);
// swap(_capacity, tmp._capacity);
// }
// return *this;
//}
//s1 = s3 不写默认也是按字节拷贝
string& operator=( string s)
{
swap(_str, s._str);
swap(_size, s._size);
swap(_capacity, s._capacity);
return *this;
}
const char& operator[] (size_t pos)const
{
assert(pos < _size);
return _str[pos];
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char* c_str()const
{
return _str;
}
size_t size()const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp,_str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void resize(size_t n, char c = '\0')
{
if (n > _size)
{
//插入数据
reserve(n);
for (size_t i = _size; i < n; i++)
{
_str[i] = c;
}
_str[n] = '\0';
_size = n;
}
else
{
//删除数据
_str[n] = '\0';
_size = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';//最后要加上\0
}
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;
}
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity==0?4:_capacity*2);
}
size_t end = _size+1;//防止pos为0出现错误
while (end >= pos)
{
_str[end ] = _str[end - 1];
end--;
}
_str[pos] = ch;
++_size;
return *this;
}
string& insert(size_t pos,const char* ch)
{
assert(pos <= _size);
size_t len = strlen(ch);
if (_size + len > _capacity)
{
reserve(_size +len);
}
size_t end = _size + len ;
while (end >= pos + len)
{
_str[end] = _str[end - len];
end--;
}
strncpy(_str + pos, ch , len);
_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;
}
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
size_t find(char ch, size_t pos = 0)
{
assert(pos < _size);
while (pos < _size)
{
if (_str[pos] == ch)
{
return pos;
}
pos++;
}
return npos;
}
size_t find(const char* sub, size_t pos = 0)
{
assert(sub);
assert(pos < _size);
const char* ptr = strstr(_str + pos, sub);
if (ptr==nullptr)
{
return npos;
}
return ptr-_str;
}
string substr(size_t pos, size_t len = npos)const
{
assert(pos < _size);
string tmp;
size_t realen = len;
if (len == npos || pos + len > _size)
{
realen = _size - pos;
}
size_t i = 0;
while (i < realen)
{
tmp += _str[pos+i];
++i;
}
return tmp;
}
string& operator+=( char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
bool operator>(const string& s)const
{
//return strcmp(_str, s.c_str());
size_t loca = 0;
while (_str[loca] == s[loca])
{
if (s[loca] == '\0')
{
return false;
}
loca++;
}
if (_str[loca] > s[loca])
return true;
else
return false;
}
bool operator==(const string& s)const
{
//return strcmp(_str, s.c_str()) == 0;
if (_size != s.size())
{
return false;
}
else
{
size_t loca = 0;
while (_str[loca] == s[loca])
{
if (loca == _size - 1 )
//由于[]中assert(pos<_size)的限制，不能写成_str[loca] == '\0'
{
return true;
}
loca++;
}
return false;
}
}
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);
}
bool operator!=(const string& s)const
{
return !(*this == s);
}
private:
char* _str;
size_t _size;
size_t _capacity;
//const static 语法特殊处理
// 直接可以当成定义初始化
public:
const static size_t npos = -1;
//static size_t npos;
};
//size_t string::npos = -1;
ostream& operator<<(ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
out << s[i];
}
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
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;
}
}
668
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
