1. 项目概述为什么我们需要深入理解string类在C的日常开发中std::string大概是除了int之外我们使用频率最高的类型之一。从简单的日志打印、文件名拼接到复杂的文本解析、网络协议处理它无处不在。很多朋友在初学C时会觉得string用起来和char*差不多无非是size()、c_str()、这几个接口能干活就行。但当你真正开始处理大规模数据、追求性能优化或者面试时被问到“string的拷贝构造为什么可能成为性能瓶颈”、“VS和G下的string对象大小为什么不一样”这类问题时仅仅停留在“会用”层面就显得捉襟见肘了。我见过不少项目因为对string的内存模型和接口行为理解不透彻导致了内存泄漏、性能低下甚至难以排查的崩溃问题。比如一个看似无害的string s funcReturnString();调用背后可能隐藏着一次或多次深拷贝再比如在循环中反复使用拼接短字符串可能引发频繁的、代价高昂的重新分配。这些问题根源都在于对string这个“黑盒”的内部机制不了解。这篇文章我们就来彻底拆解这个“黑盒”。我不会只罗列API文档那太枯燥了。我会带你从两个最主流的编译器VS和G下的不同内存布局开始一步步深入到接口的实现细节、深拷贝与浅拷贝的经典陷阱最后手把手实现一个具备工业级思考的简易String类。目标是让你不仅知道string怎么用更明白它为什么这么设计以及在不同场景下如何用得“恰到好处”写出既安全又高效的代码。2. 内存模型探秘VS与G的两种设计哲学如果你在VSVisual Studio和GGNU编译器套件下分别打印sizeof(std::string)很可能会得到两个不同的结果在32位平台上VS通常是28字节而G可能是8字节64位平台下差异更大。这个差异直接反映了两种截然不同的内存管理策略理解它们对写出跨平台且高性能的代码至关重要。2.1 VS下的SSOSmall String Optimization模型在VS的实现中以较新版本为例string对象内部通常包含以下几个成员一个联合体union用于存储字符串内容。这是关键。一个size_t类型的变量记录当前字符串的有效长度size。一个size_t类型的变量记录当前已分配的内存总容量capacity。可能还有一个指针用于指向分配器或其他管理信息。联合体的设计是精髓。它内部通常包含char _Buf[16]: 一个固定大小的字符数组例如16字节。char* _Ptr: 一个指向堆内存的指针。它的工作逻辑是这样的当你要存储的字符串长度小于16这个阈值是实现定义的常见为15或23因为要留一个字节给结束符\0时string对象会直接使用内部的_Buf数组来存放字符串。此时_Ptr成员是未激活的。这种情况下构造、拷贝、析构都发生在栈上速度极快且没有堆内存分配的开销。当字符串长度大于等于16时联合体则使用_Ptr指针在堆上申请一块足够大的内存来存放字符串。此时_Buf数组闲置。为什么这么设计统计表明程序中的绝大多数字符串都是很短的比如文件名、关键字、状态码。SSO优化正是针对这一场景通过避免短字符串的堆内存分配极大地提升了这些高频操作的性能也减少了内存碎片。你可能会问那对象本身不是变大了吗是的VS的string对象固定为28字节左右。但对于短字符串用稍大的栈空间换取一次昂贵的堆分配这笔交易非常划算。2.2 G下的COWCopy-On-Write与演进G的旧版本如GCC 4.x及之前曾广泛使用写时拷贝Copy-On-Write, COW技术。在这种模型下string对象本身很小例如在32位系统下就是一个指针4字节它指向一个堆上的控制块。这个控制块不仅存储字符串内容还包含长度size、容量capacity和一个引用计数refcount。COW的工作原理拷贝构造或赋值当string s2 s1;执行时并不立即复制字符串内容。s2的指针会指向s1所指向的同一个控制块并将该控制块的引用计数加1。这是一个典型的浅拷贝速度极快。写操作当试图修改任何一个string对象的内容如s2[0] ‘A’;时才会真正进行深拷贝检查引用计数如果大于1则分配新的内存复制内容并让当前对象指向新内存同时原控制块引用计数减1。这就是“写时”拷贝。COW的利与弊优点对于以读为主、拷贝频繁但修改稀少的场景例如作为函数参数传递只读字符串COW能节省大量内存和拷贝时间。缺点线程安全问题在多线程环境下对引用计数的增减需要原子操作否则会有数据竞争风险。早期的COW实现可能不是线程安全的。“写”的代价不确定任何非const的访问如operator[]的非const版本都可能触发深拷贝这给性能分析带来了不确定性。与标准的一些微妙冲突C11标准对迭代器失效等规则有更严格的要求使得COW的实现变得复杂且容易出问题。因此在现代G版本如GCC 5以后中默认已经弃用了COW实现转而采用了类似SSO或直接深拷贝的策略。例如libstdc现在也使用了SSO内部缓冲区大小可能是15字节。所以如果你在新版G下看到sizeof(std::string)是32字节64位也不必惊讶它很可能也包含了本地缓冲区。实操心得永远不要假设sizeof(std::string)的大小也不要依赖特定实现的内存布局。如果你需要将string对象进行二进制传输例如网络发包、写文件必须序列化为c_str()和size()。跨平台或跨编译器版本时内存布局的差异是致命的。2.3 如何探查你编译器下的string实现一个简单的方法是写个小程序测试#include iostream #include string int main() { std::string s1 “short”; // 短字符串 std::string s2 “this is a very long string that definitely exceeds the SSO buffer”; // 长字符串 const char* p1 s1.c_str(); const char* p2 s2.c_str(); std::cout “sizeof(std::string): ” sizeof(std::string) std::endl; std::cout “Address of s1: ” (void*)s1 std::endl; std::cout “Address of s1‘s data: ” (void*)p1 std::endl; std::cout “Address of s2: ” (void*)s2 std::endl; std::cout “Address of s2‘s data: ” (void*)p2 std::endl; // 如果p1指向s1对象内部的地址说明是SSO。 // 如果s1和p1地址相差很远说明数据在堆上。 return 0; }观察数据指针c_str()返回的地址和对象本身地址s1的关系。如果对于短字符串s1这两个地址非常接近差值小于sizeof(std::string)那么很可能使用了SSO。3. 核心接口的深度解析与高效使用指南了解了内存模型我们再看接口的使用就能明白其背后的代价从而做出最优选择。string的接口有上百个我们聚焦最核心、最容易用错或产生性能问题的几个。3.1c_str()与data()与C世界的桥梁这两个函数都返回指向内部字符数组的指针但在C11前后有重要区别。c_str():始终返回一个以空字符\0结尾的C风格字符串指针。这是它的承诺即使字符串内部包含\0它也会保证返回的指针在有效长度后有一个\0。这是与C语言函数如fopen,strcmp,send等交互的标准且安全的方式。std::string filename “test.txt”; FILE* fp fopen(filename.c_str(), “r”); // 正确做法data(): 在C11之前它不保证返回的数组以\0结尾。从C11开始data()的行为变得和c_str()一样也保证以\0结尾。所以在现代C中如果你只需要一个只读的指针两者都可以。但c_str()的语义更清晰表明“我需要一个C风格字符串”可读性更好。注意事项c_str()和data()返回的指针在string对象发生非 const 成员函数调用如append,operator,clear, 非const版本的operator[]等后可能会失效。不要保存这个指针长期使用应该随用随取。3.2substr()与copy()如何优雅地“切”字符串这是两个功能相似但用法迥异的接口。substr(pos, len): 返回一个新的string对象包含从pos开始的len个字符或直到末尾。这是你99%情况下应该使用的。因为它直接返回一个管理自己内存的string对象安全、方便。std::string path “/usr/local/bin/app”; std::string dir path.substr(0, path.find_last_of(‘/’)); // “/usr/local/bin” std::string file path.substr(path.find_last_of(‘/’) 1); // “app”copy(char* dest, len, pos): 将string中从pos开始的len个字符复制到用户提供的dest缓冲区。它不会在末尾添加\0你需要自己保证dest足够大并且手动添加结束符。这更像是C语言的风格容易出错。std::string s “hello”; char buf[10]; s.copy(buf, 5, 0); // 复制5个字符 buf[5] ‘\0’; // 必须手动添加否则不是合法C字符串。结论除非你在与一个必须使用char*和显式长度的老旧C接口交互并且对性能有极致要求避免一次额外的堆分配否则请毫不犹豫地使用substr()。3.3find、rfind与字符串解析实战find系列函数是字符串处理的瑞士军刀。find从前往后找rfind从后往前找。它们失败时都返回string::npos一个很大的静态常量通常是size_t的最大值。一个经典的实战案例是解析URLstd::string url “https://legacy.cplusplus.com/reference/string/string/find/”; // 1. 提取协议 (protocol) size_t protocol_end url.find(“://”); if (protocol_end ! std::string::npos) { std::string protocol url.substr(0, protocol_end); std::cout “Protocol: ” protocol std::endl; // 输出: https // 2. 提取域名 (domain) size_t domain_start protocol_end 3; // 跳过 “://” size_t path_start url.find(‘/’, domain_start); if (path_start ! std::string::npos) { std::string domain url.substr(domain_start, path_start - domain_start); std::cout “Domain: ” domain std::endl; // 输出: legacy.cplusplus.com // 3. 提取路径 (uri) std::string uri url.substr(path_start 1); std::cout “URI: ” uri std::endl; // 输出: reference/string/string/find/ } }这里的关键是find可以指定起始查找位置 (pos参数)配合substr可以非常清晰地将一个结构化字符串拆解。3.4reserve()与resize()主动管理内存避免反复“搬家”这是影响string性能最关键的两个函数但它们的职责不同。reserve(size_t n):请求改变容量capacity。它告诉string对象“我预计至少要存储n个字符请提前准备好足够的内存。” 如果n大于当前capacity它会重新分配一块至少为n的内存并将原有数据移动过去可能伴随拷贝。如果n小于等于当前capacity标准规定它可能什么都不做即reserve通常不会缩容。这是一个性能优化接口。std::string result; result.reserve(1000); // 预先分配大约1000字符的空间 for (int i 0; i 1000; i) { result “some data “; // 在循环中拼接避免了多次重新分配和拷贝 }resize(size_t n, char ch ‘\0’):改变有效长度size。如果n小于当前size则截断字符串保留前n个字符。如果n大于当前size则在末尾添加n - size个字符ch默认是\0。如果新size超过了当前capacity它也会触发重新分配。这是一个改变内容的接口。std::string s “hello”; s.resize(3); // s 变为 “hel” s.resize(8, ‘!’); // s 变为 “hel!!!!!” (size8)常见误区很多人误以为reserve后size()会改变。不会reserve只影响容量size()不变。resize才会改变size()。3.5operator与operator临时对象的陷阱operator是一个非成员函数它返回一个新的string临时对象不修改原对象。operator是成员函数直接修改原对象。std::string a “hello”, b “world”; std::string c a “ “ b; // 创建了临时对象 a “ “; // 直接修改a a b; // 直接修改a在C11之前c a b这样的表达式可能会产生多个临时对象带来拷贝开销。但现代编译器开启优化后的返回值优化RVO, NRVO已经非常强大通常能消除这些额外拷贝。但在性能敏感的循环中显式使用或append()仍然是更好的习惯因为它意图明确且直接操作原对象避免了任何临时对象产生的可能性即使被优化掉代码意图也更清晰。3.6getline与operator读取输入的差异operator以空白字符空格、制表符、换行符作为分隔符。它无法读取包含空格的整行。std::string word1, word2; std::cin word1 word2; // 输入 “hello world” word1“hello”, word2“world”std::getline(istream, string, delim)则读取整行直到遇到分隔符delim默认是换行符\n分隔符会被从流中提取但不会存入字符串。std::string line; std::getline(std::cin, line); // 输入 “hello world” line“hello world”一个经典坑点混合使用cin 和getline时cin 会在缓冲区留下一个换行符这个换行符会被紧接着的getline立刻读取到导致getline得到一个空字符串。int id; std::string name; std::cin id; // 输入 “10\n” id10 ‘\n’ 留在缓冲区 std::getline(std::cin, name); // 立刻读取到 ‘\n’ name 变为空字符串解决方法在cin 后使用cin.ignore()清除缓冲区残留的换行符。std::cin id; std::cin.ignore(std::numeric_limitsstd::streamsize::max(), ‘\n’); // 忽略直到换行符 std::getline(std::cin, name); // 现在可以正常读取了4. 从零实现一个简易String类深拷贝、移动语义与现代写法理解了原理最好的巩固方式就是动手实现。我们将实现一个简化版但包含核心思想的String类重点关注资源管理。4.1 传统写法经典的三五法则“三五法则”指的是如果一个类需要自定义析构函数、拷贝构造函数或拷贝赋值运算符那么它很可能需要全部这三个。我们的String管理着堆内存所以必须自定义。版本1基础深拷贝传统写法class String { public: String(const char* str “”) : _size(strlen(str)) { _capacity _size; _str new char[_capacity 1]; // 1 for ‘\0‘ strcpy(_str, str); } ~String() { delete[] _str; _str nullptr; _size _capacity 0; } // 拷贝构造函数深拷贝 String(const String other) : _size(other._size), _capacity(other._capacity) { _str new char[_capacity 1]; strcpy(_str, other._str); } // 拷贝赋值运算符深拷贝 String operator(const String other) { if (this ! other) { // 1. 防止自赋值 char* tmp new char[other._capacity 1]; // 2. 分配新资源 strcpy(tmp, other._str); // 3. 复制数据 delete[] _str; // 4. 释放旧资源 _str tmp; // 5. 接管新资源 _size other._size; _capacity other._capacity; } return *this; // 6. 返回自身引用 } // … 其他接口 (size, c_str, operator[]等) … private: char* _str; size_t _size; size_t _capacity; };关键点拷贝构造直接分配新内存并复制数据。拷贝赋值遵循“分配新资源 - 复制数据 - 释放旧资源 - 接管资源”的顺序。先分配新资源可以保证异常安全如果new失败抛出异常原对象状态不变。自赋值检查是必要的否则delete[] _str会把自己要拷贝的数据也删掉。为什么用strcpy在基础实现中我们假设字符串是普通的C字符串中间没有\0。但这是一个隐患。4.2 隐患与改进strcpyvsmemcpystrcpy遇到源字符串中的\0就会停止。如果我们的String要存储二进制数据如图片、序列化数据其中可能包含\0strcpy就会截断数据。char data[] {‘a’, ‘\0’, ‘b’, ‘\0’}; // 包含嵌入的 ‘\0‘ String s(data); // 使用 strcpy s 内部只会是 “a\0”丢失了后面的数据。解决方案使用memcpy。memcpy按字节拷贝指定长度的内存无视\0。// 在拷贝构造函数和赋值运算符中 memcpy(_str, other._str, other._size 1); // 拷贝 size 1 个字节确保结束符也被拷贝注意memcpy要求内存区域不重叠。如果存在重叠在string的insert等操作中可能发生应使用memmove它会正确处理重叠情况。4.3 现代写法利用“拷贝-交换” idiom传统写法代码重复较多拷贝构造和赋值运算符都要写分配和拷贝的逻辑。现代写法利用“拷贝-交换”技术让代码更简洁、更异常安全。class String { public: // … 构造函数、析构函数同前 … // 拷贝构造函数复用构造函数和swap String(const String other) : String(other._str) {} // 委托构造 // 拷贝赋值运算符传值调用 swap String operator(String other) { // 注意这里参数是值传递会调用拷贝构造 swap(other); // 交换当前对象和临时对象other的内容 return *this; // 函数结束临时对象other被销毁它现在持有的是this原来的资源自动释放。 } void swap(String other) noexcept { using std::swap; swap(_str, other._str); swap(_size, other._size); swap(_capacity, other._capacity); } // … 其他接口 … };精妙之处operator的参数是String other这是一个值传递。当执行s1 s2时会先调用拷贝构造函数创建other它是s2的一个副本。这个拷贝动作发生在进入函数体之前。在函数体内我们只需将*this和other交换。交换后*this拥有了s2的副本数据而other拥有了*this原来的数据。函数返回时局部对象other被析构顺带释放了*this原来的资源。异常安全如果拷贝构造other时失败new抛出异常赋值操作根本不会进入函数体*this的状态保持不变这是强异常安全保证。自赋值安全自赋值s1 s1时参数other是s1的拷贝交换后s1的内容和other一样最后other销毁一切正常。不需要显式的if (this ! other)检查。这种写法极度依赖一个高效且不抛异常的swap成员函数。我们实现的swap只是交换几个指针和整数非常快且安全。4.4 实现SSO小字符串优化实现一个完整的SSO比较复杂因为它需要改变类的内存布局。这里给出一个概念性的简化设计class String { private: static const size_t SSO_BUFFER_SIZE 15; // 本地缓冲区大小不含结束符 union { char _sso_buffer[SSO_BUFFER_SIZE 1]; // 本地存储 struct { char* _ptr; size_t _capacity; } _heap_data; // 堆存储信息 }; size_t _size; bool _is_sso() const { return _size SSO_BUFFER_SIZE; } public: String(const char* str “”) : _size(strlen(str)) { if (_is_sso()) { strcpy(_sso_buffer, str); } else { _heap_data._capacity _size; _heap_data._ptr new char[_heap_data._capacity 1]; strcpy(_heap_data._ptr, str); } } ~String() { if (!_is_sso()) { delete[] _heap_data._ptr; } } // 拷贝构造和赋值需要根据 _is_sso() 状态决定是拷贝缓冲区还是堆数据 // … 略 … };实际标准库的实现比这复杂得多需要考虑内存对齐、移动语义等。4.5 实现COW写时拷贝COW的实现核心是引用计数。所有共享同一份数据的String对象都指向同一个控制块。class String { private: struct ControlBlock { char* _data; size_t _size; size_t _capacity; std::atomicint _refcount; // 需要原子操作保证线程安全 ControlBlock(const char* str, size_t len) : _size(len), _capacity(len), _refcount(1) { _data new char[_capacity 1]; memcpy(_data, str, len 1); } ~ControlBlock() { delete[] _data; } void add_ref() { _refcount; } bool release() { return (--_refcount 0); } }; ControlBlock* _ctrl; public: String(const char* str “”) { size_t len strlen(str); _ctrl new ControlBlock(str, len); } // 拷贝构造浅拷贝增加引用计数 String(const String other) : _ctrl(other._ctrl) { _ctrl-add_ref(); } // 析构减少引用计数如果为0则销毁控制块 ~String() { if (_ctrl _ctrl-release()) { delete _ctrl; } } // 写时检查在修改前如果引用计数1则进行深拷贝 char operator[](size_t pos) { // 注意非const版本才需要COW if (_ctrl-_refcount 1) { // 进行深拷贝断开共享 ControlBlock* new_ctrl new ControlBlock(_ctrl-_data, _ctrl-_size); _ctrl-release(); // 减少原控制块引用 _ctrl new_ctrl; // 指向新的独立控制块 } return _ctrl-_data[pos]; } // const版本不需要COW const char operator[](size_t pos) const { return _ctrl-_data[pos]; } // 拷贝赋值需要处理自赋值和引用计数 String operator(const String other) { if (this ! other) { if (_ctrl _ctrl-release()) { delete _ctrl; } _ctrl other._ctrl; _ctrl-add_ref(); } return *this; } };COW的复杂性任何可能修改字符串内容的非const成员函数如operator[],append,都需要先进行“写时”检查Copy-On-Write Check即判断引用计数是否大于1如果是则进行深拷贝。引用计数的操作必须是原子操作如std::atomic以保证多线程安全。正因为这种复杂性以及与现代C移动语义、迭代器失效模型的一些冲突主流标准库实现已逐渐弃用COW。5. 性能优化与避坑指南基于前面的原理分析这里总结一些关键的优化技巧和常见陷阱。5.1 拼接字符串避免“Schlemiel the Painter‘s Algorithm”最著名的性能陷阱就是在循环中使用或拼接字符串而不预分配空间。// 糟糕的做法O(n^2) 时间复杂度 std::string result; for (const auto piece : pieces) { // pieces 是一个字符串vector result piece; // 每次 都可能触发重新分配和全量拷贝 }优化方法1使用reserve预分配std::string result; size_t total_len 0; for (const auto piece : pieces) { total_len piece.size(); } result.reserve(total_len); // 一次性分配足够空间 for (const auto piece : pieces) { result piece; // 现在追加操作几乎无成本 }优化方法2使用std::ostringstream#include sstream std::ostringstream oss; for (const auto piece : pieces) { oss piece; } std::string result oss.str();ostringstream内部有缓冲区能高效地处理多次追加。优化方法3对于已知数量的字符串直接使用operator// 编译器可以对连续的 进行优化 std::string result str1 “ “ str2 “ “ str3;5.2 传递字符串参数const stringvsstring_view只读参数始终使用const std::string。这是零开销的引用传递。void process(const std::string input); // 好C17及以上对于不拥有字符串所有权、且只需要读取的场合使用std::string_view。它比const string更灵活可以接受string,char*, 字符串字面量且没有构造string临时对象的开销。#include string_view void process(std::string_view sv); // 更好兼容性更强无构造开销 process(“hello”); // 直接传递字面量不会创建临时string process(char_ptr); // 传递C风格字符串 process(my_string); // 传递string对象需要修改参数根据情况使用std::string修改调用者对象或按值传递std::string获得一个副本进行修改。如果函数内部经常需要修改且可能利用移动语义按值传递有时是更好的选择即“ sink ”参数。void toUpper(std::string str); // 修改传入的字符串 std::string normalized(std::string input) { // 获得副本可以随意修改 // … 处理 input … return input; // 可能触发RVO }5.3 查找与替换注意std::string与算法库的结合algorithm头文件中的许多泛型算法如std::find,std::replace也可以用于string的迭代器。std::string s “hello world”; // 使用 std::find 查找字符 auto it std::find(s.begin(), s.end(), ‘o’); if (it ! s.end()) { /* 找到了 */ } // 使用 std::replace 替换所有 ‘l‘ 为 ‘*‘ std::replace(s.begin(), s.end(), ‘l’, ‘*’); // s 变为 “he**o wor*d”但要注意string::find查找的是子串而std::find查找的是单个元素。根据需求选择。5.4 内存释放的误区shrink_to_fit()与clear()clear(): 只将size()设为0不保证释放内存capacity()通常不变。如果你之后还会向这个string添加差不多数量的数据这是好事避免了重新分配。shrink_to_fit(): C11引入。它是一个非强制性的请求请求将capacity()减少到与size()匹配。实现可以忽略这个请求。通常在你确定一个string不会再增长且想节省内存时使用。std::string s; s.reserve(1000); s.append(“some data”); // 此时 size() 很小但 capacity() 是1000 s.shrink_to_fit(); // 请求释放多余内存 // capacity() 可能会变小但不保证等于 size()最佳实践不要频繁调用shrink_to_fit()。内存分配器通常很高效持有一些多余的内存以备后用其性能收益往往大于立即释放内存带来的微小内存节省。6. 面试常见问题深度剖析string的实现原理VS和G下有什么区别答string通常封装了一个动态增长的字符数组。VS主要采用SSO小字符串优化短字符串存储在对象内部的缓冲区长字符串存储在堆上。G旧版采用COW写时拷贝新版也转向了SSO。SSO优化了短字符串性能COW优化了拷贝性能但带来复杂性和线程安全问题。深拷贝和浅拷贝的区别string的拷贝构造函数是深拷贝还是浅拷贝答浅拷贝只复制指针使多个对象共享同一资源深拷贝复制资源本身每个对象拥有独立副本。std::string的拷贝构造是深拷贝这是为了保证对象的独立性符合值语义。string的c_str()和data()返回的指针在什么情况下会失效答在对该string对象进行任何非 const 成员函数调用可能引发重新分配如append,operator,reserve,resize增大等之后之前返回的指针就会失效。将其保存下来后续使用是未定义行为。string的reserve和resize有什么区别答reserve(n)只影响容量capacity为至少n个字符预留空间不改变内容或大小size。resize(n, ch)改变大小size如果n size()则用ch填充新增部分如果n size()则截断必要时也会改变容量。如何高效地拼接多个string答首先估算最终字符串的大致长度使用reserve()预分配空间然后在循环中使用或append()。或者使用std::ostringstream。避免在循环中直接使用连接因为它会产生临时对象。实现一个简单的String类需要注意哪些问题答需要遵循三五法则实现深拷贝的拷贝构造和拷贝赋值或使用拷贝-交换技法。注意处理\0字符用memcpy而非strcpy。考虑自赋值安全。提供必要的接口如c_str(),size(),operator[]等。在拷贝赋值运算符中要先分配新内存再释放旧内存以保证异常安全。理解std::string远不止于记住几个API。从它精巧的内存布局设计SSO/COW到每个接口背后的性能考量再到自己动手实现时对资源管理、异常安全的深刻体会这个过程是C程序员从“会用”到“懂行”的关键一步。下次当你写下std::string时希望你脑海中能浮现出它内部的联合体、引用计数或是动态数组从而写出更高效、更健壮的代码。