热门标签
热门文章
- 1MySQL中的分组查询、子查询（嵌套查询）_分组子查询
- 2Java高并发编程详解系列-线程上下文设计模式及ThreadLocal详解_threadlocal与上下文传值区别
- 3java 字符串数组查询,Java的：查找数组列表字符串
- 4一款VS Code 和 JetBrains 的AI编码插件_continue插件
- 5Gitee上传文件_gitee做接口
- 6基于FPGA的以太网设计（3）----详解各类xMII接口_xmi数字接口
- 7LeetCode 23.合并k个升序链表
- 8Java - IDEA在debug时怎么复制JSONObject或JSONArray的值_idea debug怎么复制对象
- 9flutter adb连接失败failed to connect to 127.0.0.1:21503_unable to connect to 127.0.0.1:21503:21503
- 10Qt QStackedWidget类详细分析
当前位置: article > 正文
【C++】C++中的String类详解及模拟实现示例
作者：一键难忘520 | 2024-08-03 20:52:48
赞
踩
【C++】C++中的String类详解及模拟实现示例
string类简介
string类简介在C++编程中，字符串是一种非常常见的数据类型，用于存储文本信息。C++标准库提供了string类来处理字符串，它提供了许多方法和功能，使得字符串操作更加方便和高效。
string类的基本用法
要使用C++中的string类，需要包含头文件。下面是一个简单的示例，演示了如何创建和操作string对象：
#include <iostream> #include <string> int main() { // 创建一个空的string对象 std::string str; // 初始化string对象 std::string greeting = "Hello, world!"; // 获取字符串长度 int len = greeting.length(); // 字符串拼接 std::string message = greeting + " Have a nice day!"; // 输出字符串 std::cout << message << std::endl; return 0; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
string类的常用方法
string类提供了丰富的方法来操作字符串，包括查找子串、比较字符串、截取子串等功能。下面是一些常用的方法示例：
std::string str = "This is a C++ string";
// 查找子串
size_t found = str.find("C++");
// 比较字符串
if (str.compare("Another string") == 0) {
std::cout << "Strings are equal" << std::endl;
}
// 截取子串
std::string sub = str.substr(8, 2); // 从索引8开始，截取2个字符
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
string类的优势
与C风格字符串相比，C++的string类具有许多优势。它自动管理内存，避免了内存泄漏和越界访问的问题；提供了丰富的方法和操作符重载，使得字符串操作更加方便和直观；而且在C++11标准中，string类还支持移动语义，进一步提高了性能。
总的来说，C++中的string类是一个强大而灵活的工具，用于处理字符串数据。无论是简单的字符串拼接，还是复杂的字符串处理，string类都能够满足需求并提供高效的解决方案。
string类的模拟实现
除了对string类的简单使用外，为了更好的了解string类的实现原理，我们可以试着实现string类的部分功能，以便我们可以更加深入了string的原理，以便可以更好的使用它。
存储结构
string本质上是一个char类型的顺序表，实现起来与顺序表相似，所以结构上也相似。
using namespace std; #include <iostream> #include <assert.h> // 将自定义字符串类封装在命名空间hd内 namespace hd { // 定义string类 class string { public: // 成员常量 const static size_t npos = -1; // 表示未找到的位置，它是无符号整型的最大值， //特殊用法，这个值给初始化列表，但是它又不走初始化列表 //const static double x = 1.1; 这种特使用法只支持整数，像浮点数这些类型并不支持 //这种特殊处理还有一个用法: //const static int N = 10; //int a[N]; private: // 私有数据成员 size_t _size = 0; // 字符串大小 size_t _capacity = 0; // 字符串容量 char* _str = nullptr; // 指向动态分配的数组 }; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
头文件string.h
// string.h #pragma once #define _CRT_SECURE_NO_WARNINGS 1 // 禁用安全警告，与Visual Studio相关 using namespace std; #include <iostream> #include <assert.h> // 将自定义字符串类封装在命名空间hd内 namespace hd { // 定义string类 class string { public: // 构造函数、复制构造函数、赋值运算符和析构函数 string(const char* str = ""); // 默认构造函数，可接受C风格字符串 string(const string& s); // 复制构造函数 string(const char* s, size_t n); // 从C风格字符串构造，并指定长度 string& operator= (string s); // 赋值运算符，使用拷贝交换技术 ~string(); // 析构函数，释放内存 // 迭代器相关 typedef char* iterator; // 迭代器类型定义 typedef const char* const_iterator; // 常量迭代器类型定义 iterator begin() const { return _str; } // 返回指向第一个字符的迭代器 iterator end() const { return _str + _size; } // 返回指向最后一个字符之后的迭代器 // 容量相关函数 size_t size() const { return _size; } // 返回字符串的大小 void resize(size_t n, char c = '\0'); // 改变字符串的大小，如果变大则填充c字符 void reserve(size_t n = 0); // 预留空间，避免频繁分配内存 void clear();// 清空字符串 size_t capacity() const { return _capacity; } // 返回字符串对象的容量 bool empty() const { return _size == 0; } // 判断字符串对象是否为空 // 元素访问 char& operator[] (size_t pos) { assert(pos <= _size); return _str[pos]; } // 下标运算符 const char& operator[] (size_t pos) const { assert(pos <= _size); return _str[pos]; } // 下标运算符常量版本 char& at(size_t pos) { assert(pos <= _size); return _str[pos]; } // 安全访问元素 const char& at(size_t pos) const { assert(pos <= _size); return _str[pos]; } // 安全访问元素常量版本 // 修改器 string& operator+= (const string& s) { return append(s); } // 重载+=运算符，用于追加字符串 string& operator+= (const char* str) { return append(str); } // 重载+=运算符，用于追加C风格字符串 string& operator+= (char c) { return append(1, c); } // 重载+=运算符，用于追加字符 string& append(const string& s); // 追加字符串 string& append(const char* str); // 追加C风格字符串 string& append(size_t n, char c); // 追加n个字符c string& append(const string& s, size_t subpos, size_t sublen); // 追加字符串的子串 void push_back(char c); // 在字符串末尾添加一个字符 string& insert(size_t pos, const string& str); // 在指定位置插入字符串 string& insert(size_t pos, const char* s); // 在指定位置插入C风格字符串 string& insert(size_t pos, size_t n, char c); // 在指定位置插入n个字符c string& erase(size_t pos = 0, size_t len = npos); // 删除从pos开始的len个字符 void swap(string& s); // 交换两个字符串的内容 void pop_back() { erase(_size-1, 1); } // 删除最后一个字符 // 字符串操作 const char* c_str() const { return _str; } // 返回C风格字符串 size_t copy(char* s, size_t len, size_t pos = 0); // 复制字符串到s size_t find(const string& str, size_t pos = 0) const; // 查找子字符串 size_t find(const char* s, size_t pos = 0) const; // 查找C风格子字符串 size_t find(char c, size_t pos = 0) const; // 查找字符 string substr(size_t pos = 0, size_t len = npos) const; // 返回子串 //+号运算符重载 friend string operator+(const string& lhs, const string& rhs); // 成员常量 const static size_t npos = -1; // 表示未找到的位置 private: // 私有数据成员 size_t _size = 0; // 字符串大小 size_t _capacity = 0; // 字符串容量 char* _str = nullptr; // 指向动态分配的数组 }; // 非成员函数重载 istream& operator>> (istream& is, string& str); // 输入运算符重载 ostream& operator<< (ostream& os, const string& str); // 输出运算符重载 istream& getline(istream& is, string& str, char delim); // 从输入流读取一行 istream& getline(istream& is, string& str); // 从输入流读取一行，直到换行符 } }; // 非成员函数重载 istream& operator>> (istream& is, string& str); // 输入运算符重载 ostream& operator<< (ostream& os, const string& str); // 输出运算符重载 istream& getline(istream& is, string& str, char delim); // 从输入流读取一行 istream& getline(istream& is, string& str); // 从输入流读取一行，直到换行符 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
源文件string.cpp
#include "string.h" namespace hd { // 构造函数：根据传入的C风格字符串构造字符串对象 string::string(const char* str) { _size = strlen(str); // 计算字符串长度 _capacity = _size; // 初始容量为字符串长度 _str = new char[_capacity + 1]; // 分配内存空间，+1是为了存放字符串结束符'\0' strcpy(_str, str); // 将传入的字符串拷贝到_str中 } // 拷贝构造函数：使用另一个字符串对象构造当前字符串对象 string::string(const string& s) { string tmp(s.c_str()); // 利用传入的字符串对象构造临时字符串对象 swap(tmp); // 交换当前字符串对象和临时字符串对象的成员变量值 } // 构造函数：根据传入的C风格字符串和长度构造字符串对象 string::string(const char* s, size_t n) { string tmp(s); // 利用传入的C风格字符串构造临时字符串对象 tmp[n] = '\0'; // 限制临时字符串对象的长度为n tmp._size = n; // 更新临时字符串对象的大小为n swap(tmp); // 交换当前字符串对象和临时字符串对象的成员变量值 } // 赋值运算符重载：将字符串对象s赋值给当前字符串对象 string& string::operator=(string s) { swap(s); // 交换当前字符串对象和s的成员变量值 return *this; // 返回当前字符串对象 } // 析构函数：释放字符串对象所占用的内存空间 string::~string() { delete[] _str; _str = nullptr; _size = 0; _capacity = 0; } // 修改字符串大小，使其包含n个字符，如果n小于当前大小，则截断字符串，如果n大于当前大小，则在末尾填充字符c void string::resize(size_t n, char c) { if (this->size() > n) { _str[n] = '\0'; // 截断字符串 _size = n; } else { reserve(n); // 扩容字符串，使其能够容纳n个字符 append(n - this->size(), c); // 在末尾填充字符c，直到达到长度n } } // 扩展字符串容量，以容纳至少n个字符 void string::reserve(size_t n) { if (n > _capacity) { char* tmp = new char[n + 1]; // 分配新的内存空间，+1是为了存放字符串结束符'\0' strcpy(tmp, _str); // 将原字符串拷贝到新的内存空间中 delete[] _str; // 释放原有内存空间 _str = tmp; // 更新字符串指针指向新的内存空间 _capacity = n; // 更新字符串容量 } } // 在字符串末尾追加另一个字符串对象 string& string::append(const string& s) { return append(s.c_str()); } // 在字符串末尾追加C风格字符串 string& string::append(const char* str) { size_t len = strlen(str); // 计算要追加的字符串长度 if (_size + len > _capacity) { // 如果追加后的长度大于当前容量，则扩容 reserve(_size + len); } strcpy(_str + _size, str); // 将要追加的字符串拷贝到当前字符串的末尾 _size += len; // 更新字符串大小 return *this; } // 在字符串末尾追加n个字符c string& string::append(size_t n, char c) { for (size_t i = 0; i < n; ++i) { this->push_back(c); } return *this; } // 在字符串末尾追加另一个字符串对象的子串，子串起始位置为subpos，长度为sublen string& string::append(const string& s, size_t subpos, size_t sublen) { size_t len = s.size(); // 获取字符串的大小 if (_size + len > _capacity) { // 如果追加后的长度大于当前容量，则扩容 reserve(_size + len); } const char* cp_str = s.c_str() + subpos; // 根据起始位置计算子串的指针 strncpy(_str + _size, cp_str, sublen); // 将子串拷贝到当前字符串的末尾 _size += sublen; // 更新字符串大小 _str[_size] = '\0'; // 添加字符串结束符 return *this; } // 在字符串末尾添加一个字符c void string::push_back(char c) { if (_size == _capacity) { // 如果字符串已满，则进行扩容 size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2; reserve(newcapacity); } _str[_size] = c; // 在末尾添加字符c ++_size; // 更新字符串大小 _str[_size] = '\0'; // 添加字符串结束符 } // 在字符串的指定位置插入另一个字符串对象 string& string::insert(size_t pos, const string& str) { assert(pos <= _size); // 确保插入位置在合法范围内 return this->insert(pos, str.c_str()); } // 在字符串的指定位置插入C风格字符串 string& string::insert(size_t pos, const char* s) { assert(pos <= _size); // 确保插入位置在合法范围内 size_t len = strlen(s); // 计算要插入的字符串长度 if (_size + len > _capacity) { // 如果插入后的长度大于当前容量，则扩容 reserve(_size + len); } memmove(_str + pos + len, _str + pos, _size - pos); // 将插入位置及之后的字符后移 memcpy(_str + pos, s, len); // 将要插入的字符串拷贝到指定位置 _size += len; // 更新字符串大小 _str[_size] = '\0'; // 添加字符串结束符 return *this; } // 在字符串的指定位置插入n个字符c string& string::insert(size_t pos, size_t n, char c) { assert(pos <= _size); // 确保插入位置在合法范围内 string str; while (n--) { str += c; } return this->insert(pos, str); } // 删除字符串中从指定位置开始的指定长度的字符 string& string::erase(size_t pos, size_t len) { if (len == npos || pos + len >= _size) { // 如果要删除的长度超过了字符串的长度，则截断字符串 _str[pos] = '\0'; _size = pos; return *this; } else { strcpy(_str + pos, _str + pos + len); // 将要删除的部分后面的字符前移 _size -= len; // 更新字符串大小 } return *this; } // 交换两个字符串对象的成员变量值 void string::swap(string& s) { std::swap(_str, s._str); std::swap(_size, s._size); std::swap(_capacity, s._capacity); } // 将指定长度的字符从字符串中复制到字符数组s中，返回实际复制的字符数 size_t string::copy(char* s, size_t len, size_t pos) { assert(pos <= _size); // 确保复制位置在合法范围内 size_t actual_len = min(len, _size - pos); // 计算实际要复制的字符数 strncpy(s, _str + pos, actual_len); // 将要复制的字符拷贝到数组中 return actual_len; } // 查找字符串中指定子串的起始位置，从指定的位置pos开始查找 size_t string::find(const string& str, size_t pos) const { assert(pos <= _size); // 确保查找位置在合法范围内 return find(str.c_str(), pos); } // 查找字符串中指定C风格子串的起始位置，从指定的位置pos开始查找 size_t string::find(const char* s, size_t pos) const { assert(pos <= _size); // 确保查找位置在合法范围内 char* ptr = strstr(_str + pos, s); // 在字符串中查找子串 if (ptr == nullptr) { return npos; // 如果找不到子串，则返回特殊值 npos，表示找不到 } else { return ptr - _str; // 如果找到子串，则返回子串在字符串中的起始位置 } } // 返回字符串对象的子串，从指定位置pos开始，长度为len string string::substr(size_t pos, size_t len) const { assert(pos <= _size); // 确保起始位置在合法范围内 size_t actual_len = min(len, _size - pos); // 计算实际要复制的字符数 return string(_str + pos, actual_len); // 返回从起始位置pos开始，长度为actual_len的子串 } // 清空字符串对象，将大小和容量都重置为0 void string::clear() { delete[] _str; // 释放之前分配的内存空间 _str = new char[1]; // 分配新的内存空间，大小为1，用于存放字符串结束符'\0' _str[0] = '\0'; // 设置字符串结束符 _size = 0; // 更新字符串大小 _capacity = 0; // 更新字符串容量 } string operator+(const string& lhs, const string& rhs) { std::size_t newLen = lhs._size + rhs._size; // 计算拼接后字符串的长度 char* newData = new char[newLen + 1]; // 分配足够的内存来存储新的字符串，+1 用于存储字符串末尾的 '\0' strcpy(newData, lhs._str); // 将左操作数字符串复制到新字符串的开头位置 strcpy(newData + lhs._size, rhs._str); // 将右操作数字符串复制到新字符串的左操作数字符串之后 return string(newData); // 返回一个包含新字符串的 string 对象 } istream& operator>> (istream& is, string& str) { return getline(is, str, ' '); // 使用 getline 函数从 istream 中读取字符串，以空格作为分隔符 } ostream& operator<< (ostream& os, const string& str) { for (auto& ch : str) { os << ch; // 逐个字符地写入 ostream } return os; } istream& getline(istream& is, string& str, char delim) { str.clear(); // 清空待填充的字符串 char buffer[128]; // 临时缓冲区，为了减少扩容次数，用于存储每次从 istream 中读取的字符 char ch = is.get(); // 从 istream 中获取一个字符 //in >> ch; //会导致一直连续输入无法结束 //遇到空格或者换行时会被忽略掉，用get可以收到空格和换行的内容 int i = 0; // 缓冲区索引 while (ch != '\n' && ch != delim) // 依次读取字符，直到遇到换行符或指定分隔符 { buffer[i++] = ch; if (i == 127) { // 当临时缓冲区满时，将缓冲区的内容添加到字符串中 buffer[i] = '\0'; // 将缓冲区末尾添加 '\0'，形成 C 风格字符串 str += buffer; // 将缓冲区的内容追加到字符串中 i = 0; // 重置缓冲区索引 } ch = is.get(); // 继续从 istream 中获取下一个字符 } if (i > 0) // 如果缓冲区中还有剩余的字符，则将它们添加到字符串中 { buffer[i] = '\0'; str += buffer; i = 0; } return is; // 返回 istream 对象的引用，以支持链式操作 } istream& getline(istream& is, string& str) { str.clear(); // 清空待填充的字符串 char buffer[128]; // 临时缓冲区,为了减少扩容次数，用于存储每次从 istream 中读取的字符 char ch = is.get(); // 从 istream 中获取一个字符 //in >> ch; //会导致一直连续输入无法结束 //遇到空格或者换行时会被忽略掉，用get可以收到空格和换行的内容 int i = 0; // 缓冲区索引 while (ch != '\n') // 依次读取字符，直到遇到换行符 { buffer[i++] = ch; if (i == 127) { // 当临时缓冲区满时，将缓冲区的内容添加到字符串中 buffer[i] = '\0'; // 将缓冲区末尾添加 '\0'，形成 C 风格字符串 str += buffer; // 将缓冲区的内容追加到字符串中 i = 0; // 重置缓冲区索引 } ch = is.get(); // 继续从 istream 中获取下一个字符 } if (i > 0) // 如果缓冲区中还有剩余的字符，则将它们添加到字符串中 { buffer[i] = '\0'; str += buffer; i = 0; } return is; // 返回 istream 对象的引用，以支持链式操作 } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
- 280
- 281
- 282
- 283
- 284
- 285
- 286
- 287
- 288
- 289
- 290
- 291
- 292
- 293
- 294
- 295
- 296
- 297
- 298
- 299
- 300
- 301
- 302
- 303
- 304
源文件test.cpp
//test.cpp #include "string.h" int main() { hd::string s1; // 默认构造函数 cout << "s1: " << s1 << endl; hd::string s2("Hello"); // 构造函数，接受C风格字符串 cout << "s2: " << s2 << endl; hd::string s3(s2); // 复制构造函数 cout << "s3: " << s3 << endl; hd::string s4("World", 3); // 构造函数，接受C风格字符串和长度 cout << "s4: " << s4 << endl; // 迭代器测试 cout << "s2: "; for (auto it = s2.begin(); it != s2.end(); ++it) { cout << *it; } cout << endl; // 容量相关函数测试 cout << "s2 size: " << s2.size() << endl; cout << "s2 capacity: " << s2.capacity() << endl; s2.resize(10, 'a'); cout << "s2 after resize: " << s2 << endl; cout << "s2 capacity after resize: " << s2.capacity() << endl; s2.reserve(20); cout << "s2 capacity after reserve: " << s2.capacity() << endl; s2.clear(); cout << "s2 size after clear: " << s2.size() << endl; cout << "s2 capacity after clear: " << s2.capacity() << endl; cout << "s2 is empty: " << (s2.empty() ? "true" : "false") << endl; // 元素访问测试 cout << "s3[0]: " << s3[0] << endl; cout << "s3.at(1): " << s3.at(1) << endl; // 修改器测试 s3 += " World"; // 追加字符串 cout << "s3 after append: " << s3 << endl; s3.insert(5, " C++"); // 在指定位置插入字符串 cout << "s3 after insert: " << s3 << endl; s3.erase(5, 4); // 删除指定位置的字符 cout << "s3 after erase: " << s3 << endl; s3.pop_back(); // 删除最后一个字符 cout << "s3 after pop_back: " << s3 << endl; // 字符串操作测试 const char* cStr = s3.c_str(); cout << "C-style string: " << cStr << endl; char buffer[10]; size_t copiedLen = s3.copy(buffer, 5, 0); // 复制字符串到buffer buffer[copiedLen] = '\0'; cout << "Copied string: " << buffer << endl; s3 += "World !"; size_t pos = s3.find("World"); // 查找子字符串 if (pos != hd::string::npos) { cout << "Position of 'World': " << pos << endl; } else { cout << "Position of 'World': " << -1 << endl; } hd::string subStr = s3.substr(6, 3); // 返回子串 cout << "Substring: " << subStr << endl; return 0; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
分别测试库中，和自己实现得出的结果：
这里的resize与reserve的不同，是因为在实现过程中的扩容策略的不同造成的。
通过全面介绍了C++中string类的基本用法、常用方法和优势，以及string类的模拟实现示例。通过详细的讲解和示例代码，可以深入了解如何在C++中使用string类进行字符串操作，并了解其相对于C风格字符串的优势所在。同时，通过展示一个简单的string类的模拟实现，还可以加深对string类内部原理的理解。
声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签
