跳到主要内容C++ STL:从零手写 String 类及高频易错点复盘 | 极客日志C++算法
C++ STL:从零手写 String 类及高频易错点复盘
C++ STL string 类模拟实现涉及内存管理、构造析构、常用接口及运算符重载。核心在于掌握深拷贝机制避免野指针,理解 reserve 扩容策略防止频繁分配,利用拷贝交换法优化赋值运算符安全性。此外还包含流输入输出及查找截取功能的底层逻辑分析,适合希望深入理解标准库原理的开发者参考。
城市逃兵1 浏览 C++ STL 模拟实现:String 类详解
一、整体结构
在模拟 std::string 时,核心成员变量通常包含以下三个部分:
class string {
public:
private:
char* _str;
int _size;
int _capacity;
};
_str 指针:动态分配的内存块,存放以 \0 结尾的字符序列。需要自行管理内存的分配、扩容和释放。
_size 成员:记录字符串中有效字符的数量。
_capacity 成员:记录当前容量。当 _size 即将超过 _capacity 时触发扩容,通常按倍数增长以减少频繁分配带来的性能损耗。
二、构造与析构函数
2.1 默认构造
编写构造函数时,_str 不能初始化为 nullptr。必须开辟至少 1 字节的空间并初始化为 \0,否则打印时会因缺少结束符导致乱码。
string() {
_str = new char[1]{\0};
_size = _capacity = 0;
}
这里开辟的 1 字节用于存储 \0,不计入总空间大小,方便后续管理。
2.2 拷贝构造
string(const string& ch) {
_str = new char[ch._capacity + 1];
strcpy(_str, ch._str);
_size = ch._size;
_capacity = ch._capacity;
}
注意:C++ 语法禁止拷贝构造传值传参,否则会导致无限递归调用自身引发栈溢出。参数必须采用常量引用(const string&)或普通引用。
2.3 析构函数
~string() {
delete[] _str;
_str = ;
_size = _capacity = ;
}
nullptr
0
三、功能接口实现
3.1 reserve
reserve 仅修改 _capacity,提前分配内存以避免后续频繁扩容。它不改变有效长度 _size,也不填充额外字符。
- 只负责扩容,若传入参数小于当前
_capacity 则不操作。
- 预留空间包含末尾
\0 的位置。
void reserve(int n) {
if (n > _capacity) {
char* temp = new char[n+1];
strcpy(temp, _str);
delete[] _str;
_str = temp;
_capacity = n;
}
}
坑点提示:切勿在构造函数中调用 reserve。此时成员变量尚未初始化,直接访问可能导致非法访问或逻辑错误。
3.2 c_str
返回指向内部以 \0 结尾的 C 风格字符串的常量指针,用于兼容 C 语言接口。
- 返回
const char*,不可通过该指针修改内容。
- 指针依赖对象生命周期,对象修改或销毁后指针失效。
const char* c_str() const { return _str; }
3.3 PushBack
void PushBack(const char ch) {
if (_size == _capacity) {
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
_str[_size++] = ch;
_str[_size] = 0;
}
注意判断 _capacity 是否为 0,避免新空间大小一直为 0。
3.4 Append
在末尾追加字符串。追加前检查 _size + 追加长度 > _capacity,满足则触发扩容。
void Append(const char* str) {
int len = strlen(str);
if (_size + len > _capacity) {
reserve(_size + len > 2*_capacity ? _size + len : 2 * _capacity);
}
strcpy(_str+_size, str);
_size += len;
}
扩容策略上,如果追加长度过大,直接按所需长度扩容;否则按 2 倍扩容,平衡性能与内存。
3.5 Insert
在指定位置插入字符或字符串。插入会导致后续字符后移,时间复杂度较高。
void Insert(int pos, const char ch) {
assert(pos <= _size && pos >= 0);
if (_size == _capacity) {
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
int cur = _size;
while (cur >= pos) {
_str[cur + 1] = _str[cur];
cur--;
}
_str[pos] = ch;
_size++;
}
void Insert(int pos, const char* str) {
assert(pos <= _size && pos >= 0);
int len = strlen(str);
if (_size+len > _capacity) {
reserve(_size + len > 2*_capacity ? _size + len : 2 * _capacity);
}
int cur = _size;
while (cur >= pos) {
_str[cur + len] = _str[cur];
cur--;
}
strncpy(_str+pos, str, len);
_size += len;
}
插入字符串时使用 strncpy 而非 strcpy,防止将 \0 一并拷贝进去破坏原有结构。
3.6 erase
删除指定位置或范围的字符。这里实现从指定位置删除指定长度的字符。
void erase(size_t pos, size_t len) {
assert(pos >= 0 && pos < _size);
if (len >= _size - pos) {
_str[pos] = 0;
_size -= (_size - pos);
} else {
while (pos + len <= _size) {
_str[pos] = _str[pos + len];
pos++;
}
_size -= len;
}
}
3.7 substr
截取子串。关键点:返回值是对象,会调用拷贝构造。若未显式定义深拷贝,编译器生成的浅拷贝会导致同一内存被析构两次,引发崩溃。
string substr(size_t pos, size_t len) const {
assert(pos >= 0 && pos < _size);
if (len > _size - pos) {
len = _size - pos;
}
string temp;
for (int i = pos; i < pos + len; i++) {
temp += _str[i];
}
return temp;
}
务必确保拷贝构造实现了深拷贝,为新对象重新开辟内存。
3.8 Find
查找字符或子串首次出现的位置,失败返回 npos。
size_t find(char ch, size_t pos ) {
assert(pos < _size);
for (int i = pos; i < _size; i++) {
if (_str[i] == ch) {
return i;
}
}
return npos;
}
size_t find(const char* str, size_t pos) {
assert(pos < _size);
char* ret = strstr(_str+pos, str);
if (ret != nullptr) {
return ret - _str;
}
return npos;
}
使用 strstr 查找子串时,需计算指针差值转换为下标。
四、运算符重载
4.1 赋值运算符 (=)
推荐使用拷贝交换法(Copy-and-Swap),比传统写法更安全且简洁。
void Swap(string& str) {
std::swap(_str, str._str);
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
}
string& operator=(string str) {
Swap(str);
return *this;
}
传值参数自动触发拷贝构造生成临时对象,交换资源后临时对象析构完成清理。此方式天然支持自赋值,无需额外判断。
4.2 比较运算符
利用 strcmp 实现 < 和 ==,其余运算符复用基础实现。
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;
}
声明时不要放在类内,因为非成员函数的参数列表没有隐含的 this 指针。
4.3 += 运算符
void operator+=(const char* str) { Append(str); }
void operator+=(const char ch) { PushBack(ch); }
4.4 流输入输出 (<< >>)
输出较简单,遍历字符写入流。输入需注意缓冲区处理,读取到空格或换行停止。
std::ostream& operator<<(std::ostream& out, const string& s) {
for (auto ch : s) {
out << ch;
}
return out;
}
std::istream& operator>>(std::istream& in, string& s) {
s.clear();
const int N = 256;
char buff[N];
int i = 0;
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n') {
buff[i++] = ch;
if (i == N - 1) {
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i > 0) {
buff[i] = '\0';
s += buff;
}
return in;
}
五、完整代码汇总
#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include<string.h>
#include<assert.h>
#include<iostream>
class string {
public:
typedef char* iterator;
iterator begin() const { return _str; }
iterator end() const { return _str+_size; }
void clear() { _str[0] = 0; _size = 0; }
void reserve(int n) {
if (n > _capacity) {
char* temp = new char[n+1];
strcpy(temp, _str);
delete[] _str;
_str = temp;
_capacity = n;
}
}
string() { _str = new char[1]{\0}; _size = _capacity = 0; }
string(const char* str) {
int len = strlen(str);
_str = new char[len + 1];
strcpy(_str, str);
_size = _capacity = len;
}
string(const string& ch) {
_str = new char[ch._capacity + 1];
strcpy(_str, ch._str);
_size = ch._size;
_capacity = ch._capacity;
}
const char* c_str() const { return _str; }
void Swap(string& str) {
std::swap(_str, str._str);
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
}
string& operator=(string str) { Swap(str); return *this; }
void PushBack(const char ch);
void Append(const char* str);
void Insert(int pos, const char ch);
void Insert(int pos, const char* str);
void erase(size_t pos, size_t len);
string substr(size_t pos, size_t len) const;
size_t find(char ch, size_t pos = 0);
size_t find(const char* str, size_t pos = 0);
void operator+=(const char* str) { Append(str); }
void operator+=(const char ch) { PushBack(ch); }
char operator[](int pos) { assert(pos >= 0 && pos<_size); return _str[pos]; }
int size() { return _size; }
int capacity() { return _capacity; }
~string() { delete[] _str; _str = NULL; _size = _capacity = 0; }
private:
char* _str;
int _size;
int _capacity;
static const size_t npos;
};
bool operator<(const string& s1, const string& s2);
bool operator<=(const string& s1, const string& s2);
bool operator>(const string& s1, const string& s2);
bool operator>=(const string& s1, const string& s2);
bool operator==(const string& s1, const string& s2);
bool operator!=(const string& s1, const string& s2);
std::ostream& operator<<(std::ostream& out, const string& s);
std::istream& operator>>(std::istream& in, string& s);
#include"string.h"
const size_t string::npos = -1;
void string::PushBack(const char ch) {
if (_size == _capacity) {
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
_str[_size++] = ch;
_str[_size] = 0;
}
void string::Append(const char* str) {
int len = strlen(str);
if (_size + len > _capacity) {
reserve(_size + len > 2*_capacity ? _size + len : 2 * _capacity);
}
strcpy(_str+_size, str);
_size += len;
}
void string::Insert(int pos, const char ch) {
assert(pos <= _size && pos>=0);
if (_size == _capacity) {
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
int cur = _size;
while (cur >= pos) {
_str[cur + 1] = _str[cur];
cur--;
}
_str[pos] = ch;
_size++;
}
void string::Insert(int pos, const char* str) {
assert(pos <= _size && pos >= 0);
int len = strlen(str);
if (_size+len > _capacity) {
reserve(_size + len > 2*_capacity ? _size + len : 2 * _capacity);
}
int cur = _size;
while (cur >= pos) {
_str[cur + len] = _str[cur];
cur--;
}
strncpy(_str+pos, str, len);
_size+=len;
}
void string::erase(size_t pos, size_t len) {
assert(pos>=0&&pos<_size);
if (len >= _size - pos) {
_str[pos] = 0;
_size -= (_size - pos);
} else {
while (pos + len <= _size) {
_str[pos] = _str[pos + len];
pos++;
}
_size -= len;
}
}
string string::substr(size_t pos, size_t len) const {
assert(pos>=0&&pos<_size);
if (len > _size - pos) {
len = _size - pos;
}
string temp;
for (int i = pos; i < pos + len; i++) {
temp += _str[i];
}
return temp;
}
size_t string::find(char ch, size_t pos ) {
assert(pos<_size);
for (int i = pos; i < _size; i++) {
if (_str[i] == ch) {
return i;
}
}
return npos;
}
size_t string::find(const char* str, size_t pos) {
assert(pos < _size);
char* ret=strstr(_str+pos,str);
if (ret != nullptr) {
return ret - _str;
}
return npos;
}
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 strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator!=(const string& s1, const string& s2) {
return !(s1 == s2);
}
std::ostream& operator<<(std::ostream& out, const string& s) {
for (auto ch : s) {
out << ch;
}
return out;
}
std::istream& operator>>(std::istream& in, string& s) {
s.clear();
const int N = 256;
char buff[N];
int i = 0;
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n') {
buff[i++] = ch;
if (i == N - 1) {
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i > 0) {
buff[i] = '\0';
s += buff;
}
return in;
}
相关免费在线工具
- 加密/解密文本
使用加密算法(如AES、TripleDES、Rabbit或RC4)加密和解密文本明文。 在线工具,加密/解密文本在线工具,online
- Gemini 图片去水印
基于开源反向 Alpha 混合算法去除 Gemini/Nano Banana 图片水印,支持批量处理与下载。 在线工具,Gemini 图片去水印在线工具,online
- Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具,Base64 字符串编码/解码在线工具,online
- Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具,Base64 文件转换器在线工具,online
- Markdown转HTML
将 Markdown(GFM)转为 HTML 片段,浏览器内 marked 解析;与 HTML转Markdown 互为补充。 在线工具,Markdown转HTML在线工具,online
- HTML转Markdown
将 HTML 片段转为 GitHub Flavored Markdown,支持标题、列表、链接、代码块与表格等;浏览器内处理,可链接预填。 在线工具,HTML转Markdown在线工具,online