C++ string深度解析：从现代用法到底层实现与模拟

发布时间：2026/7/28 21:07:59

C++ string深度解析：从现代用法到底层实现与模拟

1. 项目概述：为什么在2024年还要深究string？

最近在带新人，发现一个挺有意思的现象：很多刚接触C++的朋友，甚至一些工作一两年的开发者，对std::string的态度很“分裂”。一方面，觉得它太基础、太简单，不就是个“字符串”嘛，cin >>、cout <<、+拼接一下，日常够用了。另一方面，一旦遇到性能问题、内存越界、或者需要实现自定义字符串行为时，就有点抓瞎，只能去网上找代码“借鉴”，知其然不知其所以然。

这个项目标题——“2024年【C++】string使用&&模拟实现_string &&”——虽然带着点“标题党”的味道，但它确实戳中了一个核心：在C++20/23甚至展望C++26的今天，理解std::string的底层实现和现代用法，依然是夯实C++基本功、写出高效稳健代码的必经之路。这不仅仅是应付面试的“八股文”，更是解决实际开发中那些诡异Bug、进行性能调优的钥匙。今天，我就结合自己这些年踩过的坑和优化过的代码，来一次彻底的string深度游，从现代C++的高阶用法，一直挖到它的“五脏六腑”，并手把手带你模拟实现一个具备核心功能的String类。

2. string在现代C++中的核心使用范式

很多人对string的认知还停留在C++98时代。现代C++（C++11及以后）为string注入了大量新特性，让它的使用更安全、更高效。

2.1 初始化与字面量：告别混乱的构造方式

过去，我们可能这样初始化字符串：

std::string s1 = “hello”; // 拷贝初始化 std::string s2(“world”); // 直接初始化 char arr[] = {‘a‘, ’b‘, ’c‘, ’\0’}; std::string s3(arr); // 从C风格字符串构造

现代C++提供了更清晰、更高效的选项：

// 使用初始化列表 (C++11) std::string s4{‘H‘, ’e‘, ’l‘, ’l‘, ’o’}; // 注意：这不是”Hello”，是字符列表，s4为”Hello” // 更推荐：直接使用字符串字面量，但要注意类型 auto s5 = “Hello”; // 危险！s5的类型是`const char*`，不是std::string！ std::string s6 = “Hello”s; // C++14引入的用户定义字面量，需要`using namespace std::string_literals;`

注意：using namespace std::string_literals;这行代码能让“Hello”s这个后缀s生效，它直接构造一个std::string对象，避免从const char*隐式转换带来的额外开销。

2.2 字符串视图（string_view）：只读场景的性能利器

这是C++17引入的“游戏规则改变者”。std::string_view是一个非拥有（non-owning）的字符串引用，它不管理内存，只是提供一个观察字符串的“窗口”。在函数参数、子串操作等只读场景下，它能极大避免不必要的内存拷贝。

#include <string_view> void old_print(const std::string& str) { std::cout << str.substr(0, 5) << std::endl; // 这里substr返回了一个新的临时string对象，有一次拷贝和分配 } void modern_print(std::string_view sv) { std::cout << sv.substr(0, 5) << std::endl; // 这里substr返回的是一个新的string_view，仅调整起始点和长度，零拷贝！ } int main() { std::string long_str = “This is a very long string...”; old_print(long_str); // 可能触发一次内存分配和拷贝 modern_print(long_str); // 零拷贝，仅传递指针和长度 modern_print(“A C-style string”); // 甚至可以直接接受字面量，无需构造临时string }

使用心得：将函数参数从const std::string&改为std::string_view，几乎总是一个性能优化。但切记，string_view不管理生命周期，你必须确保它观察的底层字符串在string_view被使用期间一直有效。绝不能返回一个指向局部变量字符串的string_view。

2.3 内存管理：capacity、shrink_to_fit与移动语义

string内部会分配比当前字符串内容（size()）稍大一些的内存，这个大小就是capacity()。这是为了应对后续的append、+=操作，避免每次增长都重新分配内存（realloc），这是一个经典的“空间换时间”策略。

std::string str; std::cout << “初始容量:” << str.capacity() << std::endl; // 实现定义，可能是0或15 str.reserve(100); // 预先分配至少100字符的内存 str = “Hello”; std::cout << “size=” << str.size() << “, capacity=” << str.capacity() << std::endl; // size=5, capacity>=100 str.shrink_to_fit(); // C++11，请求移除未使用的容量（非强制，是hint）

关键点：reserve()用于提前分配，减少后续追加操作的重分配次数。shrink_to_fit()在确定字符串不会再增长后使用，可以节省内存，但可能导致后续追加操作再次触发重分配。

移动语义（C++11）是另一个性能飞跃。当发生资源转移（如函数返回值、放入容器）时，移动而非拷贝。

std::string create_big_string() { std::string big(100000, ’a’); // 一个大字符串 return big; // 编译器通常会进行RVO（返回值优化），否则也会触发移动构造 } std::string s = create_big_string(); // 高效，很可能是零拷贝或移动语义

2.4 新式查找与操作：更丰富的API

C++20为string增加了starts_with()和ends_with()成员函数，让前缀/后缀检查变得异常简单。

std::string filename = “example.cpp”; if (filename.ends_with(“.cpp”) || filename.ends_with(“.h”)) { std::cout << “这是一个C++源文件或头文件” << std::endl; }

contains()（C++23）则用于检查是否包含子串，比find() != std::string::npos更直观。

if (str.contains(“error”)) { // C++23 // 处理错误 }

3. 模拟实现String类的核心设计

理解了怎么用，我们再来拆解它怎么实现。自己动手实现一个简化版的String类（我们叫它MyString），是理解RAII、拷贝控制、运算符重载等C++核心概念的最佳实践。

3.1 基础架构与RAII管理

核心思想：资源获取即初始化（RAII）。类的构造函数分配内存，析构函数释放内存，确保没有内存泄漏。

class MyString { public: // 默认构造函数 MyString() : data_(new char[1]), size_(0), capacity_(0) { data_[0] = ’\0’; } // 从C风格字符串构造 MyString(const char* str) { size_ = strlen(str); capacity_ = size_; data_ = new char[capacity_ + 1]; // +1 for ’\0’ strcpy(data_, str); } // 析构函数 ~MyString() { delete[] data_; data_ = nullptr; size_ = capacity_ = 0; } private: char* data_; // 指向堆上字符数组的指针 size_t size_; // 当前字符串长度（不含’\0’） size_t capacity_; // 当前分配的总容量（不含’\0’） };

踩坑记录1：new char[size_]和new char[size_ + 1]。一定要为结尾的’\0’预留空间，这是C风格字符串的约定，也是strcpy、strlen等函数工作的基础。忘记+1是初学者最常见的错误之一，会导致越界写入。

3.2 “三/五之法则”与深拷贝

如果一个类需要自定义析构函数，那么它几乎肯定也需要自定义拷贝构造函数和拷贝赋值运算符（这就是“三之法则”）。C++11后，加上移动构造和移动赋值，就是“五之法则”。

浅拷贝（默认行为）的灾难：

MyString a(“Hello”); MyString b = a; // 默认拷贝构造，仅拷贝指针，a和b的data_指向同一块内存 // 作用域结束，a和b先后析构，同一块内存被delete两次 -> 程序崩溃（double free）

我们必须实现深拷贝：

// 拷贝构造函数 MyString(const MyString& other) : size_(other.size_), capacity_(other.capacity_) { data_ = new char[capacity_ + 1]; strcpy(data_, other.data_); } // 拷贝赋值运算符（传统写法） MyString& operator=(const MyString& other) { if (this != &other) { // 1. 防止自赋值 a = a delete[] data_; // 2. 释放原有资源 size_ = other.size_; capacity_ = other.capacity_; data_ = new char[capacity_ + 1]; // 3. 分配新资源 strcpy(data_, other.data_); // 4. 拷贝数据 } return *this; // 5. 返回自身引用 }

拷贝赋值运算符的经典写法：注意自赋值检查（if (this != &other)）。自赋值虽然不常见，但一旦发生，如果没有检查，delete[] data_会先释放掉自己的内存，紧接着new和strcpy操作的就是一块已被释放的内存，导致未定义行为。

3.3 移动语义的实现：性能的关键

移动语义是C++11的精华，它允许“偷取”临时对象（右值）的资源，避免昂贵的深拷贝。

// 移动构造函数（参数是非常量右值引用） MyString(MyString&& other) noexcept // noexcept很重要，标准库容器在扩容时会优先使用noexcept的移动操作 : data_(other.data_), size_(other.size_), capacity_(other.capacity_) { other.data_ = nullptr; // 关键！将源对象置于有效但可析构的状态 other.size_ = other.capacity_ = 0; } // 移动赋值运算符 MyString& operator=(MyString&& other) noexcept { if (this != &other) { delete[] data_; // 释放自身旧资源 data_ = other.data_; // “窃取”资源 size_ = other.size_; capacity_ = other.capacity_; other.data_ = nullptr; // 置空源对象 other.size_ = other.capacity_ = 0; } return *this; }

实现要点：

  1. 参数类型是MyString&&。
  2. 直接“窃取”other内部的指针等资源。
  3. 必须将other的成员置为空（如nullptr）。这确保了other析构时不会错误地释放已被我们“偷走”的内存，同时other对象本身仍然处于一个可安全析构和重新赋值的状态。
  4. 标记为noexcept。这告知标准库该操作不会抛出异常，使得std::vector<MyString>这样的容器在重新分配内存时，能安全且高效地使用移动而非拷贝。

3.4 运算符重载：让类用起来像内置类型

为了让MyString用起来和std::string一样自然，我们需要重载一些运算符。

// 重载下标运算符[]（非const版本，可修改） char& operator[](size_t pos) { // 边界检查！生产环境应更严谨，或提供at()函数进行带异常抛出的检查 assert(pos < size_); return data_[pos]; } // 重载下标运算符[]（const版本，用于const对象） const char& operator[](size_t pos) const { assert(pos < size_); return data_[pos]; } // 重载+=运算符（追加字符串） MyString& operator+=(const char* str) { size_t len = strlen(str); if (size_ + len > capacity_) { // 需要扩容，通常策略是capacity_ = max(capacity_ * 2, size_ + len) reserve(size_ + len); } strcpy(data_ + size_, str); // 从原结尾处开始拷贝 size_ += len; return *this; } MyString& operator+=(const MyString& str) { return *this += str.c_str(); // 复用上面的实现 } // 重载+运算符（通常定义为非成员函数，以支持“字面量 + MyString”） friend MyString operator+(const MyString& lhs, const MyString& rhs) { MyString temp(lhs); // 拷贝构造左值 temp += rhs; // 复用+= return temp; // 依赖返回值优化（RVO）或移动语义 } // 重载流插入运算符<< friend std::ostream& operator<<(std::ostream& os, const MyString& str) { os << str.data_; return os; }

运算符重载的常见问题：

  • operator=、operator+=、operator<<=等应返回左值引用（MyString&），以支持链式调用（如a = b = c）。
  • operator+通常应定义为非成员函数，以支持左右操作数的对称性。它内部可以通过调用operator+=来实现，这被称为“用+=实现+”的惯用法。
  • 对于operator[]，提供const和非const两个版本是良好实践，以分别处理const MyString和普通MyString对象。

3.5 容量管理：reserve与resize

这是string类高效与否的核心。

void reserve(size_t new_capacity) { if (new_capacity <= capacity_) return; // 无需扩容 char* new_data = new char[new_capacity + 1]; // 分配新内存 strcpy(new_data, data_); // 拷贝旧数据 delete[] data_; // 释放旧内存 data_ = new_data; capacity_ = new_capacity; } void resize(size_t new_size, char ch = ’\0’) { if (new_size > capacity_) { reserve(new_size); // 需要扩容 } if (new_size > size_) { // 扩大，填充指定字符 memset(data_ + size_, ch, new_size - size_); } // 无论是扩大还是缩小，都要设置新size和结束符 size_ = new_size; data_[size_] = ’\0’; }

扩容策略：标准库的实现通常采用指数增长策略（例如，每次扩容为当前容量的1.5或2倍）。这保证了连续进行n次push_back（或+=）操作的总时间复杂度是均摊O(n)的，而不是每次都是O(n)。我们模拟实现时也可以采用capacity_ = capacity_ == 0 ? 1 : capacity_ * 2这样的简单策略。

4. 模拟实现中的关键细节与陷阱

自己动手实现时，会遇到很多教科书上不会提的“坑”。

4.1 空指针与零长度字符串的处理

我们的默认构造函数分配了一个字节来存放’\0’，这保证了c_str()始终返回一个有效的C风格字符串（即使是空字符串）。这是一种常见的稳健设计。另一种设计是让data_在空状态下为nullptr，但这意味着c_str()需要做空指针检查，返回一个静态的空字符串“”，实现稍复杂。

4.2 拷贝交换（Copy-and-Swap）惯用法

传统的拷贝赋值运算符需要处理自赋值和异常安全。拷贝交换惯用法是一种更优雅、更安全的方式。

// 首先，我们需要一个swap成员函数或友元函数 void swap(MyString& other) noexcept { using std::swap; // 启用ADL（参数依赖查找） swap(data_, other.data_); swap(size_, other.size_); swap(capacity_, other.capacity_); } // 然后，拷贝赋值运算符可以这样写 MyString& operator=(MyString other) noexcept { // 注意！参数是值传递，会调用拷贝构造或移动构造 swap(other); // 与传入的副本交换资源 return *this; // 离开作用域时，形参other（现在持有我们的旧资源）被析构 }

优点：

  1. 异常安全：资源分配（发生在拷贝构造/移动构造other时）如果失败，异常会在修改*this之前抛出。
  2. 自赋值安全：如果是自赋值a = a，值传递会调用拷贝构造创建一个临时副本，然后交换，最后临时副本（持有和原来一样的资源）被析构，逻辑正确。
  3. 代码复用：同时利用了拷贝构造函数和析构函数的逻辑，代码简洁。

4.3 迭代器支持

为了让MyString能和标准库算法（如std::sort,std::find）协同工作，最好提供迭代器。

// 在类定义中添加类型别名（C++11 using语法） using iterator = char*; using const_iterator = const char*; // 成员函数 iterator begin() { return data_; } iterator end() { return data_ + size_; } const_iterator begin() const { return data_; } const_iterator end() const { return data_ + size_; } const_iterator cbegin() const { return data_; } const_iterator cend() const { return data_ + size_; }

这样，你就可以像使用标准容器一样使用MyString：

MyString str(“hello”); for (auto it = str.begin(); it != str.end(); ++it) { *it = toupper(*it); } // 或者使用范围for循环 for (char& ch : str) { ... }

4.4 小字符串优化（SSO）的思考

现代std::string实现（如GCC的libstdc++、Clang的libc++）几乎都采用了小字符串优化（SSO）。其核心思想是：对于很短的字符串（例如长度小于16），直接将其内容存储在对象自身的栈内存中，而不去堆上动态分配。这极大地提升了短字符串创建、拷贝和销毁的性能。

在我们的简单实现中，为了专注于核心逻辑，没有引入SSO。但了解它非常重要。一个极简的SSO思路是：在MyString类内部使用一个联合体（union），其中一个成员是指向堆内存的指针，另一个成员是固定大小的字符数组。根据字符串长度决定使用哪个存储方式。

5. 从模拟实现反观std::string的最佳实践

通过自己实现一遍，再回头看std::string，你会对以下最佳实践有更深的理解：

  1. 优先使用std::string而不是char*：自动管理内存，避免内存泄漏和越界。
  2. 函数参数传递：
    • 只读参数：使用std::string_view（C++17+）是最佳选择，否则使用const std::string&。
    • 需要修改参数：使用std::string&。
    • 需要获取参数所有权：使用std::string（值传递），配合移动语义。
  3. 返回值优化：放心地返回局部string对象，编译器会进行RVO/NRVO，或者至少触发移动语义。
  4. 善用reserve()：在已知最终大小或需要频繁追加时，提前reserve可以避免多次重分配。
  5. 理解operator+与operator+=的开销：s1 + s2 + s3会产生临时对象。在循环中拼接字符串，使用ostringstream或+=是更好的选择。
  6. 注意c_str()和data()的生命周期：c_str()返回的指针在string对象被修改或销毁后即失效。如果需要持久化，请拷贝它。

自己动手模拟实现一个String类，就像给汽车做了一次彻底拆解再组装。这个过程会让你对C++的类设计、内存管理、拷贝控制有刻骨铭心的认识。下次当你再使用std::string时，你看到的将不再是一个黑盒，而是一个由构造函数、析构函数、指针和精心设计的算法组成的精密系统。这才是深入理解一门语言的正确方式。

相关新闻

Arduino创客实践：从舵机控制到WS2812B灯光编程的万圣节骷髅机器人制作

Arduino创客实践：从舵机控制到WS2812B灯光编程的万圣节骷髅机器人制作

1. 项目缘起&#xff1a;从“气氛灯”到“骷髅机器人”的创客实践 又到了一年一度的万圣节&#xff0c;你是不是也在琢磨着&#xff0c;除了南瓜灯和糖果&#xff0c;还能搞点什么新花样&#xff0c;让家里的节日气氛更上一层楼&#xff1f;去年&#xff0c;我就在捣鼓一个简单…

2026/7/28 21:07:59
Claude Code中Prompt缓存的原理与优化实践

Claude Code中Prompt缓存的原理与优化实践

1. 为什么Prompt缓存对Claude Code如此重要在开发者和AI工程师的日常工作中&#xff0c;Claude Code已经成为处理复杂编程任务和长上下文分析的重要工具。但很多人可能没有意识到&#xff0c;Prompt缓存机制对工作效率的提升有多么关键。想象一下&#xff0c;每次向Claude Code…

2026/7/28 21:07:59
TegraRcmGUI：解锁Nintendo Switch潜能的终极图形化注入工具指南

TegraRcmGUI：解锁Nintendo Switch潜能的终极图形化注入工具指南

TegraRcmGUI&#xff1a;解锁Nintendo Switch潜能的终极图形化注入工具指南 【免费下载链接】TegraRcmGUI C GUI for TegraRcmSmash (Fuse Gele exploit for Nintendo Switch) 项目地址: https://gitcode.com/gh_mirrors/te/TegraRcmGUI 你是否拥有一台2018年7月前生产的…

2026/7/28 21:08:07

最新新闻

KillerCoda实战Kubesploit：云原生安全攻防演练指南

KillerCoda实战Kubesploit：云原生安全攻防演练指南

1. 项目概述&#xff1a;为什么要在KillerCoda里玩转Kubesploit&#xff1f;最近在跟几个做云原生安全的朋友聊天&#xff0c;发现一个挺有意思的现象&#xff1a;很多安全研究员对容器和Kubernetes的攻击面理论头头是道&#xff0c;但真给一个环境让他去实操&#xff0c;从信息…

2026/7/28 22:13:10
Claude 4.8百万Token上下文调优：长文档处理稳定运行方案

Claude 4.8百万Token上下文调优：长文档处理稳定运行方案

前言&#xff1a;窗口20万token&#xff0c;但项目文档动辄几十万字 Claude 4.8的上下文窗口是20万token——约5500行代码或15万字中文。听起来不少&#xff0c;但一个大型项目的技术文档、一个完整的产品PRD、一份几十页的合同——轻松超过这个上限。窗口塞不下怎么办&#x…

2026/7/28 22:13:10
AI论文写作工具对比：千笔AI与PaperRed功能测评

AI论文写作工具对比：千笔AI与PaperRed功能测评

1. 项目概述&#xff1a;AI论文写作平台对比分析作为一名在学术写作领域摸爬滚打多年的从业者&#xff0c;我见证了AI写作工具从最初的简单语法检查发展到如今能够辅助完成整篇论文的蜕变。2026年这个时间节点特别值得关注——随着学术评价体系的改革和AI技术的成熟&#xff0c…

2026/7/28 22:13:10
DeepSeek DSpark推理加速实战：投机解码技术原理与vLLM部署指南

DeepSeek DSpark推理加速实战：投机解码技术原理与vLLM部署指南

1. 先搞清楚 DSpark 到底解决了什么实际问题 如果你正在用 DeepSeek 这类大模型做文本生成、代码补全或者对话，最头疼的往往不是模型能力，而是推理速度。尤其是在本地部署或者调用 API 时，看着生成结果一个字一个字往外蹦，那种等待感非常影响效率。DeepSeek DSpark 瞄准的…

2026/7/28 22:13:10
限时解密：某省重点中学AI数学实验室内部训练集构建方法（含327道动态生成题库结构图）

限时解密：某省重点中学AI数学实验室内部训练集构建方法（含327道动态生成题库结构图）

更多请点击&#xff1a; https://kaifayun.com 第一章&#xff1a;AI 数学学习辅助 人工智能正深刻重塑数学教育的形态与效率。借助大语言模型、符号计算引擎与自适应学习算法&#xff0c;AI 不再仅是解题工具&#xff0c;而是具备推理引导、概念拆解与错误归因能力的学习协作…

2026/7/28 22:13:35
从MessageBox到cmp指令：逆向分析序列号验证的完整实战指南

从MessageBox到cmp指令：逆向分析序列号验证的完整实战指南

1. 项目概述&#xff1a;逆向分析中的“序列号”攻防在软件安全领域&#xff0c;“序列号”或“激活码”是软件开发者保护其知识产权、实现商业授权的一种常见手段。它像一把数字钥匙&#xff0c;只有正确的钥匙才能打开软件的全部功能。而“序列号破解”&#xff0c;则是一场围…

2026/7/28 22:13:35

日新闻

告别臃肿！3步让你的暗影精灵笔记本重获新生

告别臃肿！3步让你的暗影精灵笔记本重获新生

告别臃肿&#xff01;3步让你的暗影精灵笔记本重获新生 【免费下载链接】OmenSuperHub Control Omen laptop performance, fan speeds, and keyboard lighting, and unlock power limits. 项目地址: https://gitcode.com/gh_mirrors/om/OmenSuperHub 你是否也曾为官方Om…

2026/7/28 0:00:52
RAG必踩坑！财报法规检索不准？这款开源工具让答案浮出水面，准确率飙升98.7%！

RAG必踩坑！财报法规检索不准？这款开源工具让答案浮出水面，准确率飙升98.7%！

做 RAG 的人应该都踩过这个致命的坑&#xff1a;把几百页的财报、法规、技术手册扔给向量库&#xff0c;问一个具体问题&#xff0c;搜出来的全是沾边但没用的内容 —— 关键信息要么被硬切块拆碎了&#xff0c;要么藏在几十条结果的最下面。语义相似≠真正相关&#xff0c;这个…

2026/7/28 0:00:52
抖音视频文案提取工具全指南：免费2026版、手机App、在线工具一网打尽

抖音视频文案提取工具全指南：免费2026版、手机App、在线工具一网打尽

2026年做短视频运营&#xff0c;从抖音上扒文案早就不是偷偷抄笔记的事了。我刚开始做内容的时候&#xff0c;每天刷半小时抖音&#xff0c;手动把爆款视频的口播敲进备忘录&#xff0c;一条2分钟的视频得花十来分钟&#xff0c;碰到语速快的还要反复回听。后来试了一圈工具&am…

2026/7/28 0:00:52

周新闻

Apex英雄目标检测数据集 深度学习框架YOLO如何训练APEX数据集

Apex英雄目标检测数据集 深度学习框架YOLO如何训练APEX数据集

Apex检测数据集数据集详情检测类别&#xff1a; allies enemy tag图片总量&#xff1a;7247张训练集&#xff1a;5139张验证集&#xff1a;1425张测试集&#xff1a;683张标注状态&#xff1a;全部已标注&#xff0c;即拿即用数据格式&#xff1a;支持YOLO格式及其他格式&#…

2026/7/28 8:40:21
智慧飞行 大疆无人机一站式智能管控平台/支持大疆机场/私有化部署 从航线规划、自动飞行、AI识别到数据管理，一个平台全搞定

智慧飞行 大疆无人机一站式智能管控平台/支持大疆机场/私有化部署 从航线规划、自动飞行、AI识别到数据管理，一个平台全搞定

智慧飞行-大疆无人机一站式智能管控平台/支持大疆机场/私有化部署 企业级全域智能无人机一体化管控平台源码&#xff01; 专为电力巡检、安防监控、应急救援、测绘勘察等行业打造&#xff0c;让您的无人机舰队实现 “无人化、自动化、智能化” 管理&#xff01; &#x1f3af; …

2026/7/28 6:30:42
揭秘ChatGPT+Mathematica协同教学：为什么92%的初学者在72小时内建立函数直觉？

揭秘ChatGPT+Mathematica协同教学：为什么92%的初学者在72小时内建立函数直觉？

更多请点击&#xff1a; https://codechina.net 第一章&#xff1a;AI帮助理解数学概念 人工智能正以前所未有的方式重塑数学学习的路径。通过自然语言处理与符号计算的深度融合&#xff0c;AI不仅能解析抽象定义&#xff0c;还能将定理、证明和几何直觉转化为可交互、可验证的…

2026/7/28 9:00:08

月新闻

[C++]内存管理：串顺序存储的内存回收

[C++]内存管理：串顺序存储的内存回收

在串&#xff08;字符串&#xff09;的顺序存储中&#xff0c;内存回收的方式取决于字符串的存储方式以及所使用的编程语言和相关库。以下以 C 为例进行说明&#xff0c;因为 C 对内存管理有较为直接的控制。 1. 基于 char 数组的串顺序存储 如果使用普通的 char 数组来存储字…

2026/7/28 2:07:36
移动端游戏功耗测试实战：电流、功率、亮度和场景对比

移动端游戏功耗测试实战：电流、功率、亮度和场景对比

移动端游戏功耗测试：先控制变量，再比较优化是否真的省电 摘要：功耗测试最容易犯的错误，是拿两次不同温度、不同亮度、不同场景的平均功率直接比较。本文给出一套可复现的游戏功耗测试方法，覆盖引擎特性验证、版本回归和黑盒体验测试，并说明如何把功耗与帧率、温控、CPU/G…

2026/7/28 2:07:37
足球口袋教练 HarmonyOS 离线应用实战（03/20）：ArkUI 首页仪表盘搭建

足球口袋教练 HarmonyOS 离线应用实战（03/20）：ArkUI 首页仪表盘搭建

本文是“足球口袋教练 HarmonyOS 离线应用实战”系列第 3 篇。示例项目是一个 HarmonyOS / ArkTS / ArkUI 编写的离线足球训练助手&#xff0c;围绕真实页面、真实截图和可复现操作展开。 本篇要解决的问题 训练 App 的首页不能只展示欢迎语&#xff0c;它要解决“我现在该点哪…

2026/7/28 11:58:14