标准库中的string类
string类
template<class T>
class basic_string
{
private:
T* _str;
size_t _size;
size_t _capacity;
};
typedef basic_string<char> string;
- string是表示字符串的字符串类
- 此类的接口与常规容器的接口基本相同，另外再添加一些专门用来操作string的常规操作
- string在底层实际是：basic_string模板类的别名，typedef basic_string<char,char_traits,allocator>string
- 不能操作多字节或者变长字符的序列
使用string类时，需要包含头文件 #include和 using namespace std;
string类常用接口说明
string类对象的常见构造
| 函数名 | 功能 |
|---|---|
| string（） | 构造空的string类对象，即是空字符串 |
| string(const char*s) | 用C-string来构造string类对象 |
| string(size_t n,char c) | string类对象中包含n个字符c |
| string(const string& s) | 拷贝构造函数 |
void test()
{
//构造空的string类对象
string s1;
//用C字符串构造string类对象
string s2("hello crush");
//拷贝构造
string s3(s2);
}
string类对象的容量操作
| 函数名 | 功能 |
|---|---|
| size | 返回字符串有效字符长度（不包括’\0’) |
| length | 返回字符串有效字符长度 |
| capacity | 返回空间总大小 |
| empty | 检测字符串是否为空串，是返回true，否则返回false |
| clear | 清空有效字符 |
| reserve | 为字符串预留空间 |
| resize | 将有效字符的个数改为n个，多出的空间用字符填充 |
在学习容量操作前，先了解扩容的原理
void Testpushback()
{
string s;
size_t sz = s.capacity();
cout << "capacity changed:" << sz << "\n";
cout << s.size() << endl;
cout << "making s grow";
for (int i = 0; i < 1000; i++)
{
s.push_back('c');
if (sz != s.capacity())
{
sz = s.capacity();
cout << "capacity changed:" << sz << "\n";
}
}
}
void test()
{
Testpushback();
}
当容量不够时，string会自动进行扩容进行适配
区分size()和capacity()
size()计算的是字符串的有效长度；capacity()计算的是字符串的容量大小。两者在大小上是有所不同的
resize存在三种情况
- n<11 删除数据
- 11<n<15 插入数据
- 15<n 扩容+插入数据
void test()
{
string s1("hello crush");
//删除数据
s1.resize(5);
cout << s1.size() << endl;
cout << s1.capacity() << endl;
cout << s1 << endl << endl;
string s2("hello crush");
//插入数据
s2.resize(15, 'x');
cout << s2.size() << endl;
cout << s2.capacity() << endl;
cout << s2 << endl << endl;
string s3("hello crush");
//扩容+插入数据
s3.resize(20, 'x');
cout << s3.size() << endl;
cout << s3.capacity() << endl;
cout << s3 << endl << endl;
}
string类对象的访问及遍历操作
| 函数名 | 功能 |
|---|---|
| operator[] | 返回pos位置的字符，const string类对象调用 |
| begin + end | begin获取第一个字符的迭代器,end获取最后一个字符下一个位置的迭代器 |
| rbegin + rend | rbegin获取最后一个字符的迭代器,rend获取最后一个字符下一个位置的迭代器 |
| 范围for |
- 下标[]
void test()
{
string s1("1234");
//下标[]
for (size_t i = 0; i < s1.size(); i++)
{
s1[i]++;
}
cout << s1 << endl;
}
- 范围for
void test()
{
string s1("1234");
//范围for
for (auto& ch : s1)
{
ch--;
}
cout << s1 << endl;
}
注意这里的范围for需要使用引用，对s1本身进行修改
- 迭代器 行为上与指针一样
void test()
{
string s1("1234");
//迭代器
string::iterator it1 = s1.begin();
while (it1 != s1.end())
{
*it1 += 1;
it1++;
}
it1 = s1.begin();
while (it1 != s1.end())
{
cout << *it1 << " ";
it1++;
}
cout << endl;
}
string类对象的修改操作
| 函数名 | 功能 |
|---|---|
| push_back | 在字符串末尾插入字符c |
| append | 在字符串后追加一个字符串 |
| operator+= | 在字符串后追加字符串 |
| c_str | 返回C字符串 |
| find+npos | 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置 |
| rfind | 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置 |
| substr | 在字符串pos位置开始，截取n个字符，然后将其返回 |
在上面学习扩容原理以及介绍push_back这里不加赘述
append
功能简单来说就是在字符串后面追加字符或者字符串
实现如下
void test()
{
string s1("hello crush");
string s2("!!!");
//在字符串s1后面追加字符串s2
s1.append(s2);
cout << s1 << endl;
}
其实对于 append函数的使用很少，一般使用 operator+=，两者在功能上相似，并且后者相对简单且容易理解
替换上面的代码
void test()
{
string s1("hello crush");
string s2("!!!");
//在字符串s1后面追加字符串s2
s1 += s2;
cout << s1 << endl;
}
区分assign和replace
assign的功能是先将原有的字符串清空在进行替换；replace的功能是在原有字符串的基础上在某个位置计算一定的长度进行替换
实例如下
void test()
{
string s1("hello world hello world");
string s2("hello world hello world");
s1.assign("hello crush", 5);
cout << s1 << endl;
s2.replace(6, 5, "crush");
cout << s2 << endl;
}
find
功能简单来说就是，默认从第一个位置开始向后找某个字符，找到之后返回该字符所在的位置；若没有找到，则返回npos
示例如下
void test()
{
string s("hello crush hello crush");
cout << s << endl;
//将' '替换成20%
size_t pos = s.find(' ');
while (pos != string::npos)
{
s.replace(pos, 1, "20%");
pos = s.find(' ',pos+3);
}
cout << s << endl;
}
c_str
功能：将字符串转换成C格式字符串并返回
读取文件
void test()
{
string file("test.cpp");
//将string格式的字符串转换成C格式的字符串，以便进行读取
FILE* fout = fopen(file.c_str(), "r");
assert(fout);
char ch = fgetc(fout);
while (ch != EOF)
{
cout << ch;
ch = fgetc(fout);
}
fclose(fout);
}
string类非成员函数
| 函数名 | 功能 |
|---|---|
| operator+ | |
| operator>> | 输入运算符重载 |
| operator<< | 输出运算符重载 |
| getline | 获取一行字符串 |
| relational operators | 大小比较 |
string类的模拟实现
传统写法
namespace myj
{
class string
{
friend ostream& operator<<(ostream& out,string& s);
friend istream& operator>>(istream& in, string& s);
public:
typedef char* iterator;//迭代器
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
//构造函数
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
//s2(s1) 拷贝构造
string(const string& s)
{
_str = new char[s._capacity + 1];
_capacity = s._capacity;
_size = s._size;
strcpy(_str, s._str);
}
//s1=s3 赋值重载
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;
}
//转换成C格式字符串，便于自定义类型的输出
const char* c_str()
{
return _str;
}
//string的长度
size_t size()
{
return _size;
}
//string的容量
size_t capacity()
{
return _capacity;
}
//重载[]
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
//预留空间
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 ch = '\0')
{
if (n > _size)
{
//如果n>_capacity，将会进行扩容
reserve(n);
for (size_t i = _size; i < n; i++)
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0';
}
else
{
_str[n] = '\0';
_size = n;
}
}
//尾插
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';
}
//追加字符串
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;
}
//重载+=
string& operator+=(const char* str)
{
append(str);
return *this;
}
//字符插入
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
end--;
}
_str[pos] = ch;
_size++;
return *this;
}
//字符串插入
string& insert(size_t pos, const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
size_t end = _size + len;
while (end > pos + len - 1)
{
_str[end] = _str[end - len];
end--;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
//消除字符
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);
}
return *this;
}
//查找字符
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* str, size_t pos = 0)
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, str);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
//清楚string内容
void clear()
{
_size = 0;
_str[0] = '\0';
}
private:
char* _str;
size_t _size;
size_t _capacity;
const static size_t npos = -1;
};
//流提取
ostream& operator<<(ostream& out,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 buff[128] = { '\0' };
size_t i = 0;
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
if (i == 127)
{
s += buff;
i = 0;
}
buff[i++] = ch;
ch = in.get();
}
if (i > 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
}
现代写法
主要是对拷贝构造和赋值重载进行改进，并不是为了提高效率，而是方便理解
拷贝构造
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
//s1(s2)
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);
swap(tmp);
}
思路：
将s2进行初始化；
创建临时变量string tmp拷贝构造s1；
交换tmp和s1的内容；
区分两个函数
string成员函数
swap(s1,s2);
进行三次深拷贝，交换s1和s2整体
s1.swap(s2);
只改变s1和s2中指针指向的内容
赋值重载
这里便可以利用上面**s1.swap(s2);**的思想
//s1=s2
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);
swap(tmp);
}
return *this;
}
扫一扫
302
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
