string类的文档介绍
string类表示字符串：
string类用于表示字符序列。接口与标准字符容器类似：
- 标准的
string类提供了类似于标准字符容器的接口，但增加了专门用于操作单字节字符字符串的特性。
string类的实现：
string类是basic_string模板类的一个实例，使用char作为字符类型，默认使用char_traits和allocator。- 实际上，
string类是通过以下typedef声明实现的：typedef basic_string<char, char_traits<char>, allocator<char>> string;字节级操作：
string类独立于使用的编码来处理字节。如果用于多字节或变长字符（如 UTF-8）的序列，这个类的所有成员（如长度或大小）以及它的迭代器将仍然按照字节进行操作，而不是实际的编码字符。总结：
string是表示字符串的类。- 该类的接口与标准容器的接口类似，增加了一些专门用于操作字符串的特性。
string底层是basic_string模板类的别名：typedef basic_string<char, char_traits<char>, allocator<char>> string;- 它不能直接处理多字节或变长字符的序列，而是按字节操作。
在使用
string类时，需要包含头文件并使用std命名空间：
#include <string>
using namespace std;
成员类型
成员函数
常量成员 和 非成员函数重载
标准库中的string类
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) （重点） | 拷贝构造函数 |
使用构造示例：
#include <iostream>
#include <string> // 包含标准库中的 string 头文件
int main() {
using namespace std; // 引入 std 命名空间
// 1. 构造空的 string 对象
string emptyString;
cout << "Empty String: " << emptyString << endl;
// 2. 使用 C 字符串来构造 string 对象
const char* cString = "Hello, world!";
string strFromCString(cString);
cout << "String from C string: " << strFromCString << endl;
// 3. 构造包含重复字符的 string 对象
size_t n = 5;
char c = '*';
string repeatedString(n, c);
cout << "Repeated String: " << repeatedString << endl;
// 4. 拷贝构造函数
string originalString("Original string");
string copiedString(originalString);
cout << "Copied String: " << copiedString << endl;
return 0;
}
2.string类对象的容量操作
| 函数名称 | 功能说明 |
| size（重点） | 返回字符串有效字符长度 |
| length | 返回字符串有效字符长度 |
| capacity | 返回空间总大小 |
| empty （重点） | 检测字符串释放为空串，是返回true，否则返回false |
| clear （重点） | 清空有效字符 |
| reserve （重点） | 为字符串预留空间 |
| resize （重点） | 将有效字符的个数该成n个，多出的空间用字符c填充 |
注意：
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的底层空间总大小时，reserve不会改变容量大小。
#include <iostream>
#include <string>
using namespace std;
void Teststring() {
// 1. 构造空的 string 类对象 s1
string s1;
cout << "s1: " << s1 << ", size: " << s1.size() << endl;
// 2. 用 C 格式字符串构造 string 类对象 s2
string s2("hello bit");
cout << "s2: " << s2 << ", size: " << s2.size() << endl;
// 3. 拷贝构造 s3
string s3(s2);
cout << "s3: " << s3 << ", size: " << s3.size() << endl;
// 4. 使用 resize(size_t n) 方法
s1.resize(10);
cout << "s1 after resize(10): " << s1 << ", size: " << s1.size() << endl;
// 5. 使用 resize(size_t n, char c) 方法
s2.resize(10, '*');
cout << "s2 after resize(10, '*'): " << s2 << ", size: " << s2.size() << endl;
// 6. 使用 clear() 方法
s3.clear();
cout << "s3 after clear(): " << s3 << ", size: " << s3.size() << endl;
// 7. 使用 reserve(size_t res_arg) 方法
s1.reserve(20);
cout << "s1 after reserve(20): " << s1 << ", size: " << s1.size() << ", capacity: " << s1.capacity() << endl;
}
int main() {
Teststring();
return 0;
}
输出：
s1: , size: 0
s2: hello bit, size: 9
s3: hello bit, size: 9
s1 after resize(10): , size: 10
s2 after resize(10, '*'): hello bit*, size: 10
s3 after clear(): , size: 0
s1 after reserve(20): , size: 10, capacity: 313.string类对象的访问及遍历操作
| 函数名称 | 功能说明 |
| operator[] （重 点） | 返回pos位置的字符，const string类对象调用 |
| begin+ end | begin获取一个字符的迭代器 ； end获取最后一个字符下一个位置的迭 代器 |
| rbegin + rend | begin获取一个字符的迭代器 ； end获取最后一个字符下一个位置的迭 代器 |
| 范围for | C++11支持更简洁的范围for的新遍历方式 |
#include <iostream>
#include <string>
using namespace std;
int main() {
// 创建一个 string 对象
string str = "Hello, world!";
// 使用 operator[] 获取特定位置的字符
cout << "Character at position 1: " << str[1] << endl;
// 使用 const string 对象调用 begin() 和 end() 方法获取迭代器
auto it_begin = str.begin();
auto it_end = str.end();
// 输出范围内的字符
cout << "Characters using iterators:" << endl;
for (auto it = it_begin; it != it_end; ++it) {
cout << *it << " ";
}
cout << endl;
// 使用 rbegin() 和 rend() 方法获取反向迭代器
auto rit_begin = str.rbegin();
auto rit_end = str.rend();
// 输出范围内的字符（反向）
cout << "Characters using reverse iterators:" << endl;
for (auto rit = rit_begin; rit != rit_end; ++rit) {
cout << *rit << " ";
}
cout << endl;
// 使用范围 for 循环遍历字符串
cout << "Characters using range-based for loop:" << endl;
for (char c : str) {
cout << c << " ";
}
cout << endl;
return 0;
}
输出：
Character at position 1: e
Characters using iterators:
H e l l o , w o r l d !
Characters using reverse iterators:
! d l r o w , o l l e H
Characters using range-based for loop:
H e l l o , w o r l d !4.string类对象的修改操作
| 函数名称 | 功能说明 |
| push_back | 在字符串后尾插字符c |
| append | 在字符串后追加一个字符串 |
| operator+= (重点) | 在字符串后追加字符串str |
| c_str(重点) | 返回C格式字符串 |
| find + npos(重点) | 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置 |
| rfind | 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置 |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回 |
void Teststring1()
{
// 注意：string类对象支持直接用cin和cout进行输入和输出
string s("hello, World!!!");
cout << s.size() << endl;
cout << s.length() << endl;
cout << s.capacity() << endl;
cout << s << endl;
// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
s.clear();
cout << s.size() << endl;
cout << s.capacity() << endl;
// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
// “aaaaaaaaaa”
s.resize(10, 'a');
cout << s.size() << endl;
cout << s.capacity() << endl;
// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
// "aaaaaaaaaa\0\0\0\0\0"
// 注意此时s中有效字符个数已经增加到15个
s.resize(15);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
// 将s中有效字符个数缩小到5个
s.resize(5);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
}输出：
15
15
15
hello, World!!!
0
15
10
15
15
15
aaaaaaaaaa
5
15
aaaaa
void Teststring2()
{
string s;
// 测试reserve是否会改变string中有效元素个数
s.reserve(100);
cout << s.size() << endl;
cout << s.capacity() << endl;
// 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
s.reserve(50);
cout << s.size() << endl;
cout << s.capacity() << endl;
}
// 利用reserve提高插入数据的效率，避免增容带来的开销输出：
0
111
0
111void TestPushBack()
{
string s;
size_t sz = s.capacity();
cout << "making s grow:\n";
for (int i = 0; i < 100; ++i)
{
s.push_back('c');
if (sz != s.capacity())
{
sz = s.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}输出：
making s grow:
capacity changed: 31
capacity changed: 47
capacity changed: 70
capacity changed: 105// 构建vector时，如果提前已经知道string中大概要放多少个元素，可以提前将string中空间设置好
void TestPushBackReserve()
{
string s;
s.reserve(100);
size_t sz = s.capacity();
cout << "making s grow:\n";
for (int i = 0; i < 100; ++i)
{
s.push_back('c');
if (sz != s.capacity())
{
sz = s.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}输出:
making s grow:注意：
string的遍历方式：
begin() + end()for + []- 范围
for（C++11 之后支持）
string遍历时使用最多的还是for + 下标或者 范围for（C++11 之后支持）。
begin() + end()大多数使用在需要使用 STL 提供的算法操作string时，比如：采用reverse逆置string。
void Teststring3()
{
string s1("hello World");
const string s2("Hello World");
cout << s1 << " " << s2 << endl;
cout << s1[0] << " " << s2[0] << endl;
s1[0] = 'H';
cout << s1 << endl;
// s2[0] = 'h'; 代码编译失败，因为const类型对象不能修改
}输出：
hello World Hello World
h H
Hello Worldvoid Teststring4()
{
string s("hello World");
// 3种遍历方式：
// 需要注意的以下三种方式除了遍历string对象，还可以遍历是修改string中的字符，
// 另外以下三种方式对于string而言，第一种使用最多
// 1. for+operator[]
for (size_t i = 0; i < s.size(); ++i)
cout << s[i] << endl;
// 2.迭代器
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << endl;
++it;
}
// string::reverse_iterator rit = s.rbegin();
// C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型
auto rit = s.rbegin();
while (rit != s.rend())
cout << *rit << endl;
// 3.范围for
for (auto ch : s)
cout << ch << endl;
}输出：
h
e
l
l
o
W
o
r
l
d
h
e
l
l
o
W
o
r
l
d
d
l
r
o
W
o
l
l
e
h
h
e
l
l
o
W
o
r
l
d注意：
- 在向
string尾部追加字符时，s.push_back(c)、s.append(1, c)和s += 'c'三种实现方式差不多。一般情况下，string类的+=操作用得比较多，因为+=操作不仅可以连接单个字符，还可以连接字符串。- 在对
string进行操作时，如果能够大概预估需要存放多少字符，可以先通过reserve方法将空间预留好。
5.string类非成员函数
| 函数 | 功能说明 |
| operator+ | 尽量少用，因为传值返回，导致深拷贝效率低 |
| operator>> （重点） | 输入运算符重载 |
| operator<< （重点） | 输出运算符重载 |
| getline （重点） | 获取一行字符串 |
| relational operators （重点） | 大小比较 |
#include <iostream>
#include <string>
int main() {
// 演示 operator+
std::string str1 = "Hello, ";
std::string str2 = "world!";
// 尽量少用，因为传值返回，导致深拷贝效率低
std::string str3 = str1 + str2;
std::cout << "Concatenated string: " << str3 << std::endl;
// 输入运算符重载 operator>>
std::string input;
std::cout << "Enter a word: ";
std::cin >> input;
std::cout << "You entered: " << input << std::endl;
// 输出运算符重载 operator<<
std::string output = "This is a string.";
std::cout << "Output string: " << output << std::endl;
// 使用 getline 获取一行字符串
std::string line;
std::cout << "Enter a line of text: ";
std::getline(std::cin, line);
std::cout << "You entered: " << line << std::endl;
// 演示关系运算符 (relational operators)
std::string s1 = "apple";
std::string s2 = "banana";
if (s1 == s2)
std::cout << s1 << " is equal to " << s2 << std::endl;
else if (s1 < s2)
std::cout << s1 << " is less than " << s2 << std::endl;
else
std::cout << s1 << " is greater than " << s2 << std::endl;
return 0;
}输出：
Concatenated string: Hello, world!
Enter a word: GOOD!
You entered: GOOD!
Output string: This is a string.
Enter a line of text: You entered:
apple is less than banana6.vs和g++下string结构的说明
VS下string的结构
在32位平台下，Visual Studio (VS) 实现的
std::string的确有一个复杂的内部结构，设计用来优化字符串存储和操作的效率。内部结构
联合体（union）：
std::string使用一个联合体来存储字符串。联合体包括一个字符数组和一个指针。- 当字符串长度小于16时，字符数组用于存储字符串，避免了堆分配。
- 当字符串长度大于等于16时，指针指向堆上的存储空间。
固定字符数组：
- 内部固定字符数组的大小为16字节，这个数组在字符串长度小于16时直接存储字符。
长度和容量：
- 一个
size_t类型的字段用于保存字符串的长度。size_t在32位平台下占4个字节。- 另一个
size_t类型的字段用于保存字符串的容量，也就是从堆上分配的总空间大小。指针：
- 一个指针用于指向堆上的字符串存储空间，或者用于其他内部管理。
总大小计算
- 字符数组：16 字节
- 长度字段：4 字节
- 容量字段：4 字节
- 指针：4 字节
总大小为：16 + 4 + 4 + 4 = 28 字节
class string { public: // Public member functions... private: union _Bxty { char _Buf[16]; // 用于存储短字符串 char* _Ptr; // 用于存储长字符串的指针 char _Alias[16]; // 允许别名 } _Bx; size_t _Mysize; // 字符串的长度 size_t _Myres; // 容量或其他控制字段 };不同环境下可能有不同的实现，可能的额外指针，用于其他目的（例如引用计数、保留位等）
g++下string的结构
内部结构
class string { public: // Public member functions... private: struct _Rep_base { size_t _M_length; // 字符串的长度 size_t _M_capacity; // 容量 _Atomic_word _M_refcount;// 引用计数 }; _Rep_base* _M_data; // 指向堆空间的指针，用来存储字符串 // 其他可能的字段和对齐 };在vim上执行:
输出：
string类的模拟实现
String.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring> // 使用 strlen、strcpy、strchr、strstr 等函数
#include <assert.h>
using namespace std;
namespace bit
{
class string
{
public:
typedef char* iterator;
static const size_t npos = -1; // 表示 size_t 类型的最大值
public:
// 构造函数
string(const char* str = "")
{
_size = strlen(str); // 获取输入字符串的长度
_capacity = _size; // 将容量设置为与大小相等
_str = new char[_capacity + 1]; // 为字符串分配内存空间
strcpy(_str, str); // 将输入字符串复制到内部缓冲区
}
// 拷贝构造函数
string(const string& s)
: _str(nullptr)
, _size(0)
, _capacity(0)
{
// 使用输入字符串 s 的内容创建临时字符串
string tmp(s._str);
// 交换临时字符串与当前对象
this->swap(tmp);
}
// 赋值运算符
string& operator=(string s)
{
// 交换输入字符串的内容与当前对象的内容
this->swap(s);
return *this;
}
// 析构函数
~string()
{
if (_str)
{
delete[] _str; // 释放动态分配的内存
_str = nullptr;
}
}
// 迭代器函数
iterator begin()
{
return _str; // 返回指向字符串开头的指针
}
iterator end()
{
return _str + _size; // 返回指向字符串结尾的指针
}
// 修改函数
void push_back(char c)
{
if (_size == _capacity)
reserve(_capacity * 2); // 如果需要，增加容量
_str[_size++] = c; // 将字符添加到字符串末尾
_str[_size] = '\0'; // 添加字符串结束符
}
string& operator+=(char c)
{
push_back(c); // 将字符追加到字符串末尾
return *this;
}
// 追加函数
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity) {
reserve(_size + len);
}
strcat(_str, str); // 使用 strcat 函数将 str 追加到 _str 后面
_size += len;
}
// 重载 += 运算符
string& operator+=(const char* str)
{
append(str); // 调用 append 函数将 str 追加到当前字符串的末尾
return *this;
}
// 清空字符串
void clear()
{
_size = 0; // 将大小设为零
_str[_size] = '\0'; // 添加字符串结束符
}
// 交换两个字符串
void swap(string& s)
{
std::swap(_str, s._str); // 交换内部缓冲区
std::swap(_size, s._size); // 交换大小
std::swap(_capacity, s._capacity); // 交换容量
}
// 获取 C 风格字符串
const char* c_str() const
{
return _str; // 返回指向内部缓冲区的指针
}
//字符串有效长度
size_t size() const
{
return _size; // 返回字符串的大小
}
// 容量函数
size_t capacity() const
{
return _capacity; // 返回字符串的容量
}
bool empty() const
{
return 0 == _size; // 检查字符串是否为空
}
// 调整字符串大小
void resize(size_t newSize, char c)
{
if (newSize > _size)
{
// 如果新大小大于当前大小，需要添加字符以达到新大小
if (newSize > _capacity)
{
reserve(newSize); // 确保有足够的内存空间
}
// 将新增的字符设为指定的字符 c
memset(_str + _size, c, newSize - _size);
}
// 更新字符串的大小
_size = newSize;
_str[newSize] = '\0'; // 添加字符串结束符
}
// 为字符串保留内存空间
void reserve(size_t newCapacity)
{
// 如果新容量大于当前容量，则需要重新分配内存
if (newCapacity > _capacity)
{
char* newStr = new char[newCapacity + 1]; // 新的内存空间
strcpy(newStr, _str); // 复制旧字符串到新的内存空间
delete[] _str; // 释放旧的内存空间
_str = newStr; // 更新指针指向新的内存空间
_capacity = newCapacity; // 更新容量
}
}
// 访问函数
char& operator[](size_t index)
{
assert(index < _size); // 确保索引在范围内
return _str[index]; // 返回指定索引处字符的引用
}
//重载 [] 运算符
const char& operator[](size_t index) const
{
assert(index < _size); // 确保索引在范围内
return _str[index]; // 返回指定索引处字符的引用
}
// 比较运算符
bool operator<(const string& s) {
return strcmp(_str, s._str) < 0;
}
bool operator<=(const string& s) {
return strcmp(_str, s._str) <= 0;
}
bool operator>(const string& s) {
return strcmp(_str, s._str) > 0;
}
bool operator>=(const string& s) {
return strcmp(_str, s._str) >= 0;
}
bool operator==(const string& s) {
return strcmp(_str, s._str) == 0;
}
bool operator!=(const string& s) {
return strcmp(_str, s._str) != 0;
}
// 查找函数
size_t find(char c, size_t pos = 0) const {
char* p = strchr(_str + pos, c);
return p ? p - _str : npos;
}
size_t find(const char* s, size_t pos = 0) const {
char* p = strstr(_str + pos, s);
return p ? p - _str : npos;
}
// 插入函数
string& insert(size_t pos, char c) {
assert(pos <= _size);
if (_size == _capacity) {
reserve(_capacity * 2);
}
memmove(_str + pos + 1, _str + pos, _size - pos + 1);
_str[pos] = c;
++_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);
}
memmove(_str + pos + len, _str + pos, _size - pos + 1);
memcpy(_str + pos, str, len);
_size += len;
return *this;
}
// 删除函数
string& erase(size_t pos, size_t len) {
assert(pos < _size);
if (len == npos || pos + len > _size) {
len = _size - pos;
}
memmove(_str + pos, _str + pos + len, _size - pos - len + 1);
_size -= len;
return *this;
}
private:
// 为输入输出运算符设为友元
friend std::ostream& operator<<(std::ostream& _cout, const bit::string& s);
friend std::istream& operator>>(std::istream& _cin, bit::string& s);
private:
char* _str; // 指向内部缓冲区的指针
size_t _capacity; // 缓冲区的容量
size_t _size; // 字符串的当前大小
};
// 输出运算符
ostream& operator<<(ostream& _cout, const bit::string& s)
{
// 不能使用这个, 因为string的字符串内部可能会包含\0
// 直接cout时, 是将_str当成char*打印的，遇到内部的\0时后序内容就不打印了
//cout << s._str;
for (size_t i = 0; i < s.size(); ++i)
{
_cout << s[i];
}
return _cout;
}
// 输入运算符
std::istream& operator>>(std::istream& _cin, bit::string& s)
{
// 清空之前的字符串内容
s.clear();
// 读取输入流中的字符串并追加到目标字符串中
std::string input;
_cin >> input;
s.append(input.c_str());
return _cin;
}
}
///对自定义的string类进行测试
void TestBitstring()
{
bit::string s1("hello");
s1.push_back(' ');
s1.push_back('w');
s1 += 'o';
s1 += "rld";
cout << s1 << endl;
cout << s1.size() << endl;
cout << s1.capacity() << endl;
// 利用迭代器打印string中的元素
bit::string::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it;
++it;
}
cout << endl;
// 这里可以看到一个类只要支持的基本的iterator，就支持范围for
for (auto ch : s1)
cout << ch;
cout << endl;
}
test.cpp
///对自定义的string类进行测试
void TestBitstring()
{
bit::string s1("hello");
s1.push_back(' ');
s1.push_back('w');
s1 += 'o';
s1 += "rld";
cout << s1 << endl;
cout << s1.size() << endl;
cout << s1.capacity() << endl;
// 利用迭代器打印string中的元素
bit::string::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it;
++it;
}
cout << endl;
// 这里可以看到一个类只要支持的基本的iterator，就支持范围for
for (auto ch : s1)
cout << ch;
cout << endl;
}
输出：
123
12366666666
------------------------
hello world
11
11
hello world
hello world以上就是常见的接口函数及其应用的内容。
1712
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
