震惊！string 类底层代码全解析，看完你会怀疑自己以前学了假的 C++！

本文将深入解析C++标准库string类的底层实现原理，通过手动模拟实现string类来理解动态内存管理、类设计核心逻辑。文章从string类的基础结构出发，详细拆解构造、拷贝、扩容等功能的底层实现，重点解析浅拷贝与深拷贝等关键概念。内容包括构造函数与析构函数的实现细节、内存分配策略、拷贝构造函数的深拷贝实现方式，以及如何通过写时拷贝优化性能。通过本文，读者将能从"会用"进阶到

2301_78847073

1208人浏览 · 2025-07-28 18:23:22

2301_78847073 · 2025-07-28 18:23:22 发布

💻作者简介：曾与你一样迷茫，现以经验助你入门 C++。
💡个人主页：@笑口常开xpr 的个人主页
📚系列专栏：C++ 炼魂场：从青铜到王者的进阶之路

✨代码趣语：写时拷贝是 ‘平时借同桌的作业抄，要修改时才自己重新写’ - - - 没修改时省事儿，改的时候可得自己动手。
💪代码千行，始于坚持，每日敲码，进阶编程之路。
📦gitee 链接：gitee

在这里插入图片描述
C++ 标准库的 string 类虽好用，但多数人仅知其表。其实，手动模拟实现 string 类，是理解动态内存管理、类设计核心逻辑的最佳实践。本文从 string 类的基础结构出发，拆解构造、拷贝、扩容等功能的底层实现，解析浅拷贝、深拷贝等关键概念，帮你从 “会用” 到 “懂原理”。

string 的模拟实现

原因

标准库的 string 类虽然强大，但直接使用它时，我们往往只知其然不知其所以然。通过手动实现 string 类，我们可以理解动态内存管理的核心逻辑（内存分配、释放、扩容），掌握类的拷贝构造、赋值运算符重载等关键语法，清晰字符串操作（增删查改）的底层实现，学会处理边界情况和异常场景。

一个基础的 string 类需要管理三个核心成员：存储字符串的内存地址、当前字符串长度、当前已分配的容量。

namespace str 
{
    class string 
    {
    private:
        char* _str;       //存储字符串的内存地址
        size_t _size;     //当前字符串长度(有效字符数)
        size_t _capacity; //已分配的容量(可存储的最大字符数,不含终止符)
        const static size_t _npos; //表示"未找到"的特殊值
    };
}

_size 与 _capacity 分离
_size 记录字符串的实际字符数，_capacity 记录已分配内存能容纳的最大字符数，这样可以减少频繁扩容带来的性能损耗。

_npos 定义
作为静态常量，其值为 -1（因 size_t 是无符号类型，实际会表示为最大正整数），用于表示 “查找失败” 等场景。

构造函数与析构函数

字符串的创建和销毁是 string 类的基础功能，我们需要处理两种常见场景：常量字符串初始化、默认初始化。

构造函数

传统实现中，我们可能会分别定义默认构造和带参构造，但通过缺省参数可以合并为一个构造函数。

string(const char* str = "")//常量字符串后面默认有\0
	: _size(strlen(str))
	, _capacity(strlen(str))
	, _str(new char[strlen(str) + 1])//开辟空间
{
	//c语言到\0终止,C++到_size结束
	//strcpy(_str, str);//拷贝数据
	memcpy(_str, str, _size + 1);//拷贝数据
}

缺省参数用空字符串而不是 “\0”：常量字符串本身已包含终止符 ‘\0’，strlen(" ") 会返回 0，符合默认初始化需求。
内存分配需 +1：预留 ‘\0’ 的位置。
memcpy 替代 strcpy：若字符串中包含 ‘\0’，strcpy 会提前终止，而 memcpy 按指定长度拷贝更安全。

析构函数

析构函数需要释放动态分配的内存，避免内存泄漏。

~string() 
{
    if (_str) {  // 若指针有效
        delete[] _str;  // 释放数组内存
        _str = nullptr;  // 避免野指针
        _size = _capacity = 0;  // 重置状态
    }
}

拷贝

浅拷贝

浅拷贝也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进行操作时，就会发生发生了访问违规。

比如一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。
在这里插入图片描述

在这里插入图片描述

深拷贝

深拷贝是给每个对象独立分配资源，保证多个对象之间不会因共享资源而造成多次释放造成程序崩溃。

比如父母给每个孩子都买一份玩具，各自玩各自的就不会有问题了。
在这里插入图片描述

拷贝构造函数 - - - 深拷贝

string 类包含动态分配的内存，默认生成的拷贝构造和赋值运算符会导致 “浅拷贝” 问题（多个对象共享同一块内存，析构时重复释放）。因此必须手动实现深拷贝。
拷贝构造函数用于从已存在的 string 对象创建新对象，核心是为新对象分配独立内存并复制数据。

方法 1 - - - 直接分配内存拷贝

string(const string& s)
{
	_str = new char[s._capacity + 1];
	//strcpy(_str, s._str);
	memcpy(_str, s._str, s._size + 1);
	_size = s._size;
	_capacity = s._capacity;
}

方法 2 - - - 借助临时对象交换

string(const string& s)
	:_str(nullptr)
	, _size(0)
	,_capacity(0)
{
	string tmp(s._str);
	swap(tmp);
}

相比于方法 1，方法 2 利用临时对象的析构自动释放旧内存，避免手动释放可能出现的错误。
由于字符串中可能会有 ‘\0’，可能拷贝构造会有问题。下面只展示了部分代码。

使用方法 1
string.h

string(const string& s)
{
	_str = new char[s._capacity + 1];
	//strcpy(_str, s._str);
	memcpy(_str, s._str, s._size + 1);
	_size = s._size;
	_capacity = s._capacity;
}

test.cpp

#include "string.h"
void test_string()
{
	str::string s3("xxxxxxxxxxx");
	s3 += '\0';
	s3 += "tttt";
	cout << s3 << endl;
	str::string s4(s3);
	cout << s4 << endl;
}
int main()
{
	test_string();
	return 0;
}

在这里插入图片描述

使用方法 2
string.h

string(const string& s)
	:_str(nullptr)
	, _size(0)
	,_capacity(0)
{
	string tmp(s._str);
	swap(tmp);
}

test.cpp

#include "string.h"
void test_string()
{
	str::string s3("xxxxxxxxxxx");
	s3 += '\0';
	s3 += "tttt";
	cout << s3 << endl;
	str::string s4(s3);
	cout << s4 << endl;
}
int main()
{
	test_string();
	return 0;
}

在这里插入图片描述
因为 \0 的存在，方法 2 可能会出现 bug，因此这里建议使用方法 1。

赋值运算符重载

赋值运算符与拷贝构造的区别是赋值操作的目标对象已经存在，需要先释放其原有资源。

string& operator=(string tmp)  //传值时自动拷贝构造临时对象
{
    swap(tmp);     //交换当前对象与临时对象
    return *this;  //临时对象会在函数结束后自动析构,释放原有资源
}

优点

避免了手动判断自赋值（this != &s）的逻辑。
利用值传递自动完成拷贝，通过交换实现赋值。
临时对象析构时自动释放当前对象的旧资源，无需手动delete。

增删查改

string 类的核心价值在于提供便捷的字符串操作。这里我们重点解析几个常用操作的实现逻辑。

扩容操作

字符串需要动态扩容以容纳更多字符，reserve 和 resize 是两种常用的扩容接口，但功能不同：
reserve：仅预留容量（不改变实际字符数）
resize：改变字符串长度（不足时填充指定字符）

//预留容量(仅当n大于当前容量时扩容)
void reserve(size_t n) 
{
    if (n > _capacity) 
    {  
    	//避免不必要的扩容
        char* tmp = new char[n + 1];   //新内存(+1存'\0')
        memcpy(tmp, _str, _size + 1);  //复制原有数据
        delete[] _str;  //释放旧内存
        _str = tmp;
        _capacity = n;  //更新容量
    }
}
//调整长度(短则截断,长则填充)
void resize(size_t n, char ch = '\0') 
{
    if (n < _size) 
    {  
    	//缩短,直接截断
        _size = n;
        _str[_size] = '\0';  //更新终止符
    } 
    else 
    {  
    	//延长,填充字符
        reserve(n);  //确保容量足够
        for (size_t i = _size; i < n; i++) 
        {
            _str[i] = ch;    //填充指定字符
        }
        _size = n;
        _str[_size] = '\0';  //更新终止符
    }
}

reserve 不会改变 _size，也不会初始化新增的内存；resize 会改变 _ size，并对新增位置进行初始化。

插入操作

插入操作需要先判断容量是否足够，再移动原有数据腾出位置，最后插入新内容。

void insert(size_t pos, const char* str) 
{
    assert(pos <= _size);  //插入位置不能超过字符串长度
    size_t len = strlen(str);
    if (_size + len > _capacity) 
    {  
    	//容量不足时扩容
        reserve(_size + len);
    }
    //从后往前移动数据,避免覆盖
    size_t end = _size;
    while (end >= pos && end != _npos) 
    {
        //_npos避免下溢
        _str[end + len] = _str[end];
        end--;
    }
    //插入新字符串
    for (size_t i = 0; i < len; i++) 
    {
        _str[pos + i] = str[i];
    }
    _size += len;  //更新长度
}

关键逻辑

插入位置合法性检查（pos <= _size）。
先扩容再移动数据（避免多次扩容）。
从后往前移动数据（防止原有数据被覆盖）。
处理 end 下溢（当 pos = 0 时，end 减到 -1，size_t 会转为 _npos）。

查找与截取

字符串查找（find）和截取（substr）是处理 URL、路径等场景的常用功能。

//截取子串(从pos开始,长度为len)
string substr(size_t pos = 0, size_t len = _npos) 
{
    assert(pos < _size);  //起始位置合法
    //计算实际截取长度(避免越界)
    size_t n = len;
    if (len == _npos || pos + len > _size) 
    {
        n = _size - pos;  //最多截取到字符串末尾
    }
    string tmp;  //存储结果
    tmp.reserve(n);  //预留容量
    for (size_t i = pos; i < pos + n; i++) 
    {
        tmp += _str[i];  //拼接子串
    }
    return tmp;
}
//查找子串(从pos开始)
size_t find(const char* str, size_t pos = 0) 
{
    assert(pos < _size);
    //利用C库函数strstr查找子串
    const char* ptr = strstr(_str + pos, str);
    if (ptr) 
    {
        return ptr - _str;  //转换为相对起始地址的偏移量
    } 
    else 
    {
        return _npos;  //未找到
    }
}

运算符重载

为了让 string 类像原生类型一样使用，需要重载 [ ]（访问字符）和 +=（拼接字符串）。

//普通对象:可读可写
char& operator[](size_t pos) 
{
    assert(pos < _size);
    return _str[pos];
}
// const对象:仅可读
const char& operator[](size_t pos) const 
{
    assert(pos < _size);
    return _str[pos];
}
//拼接字符
string& operator+=(char ch) 
{
    push_back(ch);  //复用push_back
    return *this;
}
//拼接字符串
string& operator+=(const char* str) 
{
    append(str);  //复用append
    return *this;
}

const 重载的意义
确保 const 对象只能读取字符（不能修改），普通对象可以读写，符合 const 正确性原则。

迭代器与范围 for

迭代器是容器的通用遍历接口，string 类通过迭代器支持范围 for 循环。

// 迭代器定义(本质是字符指针的封装)
typedef char* iterator;
typedef const char* const_iterator;

//普通迭代器(可读可写)
iterator begin() 
{ 
	return _str; 
}
iterator end() 
{ 
	return _str + _size; 
}
//const迭代器(仅可读)
const_iterator begin() const 
{ 
	return _str; 
}
const_iterator end() const 
{ 
	return _str + _size; 
}

有了迭代器，就可以使用范围 for 遍历。如果没有迭代器，代码会报错。

string s("hello");
for (auto ch : s) 
{  
	//范围for会被编译器转换为迭代器遍历
    cout << ch << " ";
}

在这里插入图片描述
迭代器设计逻辑
begin( ) 返回首字符地址，end( ) 返回尾字符的下一个位置（左闭右开区间），这是 C++ 容器的通用设计。

流操作

为了支持 cout << string 和 cin >> string，需要重载流插入和流提取运算符。

//流插入(输出字符串)
ostream& operator<<(ostream& out, const string& s) 
{
    for (auto ch : s) 
    {  
    	//遍历输出每个字符(包括'\0'后的有效字符)
        out << ch;
    }
    return out;
}
//流提取(读取字符串,忽略前导空格)
istream& operator>>(istream& in, string& s) 
{
    s.clear();  //先清空原有内容
    char ch = in.get();  //读取单个字符(包括空格)
    //跳过空格和换行
    while (ch == '\n' || ch == ' ') 
    {
        ch = in.get();
    }
    //读取有效字符(遇到空格或换行停止)
    char buff[128];  //缓冲区减少频繁扩容
    int i = 0;
    while (ch != '\n' && ch != ' ') 
    {
        buff[i++] = ch;
        if (i == 127) 
        {  
        	//缓冲区满时写入string
            buff[i] = '\0';
            s += buff;
            i = 0;
        }
        ch = in.get();
    }
    //处理缓冲区剩余字符
    if (i != 0) 
    {
        buff[i] = '\0';
        s += buff;
    }
    return in;
}

流插入与 c_str ( ) 的区别

cout << s：输出 _size 个字符（即使中间有 ‘\0’）。
cout << s.c_str( )：输出到第一个 ‘\0’ 为止（C 风格字符串逻辑）。

写时拷贝

浅拷贝的问题

析构 2 次。
一个对象修改会影响另一个 (写的时候引用计数如果不是 1,则进行深拷贝，再修改)。

写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。

引用计数

引用计数用来记录资源使用者的个数。在构造时，将资源的计数给成 1，每增加一个对象使用该资源，就给计数增加 1，当某个对象被销毁时，先给该计数减 1，然后再检查是否需要释放资源，如果计数为 1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。

在不同的编译环境下有着不同的结果。
Linux
在这里插入图片描述
VS2022

#include<iostream>
#include<string>
using namespace std;
int main()
{
	std::string s1("hello world");
	std::string s2(s1);
	//深拷贝
	printf("%p\n", s1.c_str());
	printf("%p\n", s2.c_str());
	s2[0]++;
	printf("%p\n", s1.c_str());
	printf("%p\n", s2.c_str());
	cout << sizeof(s1) << endl;
	return 0;
}

在这里插入图片描述

总结

在 Linux 环境下，前两次地址相同，说明拷贝构造函数是浅拷贝，而不是深拷贝，修改 s2 后地址发生改变（写时拷贝触发深拷贝）。
在 VS 编译器中，直接进行的是深拷贝，没有进行浅拷贝。

_Buf 和 _Ptr

#include<iostream>
#include<string>
using namespace std;
int main()
{
	std::string s1("hello world");//size<16,字符串存在_Buf数组中
	std::string s2("hello worldxxxxxxxxxxxxxxxxx");//
	return 0;
}

总结
在 VS 编译器中，当 size < 16，字符串存在 _Buf 数组中，当 size >= 16，字符串在 _Ptr 指向的堆空间中。

在这里插入图片描述

总结

模拟实现 string 类的过程，本质是拆解 “字符串管理” 的核心逻辑：从内存分配到资源释放，从拷贝安全到操作优化，每一步都体现着 C++ 对 “功能与性能” 的平衡。而写时拷贝、存储策略等细节，更让我们看到标准库设计的精妙。掌握这些底层逻辑，不仅能让我们更灵活地使用 string 类，更能培养 “透过接口看实现” 的编程思维 - - - 这正是从 “使用者” 到 “设计者” 的重要一步。