C++ String类实现：从零构建理解内存管理与STL核心机制

1. 项目概述：为什么我们要亲手实现一个String类？

在C++的世界里，std::string几乎是每个开发者最熟悉的老朋友。从控制台输出到文件处理，从网络通信到算法实现，它无处不在。你可能已经熟练地使用它的find、substr、+=等接口，觉得它理所当然地应该在那里。但有没有那么一刻，你好奇过这个“老朋友”内部究竟是如何工作的？当你在面试中被问到“请简述String类的实现原理”时，是否感到一丝心虚？

这就是我们动手模拟实现一个String类的全部意义。这绝不是一个“造轮子”的无效练习，而是一次深入C++核心的“外科手术”。通过亲手构建一个从零开始的MyString类，你将彻底理解：

1. 资源管理的艺术：动态内存的申请与释放，拷贝控制（三/五法则）如何避免内存泄漏和悬垂指针。
2. 接口设计的权衡：为什么size()和length()同时存在？c_str()返回的是什么？operator[]的常量版本和非常量版本有何区别？
3. 性能优化的细节：短字符串优化（SSO）是什么？移动语义（C++11）如何大幅提升性能？reserve()和resize()对效率的影响。

无论你是正在准备技术面试，希望夯实C++基础的中级开发者，还是对STL内部机制充满好奇的学习者，这次实现之旅都将让你对C++的理解提升一个维度。我们将从一块 raw memory 开始，一步步构建出一个功能完整、健壮的字符串类，并在此过程中，直面那些教科书里一笔带过，但实际编码中频频出现的“坑”。

2. 整体设计与核心思路拆解

在动手写第一行代码之前，我们必须想清楚这个MyString类的蓝图。一个现代的、工业级的字符串类设计非常复杂（参考std::string的源码），但我们的教学版本需要抓住主干，聚焦最核心的机制。

2.1 数据成员与内存管理策略

首先，我们的类需要存储字符序列。最直接的方案是使用一个char*指针指向堆上动态分配的内存。

class MyString { private: char* _data; // 指向存储字符串的堆内存 size_t _size; // 当前字符串的实际长度（不包含结尾的'\0'） size_t _capacity; // 当前分配的内存总大小（通常 >= _size + 1） };

这里引入了_capacity的概念，这是实现高效内存管理的关键。想象一下，如果你每次给字符串追加一个字符（push_back）都重新分配一块新内存，性能将是灾难性的。_capacity允许我们进行容量预分配，当_size即将超过_capacity时，我们一次性分配一块更大的内存（通常是原容量的1.5或2倍），将旧数据拷贝过去，然后释放旧内存。这个过程称为“扩容”。

注意：_size不包含结尾的空字符\0，但_capacity必须至少为_size + 1，以便为\0预留空间。这是为了兼容C风格的字符串函数（如strlen,strcpy）。

2.2 至关重要的“三/五法则”

C++中，如果一个类管理了动态资源（这里是_data指向的堆内存），那么编译器默认生成的拷贝构造函数、拷贝赋值运算符和析构函数很可能是不正确的，会导致浅拷贝问题。

• 浅拷贝：只复制指针的值，两个对象的_data指向同一块内存。当一个对象被销毁释放内存后，另一个对象的_data就变成了悬垂指针，再次访问或释放会导致未定义行为（通常是程序崩溃）。
• 深拷贝：复制指针所指向的内容。为新对象分配一块新内存，并将原字符串数据完整地拷贝过来。这样两个对象完全独立。

因此，我们必须手动实现“三法则”（C++98/03）或“五法则”（C++11及以后）：

1. 析构函数（~MyString）：负责释放_data指向的动态内存。
2. 拷贝构造函数（MyString(const MyString&)）：实现深拷贝，用于初始化一个新对象。
3. 拷贝赋值运算符（operator=）：同样实现深拷贝，并处理自赋值（str = str）的情况。
4. 移动构造函数（MyString(MyString&&)）（C++11+）：用于“窃取”临时对象（右值）的资源，避免不必要的深拷贝，提升性能。
5. 移动赋值运算符（operator=）（C++11+）：同理。

我们的实现将涵盖这五个函数，这是构建一个健壮资源管理类的基石。

2.3 接口设计哲学

我们将模拟std::string最常用的一部分接口，分为几个核心类别：

• 构造与析构：默认构造、C字符串构造、拷贝构造、移动构造等。
• 容量操作：size,capacity,empty,reserve,resize。
• 元素访问：operator[]（const 和 non-const 版本）、at、front、back、c_str、data。
• 修改操作：append、push_back、operator+=、insert、erase、clear。
• 字符串操作：find、substr、compare。
• 迭代器支持：简单的begin()和end()，以支持范围for循环。

我们将按照从内到外、从基础到复杂的顺序来实现它们。

3. 基础架构与资源管理实现

让我们从类的骨架和最重要的资源管理函数开始。

3.1 类定义与私有辅助函数

首先定义类，并声明一些私有辅助函数，它们将简化我们后续的实现。

#include <cstring> // for strlen, strcpy, memcpy #include <algorithm> // for std::swap (C++11), 或自己实现 #include <stdexcept> // for std::out_of_range class MyString { public: // 类型别名，与STL风格保持一致 using iterator = char*; using const_iterator = const char*; // ---------- 构造函数族 ---------- MyString(); // 默认构造 MyString(const char* str); // 从C字符串构造 MyString(const MyString& other); // 拷贝构造 MyString(MyString&& other) noexcept; // 移动构造 (C++11) // ---------- 析构函数 ---------- ~MyString(); // ---------- 赋值运算符 ---------- MyString& operator=(const MyString& other); // 拷贝赋值 MyString& operator=(MyString&& other) noexcept; // 移动赋值 (C++11) // ... 其他公共接口将在后续章节添加 private: char* _data; size_t _size; size_t _capacity; // 私有辅助函数 void _reallocate(size_t new_capacity); // 重新分配内存 void _free(); // 释放内存并重置状态 void _copy_from(const char* str, size_t len); // 从指定字符串拷贝数据 };

3.2 内存管理核心：_reallocate与_free

在实现构造函数之前，我们先搞定这两个底层帮手。

// 释放当前内存，并将成员置为初始状态 void MyString::_free() { if (_data) { delete[] _data; // 匹配 new char[] _data = nullptr; } _size = 0; _capacity = 0; } // 分配至少能容纳 new_capacity 个字符（包括结尾的\0）的新内存。 // 如果 new_capacity <= _capacity，则什么都不做（不缩容）。 void MyString::_reallocate(size_t new_capacity) { if (new_capacity <= _capacity) { return; } // 实际分配时，多分配一个字节给结尾的 '\0' char* new_block = new char[new_capacity + 1]; if (_data) { // 将旧数据拷贝到新内存，包括结尾的 \0 // memcpy 比 strcpy 更安全，因为我们明确知道长度 std::memcpy(new_block, _data, _size + 1); delete[] _data; // 释放旧内存 } _data = new_block; _capacity = new_capacity; // 注意：_size 不变，新分配的内存后半部分是未初始化的。 }

实操心得：这里使用memcpy而不是strcpy是更优的选择。因为strcpy需要遍历源字符串直到遇到\0，而我们已知长度_size，memcpy直接按字节拷贝，效率更高。同时，我们拷贝了_size + 1个字节，确保了结尾的\0也被正确复制。

3.3 构造与析构函数的实现

有了辅助函数，构造函数就清晰多了。

// 默认构造函数：创建一个空字符串 MyString::MyString() : _data(nullptr), _size(0), _capacity(0) { // 为 _data 分配一个最小空间（例如16字节）并放入空字符串，也是常见实现（SSO的简化）。 // 这里我们采用更简单的“惰性分配”，第一次添加字符时再分配。 // 但为了 c_str() 安全返回空指针，我们分配一个只包含\0的最小块。 _reallocate(0); // 这实际上会分配1个字节（0+1） _data[0] = '\0'; } // 从C风格字符串构造 MyString::MyString(const char* str) : _data(nullptr), _size(0), _capacity(0) { if (str == nullptr) { // 处理空指针输入，将其视为空字符串 _reallocate(0); _data[0] = '\0'; return; } size_t len = std::strlen(str); _copy_from(str, len); } // 拷贝构造函数（深拷贝） MyString::MyString(const MyString& other) : _data(nullptr), _size(other._size), _capacity(other._capacity) { if (other._data) { _data = new char[_capacity + 1]; std::memcpy(_data, other._data, _size + 1); } else { _reallocate(0); _data[0] = '\0'; } } // 移动构造函数（C++11）: “窃取”资源，将源对象置于有效但未定义的状态 MyString::MyString(MyString&& other) noexcept : _data(other._data), _size(other._size), _capacity(other._capacity) { // 将源对象的指针置空，使其析构时不会释放我们刚“偷”走的内存 other._data = nullptr; other._size = 0; other._capacity = 0; } // 析构函数 MyString::~MyString() { _free(); }

_copy_from辅助函数的实现：

void MyString::_copy_from(const char* str, size_t len) { // 确保有足够空间（len个字符 + 1个\0） _reallocate(len); _size = len; std::memcpy(_data, str, len); // 拷贝字符串内容 _data[_size] = '\0'; // 手动添加结尾空字符 }

3.4 赋值运算符的实现

赋值运算符比构造函数复杂一点，因为它需要处理自赋值和清理原有资源。

// 拷贝赋值运算符 MyString& MyString::operator=(const MyString& other) { // 1. 防止自赋值： if (this == &other) return *this; if (this != &other) { // 2. 释放当前对象的资源 _free(); // 3. 深拷贝对方资源 _size = other._size; _capacity = other._capacity; if (other._data) { _data = new char[_capacity + 1]; std::memcpy(_data, other._data, _size + 1); } else { _reallocate(0); _data[0] = '\0'; } } return *this; // 4. 返回本对象的引用以支持链式赋值 } // 移动赋值运算符 (C++11) MyString& MyString::operator=(MyString&& other) noexcept { // 同样需要防止自赋值（虽然移动自赋值不常见） if (this != &other) { _free(); // 释放自身旧资源 // 直接接管对方资源 _data = other._data; _size = other._size; _capacity = other._capacity; // 置空对方，使其处于可安全析构的状态 other._data = nullptr; other._size = 0; other._capacity = 0; } return *this; }

关键点解析：拷贝赋值运算符的“拷贝并交换”（copy-and-swap） idiom 是更优雅和异常安全的实现方式，但为了清晰理解每一步，我们采用了上述传统写法。移动赋值运算符通常标记为noexcept，这有助于标准库容器（如std::vector）在扩容时使用移动而非拷贝，从而提升性能。

至此，我们完成了MyString类最核心、也最容易出错的部分——资源管理。接下来，我们将在此基础上搭建丰富的功能接口。

4. 容量与元素访问接口实现

有了稳定的内存管理基础，我们可以开始实现那些最常被调用的查询和访问接口。

4.1 容量查询接口

这些接口通常很简单，直接返回成员变量或进行简单判断。

// 在类定义中添加声明 public: size_t size() const { return _size; } size_t length() const { return _size; } // 与size()一致，仅为兼容习惯 size_t capacity() const { return _capacity; } bool empty() const { return _size == 0; }

为什么同时有 size() 和 length()？这是历史原因。size()是STL容器的通用接口，而length()是为了符合字符串的直观概念。在std::string中，它们是完全等价的，我们这里也遵循这一约定。

4.2 元素访问接口

访问字符串中的单个字符，需要提供常量版本和非常量版本，并且要考虑边界安全。

public: // 非常量版本，允许修改 char& operator[](size_t pos) { // 通常不进行边界检查，以追求最高性能（与std::string行为一致） // 但在调试阶段，可以加入断言 assert(pos < _size); return _data[pos]; } // 常量版本，用于const对象 const char& operator[](size_t pos) const { return _data[pos]; } // 带边界检查的访问，越界时抛出异常 char& at(size_t pos) { if (pos >= _size) { throw std::out_of_range("MyString::at: pos out of range"); } return _data[pos]; } const char& at(size_t pos) const { if (pos >= _size) { throw std::out_of_range("MyString::at: pos out of range"); } return _data[pos]; } // 访问首尾字符 char& front() { return _data[0]; } const char& front() const { return _data[0]; } char& back() { return _data[_size - 1]; } const char& back() const { return _data[_size - 1]; } // 获取C风格字符串指针 const char* c_str() const { return _data ? _data : ""; } const char* data() const { return _data ? _data : ""; } // C++17前，data()返回的也不保证以\0结尾，但我们这里简单实现为与c_str相同。

注意事项：

1. operator[]不进行边界检查是基于性能的权衡。调用者应确保索引有效。at()提供了安全的替代方案，但会有轻微的性能开销。
2. 当_data为nullptr时（例如默认构造后未分配），c_str()和data()返回一个指向空字符串字面量的指针，这是一个常见且安全的做法，避免了返回空指针导致调用者崩溃。
3. 在C++17之后，data()返回的指针也保证以\0结尾，与c_str()相同。我们的简单实现遵循了这一点。

4.3 容量修改接口：reserve与resize

这两个函数是高效管理字符串内存的关键。

public: // 增加容量（至少为 new_cap），但不改变字符串内容。 // 如果 new_cap <= _capacity，则什么都不做（标准行为，不缩容）。 void reserve(size_t new_cap) { _reallocate(new_cap); } // 改变字符串大小，并可能改变容量。 // 如果 new_size > _size，则多出的部分用字符 ch 填充。 // 如果 new_size < _size，则截断字符串。 void resize(size_t new_size, char ch = '\0') { if (new_size > _size) { // 需要扩容 reserve(new_size); // 注意：reserve的参数是容量，不是大小。这里简化处理，实际std::string的resize可能更智能。 // 填充新字符 for (size_t i = _size; i < new_size; ++i) { _data[i] = ch; } _size = new_size; _data[_size] = '\0'; // 设置新结尾 } else if (new_size < _size) { // 截断 _size = new_size; _data[_size] = '\0'; // 直接在原位置写入\0即可 } // 如果 new_size == _size，什么都不做 }

踩坑记录：reserve和resize非常容易混淆。

• reserve(n)：只影响容量(_capacity)。它保证之后至少可以添加n个字符而无需重新分配。它不改变字符串内容或大小(_size)。这是一个性能优化提示。
• resize(n, ch)：直接改变大小(_size)。如果n > _size，则扩展并用ch填充；如果n < _size，则截断。它可能隐式地改变容量（如果需要扩容）。这是为了改变字符串的逻辑长度。

一个典型的使用场景是：如果你知道要拼接一个很长的字符串，可以先reserve(足够大的值)来避免多次扩容，然后再进行append或operator+=操作。

5. 字符串修改与操作接口实现

这是字符串类的“肌肉”部分，实现了添加、插入、删除等动态修改功能。

5.1 追加与拼接操作

我们先实现一个基础的append，其他操作可以基于它或类似逻辑实现。

public: // 追加一个C风格字符串 MyString& append(const char* str) { if (str == nullptr) return *this; size_t len = std::strlen(str); if (len == 0) return *this; // 检查是否需要扩容 if (_size + len > _capacity) { // 常见的增长因子：2倍或1.5倍。这里使用 new_size * 2 的策略。 size_t new_cap = std::max(_size + len, _capacity * 2); _reallocate(new_cap); } // 追加数据 std::memcpy(_data + _size, str, len); _size += len; _data[_size] = '\0'; return *this; } // 追加另一个MyString对象 MyString& append(const MyString& str) { return append(str.c_str()); // 复用上面的实现 } // 追加 count 个字符 ch MyString& append(size_t count, char ch) { if (count == 0) return *this; if (_size + count > _capacity) { size_t new_cap = std::max(_size + count, _capacity * 2); _reallocate(new_cap); } std::memset(_data + _size, ch, count); _size += count; _data[_size] = '\0'; return *this; } // 重载 += 运算符，提供更直观的拼接语法 MyString& operator+=(const char* str) { return append(str); } MyString& operator+=(const MyString& str) { return append(str); } MyString& operator+=(char ch) { return append(1, ch); } // 在末尾添加一个字符 void push_back(char ch) { append(1, ch); // 直接复用append // 更高效的实现可以内联检查扩容，这里为清晰起见复用代码。 }

5.2 插入与删除操作

insert和erase是更复杂的修改操作，因为它们涉及内存的移动。

public: // 在指定位置 pos 前插入字符串 str MyString& insert(size_t pos, const char* str) { if (pos > _size) { // pos等于_size时，相当于在末尾append throw std::out_of_range("MyString::insert: pos out of range"); } if (str == nullptr) return *this; size_t len = std::strlen(str); if (len == 0) return *this; // 1. 确保容量足够 if (_size + len > _capacity) { size_t new_cap = std::max(_size + len, _capacity * 2); _reallocate(new_cap); } // 2. 将 pos 之后的原有数据向后移动 len 个位置 // memmove 可以处理内存重叠区域，比 memcpy 更安全 std::memmove(_data + pos + len, _data + pos, _size - pos); // 3. 将新字符串拷贝到 pos 处 std::memcpy(_data + pos, str, len); // 4. 更新大小和结尾 _size += len; _data[_size] = '\0'; return *this; } // 删除从 pos 开始的 count 个字符 MyString& erase(size_t pos = 0, size_t count = npos) { if (pos >= _size) return *this; // 标准库行为：如果pos>=size，则无效果 // 处理 count 为 npos 或过长的情况 size_t actual_count = count; if (count == npos || pos + count > _size) { actual_count = _size - pos; } // 将 pos+actual_count 之后的数据向前移动 std::memmove(_data + pos, _data + pos + actual_count, _size - (pos + actual_count) + 1); // +1 是为了移动结尾的\0 _size -= actual_count; return *this; } // 清空字符串内容，但不释放内存（或释放到初始状态） void clear() { _size = 0; if (_data) { _data[0] = '\0'; } // 注意：标准库的 clear() 不改变 capacity()。如果想释放内存，可以调用 shrink_to_fit()（我们未实现）。 } private: static const size_t npos = -1; // 模仿 std::string::npos

核心技巧：在insert和erase中，当需要移动内存块时，务必使用std::memmove而不是std::memcpy。因为源内存和目标内存可能存在重叠（例如，在字符串中间插入或删除），memcpy对于重叠区域的行为是未定义的，而memmove会正确处理这种情况。

5.3 子串与查找操作

public: // 返回从 pos 开始，长度为 count 的子串 MyString substr(size_t pos = 0, size_t count = npos) const { if (pos >= _size) { throw std::out_of_range("MyString::substr: pos out of range"); } size_t actual_count = count; if (count == npos || pos + count > _size) { actual_count = _size - pos; } // 构造一个临时 MyString 对象 MyString result; result.reserve(actual_count); std::memcpy(result._data, _data + pos, actual_count); result._size = actual_count; result._data[actual_count] = '\0'; return result; // 依赖移动语义（如果支持）或NRVO优化，避免拷贝开销 } // 查找字符 ch 第一次出现的位置，从 pos 开始 size_t find(char ch, size_t pos = 0) const { if (pos >= _size) return npos; for (size_t i = pos; i < _size; ++i) { if (_data[i] == ch) { return i; } } return npos; } // 查找子串 str 第一次出现的位置（简易版，未使用KMP等高效算法） size_t find(const char* str, size_t pos = 0) const { if (pos >= _size || str == nullptr) return npos; size_t str_len = std::strlen(str); if (str_len == 0) return pos; // 空串总是被找到 if (str_len > _size - pos) return npos; // 朴素字符串匹配算法 for (size_t i = pos; i <= _size - str_len; ++i) { bool found = true; for (size_t j = 0; j < str_len; ++j) { if (_data[i + j] != str[j]) { found = false; break; } } if (found) { return i; } } return npos; }

6. 迭代器与非成员函数

为了让我们的MyString更好地融入C++生态系统（比如支持范围for循环，以及一些标准库算法），我们需要提供迭代器。

6.1 迭代器实现

对于这种底层是连续内存的容器，迭代器就是指针的别名，实现起来非常简单。

public: // 迭代器类型已在类定义开头 using iterator begin() { return _data; } const_iterator begin() const { return _data; } const_iterator cbegin() const { return _data; } iterator end() { return _data + _size; } const_iterator end() const { return _data + _size; } const_iterator cend() const { return _data + _size; }

现在，你可以这样使用：

MyString str = "Hello"; for (char& c : str) { // 范围for循环 c = std::toupper(c); } std::sort(str.begin(), str.end()); // 使用标准库算法

6.2 流操作符重载

为了方便输入输出，我们重载<<和>>运算符。

#include <iostream> #include <istream> // 输出运算符 std::ostream& operator<<(std::ostream& os, const MyString& str) { if (str.c_str()) { os << str.c_str(); } return os; } // 输入运算符（简易版，读取到空白字符为止） std::istream& operator>>(std::istream& is, MyString& str) { str.clear(); // 先清空目标字符串 char ch; // 跳过开头的空白字符 while (is.get(ch) && std::isspace(ch)) {} if (!is) return is; // 读取失败 // 将第一个非空白字符放回流中（或者我们自己保存） is.unget(); // 或者我们直接使用它： // str.push_back(ch); // 但更简单的方式是使用 >> 到 char*，这里我们手动循环 while (is.get(ch) && !std::isspace(ch)) { str.push_back(ch); } return is; }

注意：这个operator>>实现是简化版，标准的std::string输入处理更复杂，涉及流的状态、宽度设置等。但对于大多数情况，这个版本已经够用。

7. 常见问题、调试技巧与性能考量

在实现和使用自定义字符串类的过程中，你会遇到各种问题。这里记录一些典型的“坑”和优化思路。

7.1 内存问题排查

1. 内存泄漏：确保每个new[]都有对应的delete[]。重点检查所有构造函数（特别是拷贝构造）和赋值运算符中，在分配新内存前是否正确释放了旧内存。使用 Valgrind 或 AddressSanitizer 等工具进行检测。
2. 悬垂指针/野指针：在移动操作后，务必将源对象的指针置为nullptr，防止其析构函数释放已被转移的内存。同样，在_free()函数中，释放内存后也立即将_data置nullptr。
3. 缓冲区溢出：任何修改_data内容的操作（如append,insert,operator[]赋值），都必须确保写入位置在[0, _capacity)范围内，并且对于字符串操作，永远不要忘记在最后写入\0。at()函数提供了安全的边界检查。

7.2 关于“三/五法则”的常见错误

• 忘记处理自赋值：在拷贝赋值运算符中，if (this == &other) return *this;这行代码至关重要。没有它，str = str这样的操作会先释放自身内存，然后试图从已释放的内存中拷贝数据，导致未定义行为。
• 异常安全：更高级的实现会考虑“拷贝并交换”技法，它提供了强烈的异常安全保证。我们的实现是基本安全（在new失败抛出异常时，对象状态不变），但“拷贝并交换”通常更优。

7.3 性能优化点

1. 扩容策略：我们使用了简单的_capacity * 2策略。std::string的实现通常更复杂，可能会考虑一个较小的初始容量（如15），然后按固定大小或因子增长。频繁扩容（尤其是大量小字符串拼接）是性能瓶颈。在已知最终大小的情况下，优先使用reserve()。
2. 短字符串优化（SSO）：这是现代std::string实现中最重要的优化之一。对于很短的字符串（例如15或22个字符以内），直接将其存储在对象自身的栈内存中，而不是堆上。这避免了动态内存分配的开销，对小字符串操作性能提升巨大。我们的实现没有包含SSO，但了解其原理非常重要：它通常通过一个union来区分“短字符串模式”和“长字符串模式”。
3. 移动语义：我们实现了移动构造和移动赋值。确保在函数返回局部MyString对象、作为参数传递临时对象时，编译器能使用移动而非拷贝，这能显著提升性能。
4. reserve的误用：reserve只会增加或保持容量，不会减少。如果你需要将容量缩减到刚好适合当前字符串大小，标准库提供了shrink_to_fit()请求（注意，这是一个非强制性的请求）。我们的简单实现可以添加一个类似的函数。

7.4 测试你的实现

编写全面的测试用例是验证实现正确性的关键。至少应该测试：

• 默认构造、C字符串构造、拷贝构造。
• 基本操作：append,+=,insert,erase。
• 边界情况：空字符串、自赋值、查找不存在的子串（返回npos）。
• 内存安全：在Valgrind下运行，确保无内存泄漏和非法访问。
• 迭代器有效性：修改字符串后，之前获取的迭代器是否失效（对于我们的实现，任何可能引起_reallocate的操作都会使所有迭代器、指针、引用失效）。

亲手实现一个完整的MyString类是一次极具价值的练习。它强迫你直面C++中资源管理、接口设计、异常安全和性能权衡的核心问题。虽然我们的实现距离std::string的工业强度还有差距（缺少SSO、更复杂的分配器支持、更完善的异常安全等），但核心骨架和思想已经具备。理解了这个过程，你再去看std::string的文档甚至源码，就会有一种豁然开朗的感觉。下次面试官再问你字符串相关的底层原理，你就能从容地告诉他，你是如何从零开始构建它的。