C++字符串转换终极指南：掌握20种核心技巧，避免常见错误


参考资源链接：[C++中string, CString, char*相互转换方法](https://wenku.csdn.net/doc/790uhkp7d4?spm=1055.2635.3001.10343)
# 1. C++字符串转换基础概览

C++作为一种强类型语言，字符串与数值之间的转换是日常编程任务中的常见需求。本章我们将介绍字符串转换的基础概念，为后续章节的深入探讨奠定基础。

## 1.1 字符串与数值类型的区别

在C++中，字符串通常以`std::string`类型表示，而数值类型则包括基本的整型（`int`、`long`等）和浮点型（`float`、`double`等）。它们在内存中的存储和表示方式有着本质的不同。

## 1.2 字符串转换的场景与需求

理解转换的实际应用场景至关重要。例如，从文件读取的文本可能需要解析为数值进行计算；而计算结果则需要转换回字符串以供用户界面展示。

## 1.3 字符串转换的重要性

错误的字符串转换可能会导致程序运行异常或数据错误。因此，掌握正确且高效的转换方法是保证程序质量和性能的关键步骤。

通过对本章的阅读，读者将对C++中字符串转换的初步概念有所了解，并准备好进入更深入的转换工具和技巧的学习。

# 2. C++标准库中的字符串转换工具

在C++编程中，字符串和各种数据类型之间的转换是一个常见的需求。标准库提供了多种工具和函数来实现这些转换，这些工具不仅方便使用，而且在很多情况下能够保证转换的正确性和效率。本章节将详细探讨C++标准库中的字符串转换工具及其使用技巧。

## 2.1 使用std::stringstream进行转换

### 2.1.1 std::stringstream的基本使用

`std::stringstream`是C++标准库中一个功能强大的I/O流类，它允许字符串、基本数据类型和复杂的自定义类型之间的灵活转换。`std::stringstream`类似于文件流，但是它的输入和输出是通过内存中的字符串来完成的。

下面是一个使用`std::stringstream`进行基本类型转换的示例代码：

#include <sstream>
#include <string>

int main() {
    std::stringstream ss;
    std::string input = "123";
    int number;

    ss << input;          // 将字符串存入stringstream
    ss >> number;         // 将stringstream中的内容转换为整数

    // 输出转换结果
    std::cout << "The integer value is: " << number << std::endl;

    return 0;
}

在这段代码中，首先创建了一个`std::stringstream`对象`ss`，然后将一个字符串`input`输入到`ss`中。之后，使用`>>`操作符从`ss`中提取出一个整数`number`。在实际应用中，你可以根据需要输出转换后的整数。

### 2.1.2 格式化字符串的高级技巧

`std::stringstream`不仅可以用于基本类型的转换，它还支持格式化转换。格式化字符串时，你可以指定输出格式，使得转换结果满足特定的格式要求。例如，对于整数和浮点数，你可以指定输出时的宽度、精度和填充字符。

下面是一个格式化转换的示例代码：

#include <sstream>
#include <iostream>
#include <iomanip>

int main() {
    std::stringstream ss;

    // 格式化整数
    int num = 42;
    ss << std::setw(10) << std::setfill('0') << num;
    std::cout << ss.str() << std::endl; // 输出: "0000000042"

    ss.clear();
    ss.str("");

    // 格式化浮点数
    double dnum = 3.14159;
    ss << std::fixed << std::setprecision(2) << dnum;
    std::cout << ss.str() << std::endl; // 输出: "3.14"

    return 0;
}

在这段代码中，我们使用了几个函数来格式化输出：`std::setw`设置了输出宽度，`std::setfill`设置了填充字符，`std::fixed`指定了浮点数的固定点表示法，而`std::setprecision`设定了浮点数输出的精度。通过这些操作，可以灵活地控制输出格式，以适应不同的应用场景。

## 2.2 标准库中的字符串与其他类型的转换

### 2.2.1 std::stoi, std::stol, std::stoll等函数的使用

C++11标准引入了`std::stoi`, `std::stol`, `std::stoll`等函数，它们可以将字符串转换为整数类型，其中`std::stoi`用于将字符串转换为`int`，`std::stol`用于`long`，而`std::stoll`用于`long long`。

这里是一个使用这些函数的示例：

#include <string>
#include <iostream>

int main() {
    std::string strNumber = "12345";
    try {
        int num = std::stoi(strNumber);
        std::cout << "The integer is: " << num << std::endl;

        long long llnum = std::stoll(strNumber);
        std::cout << "The long long integer is: " << llnum << std::endl;
    } catch (const std::invalid_argument& ia) {
        std::cerr << "Invalid argument: " << ia.what() << '\n';
    } catch (const std::out_of_range& oor) {
        std::cerr << "Out of range: " << oor.what() << '\n';
    }

    return 0;
}

在这段代码中，我们首先尝试将字符串`strNumber`转换为`int`类型，然后转换为`long long`类型。注意，这两个转换都有可能抛出异常，分别是`std::invalid_argument`和`std::out_of_range`，这些异常需要在调用转换函数时被捕获处理。

### 2.2.2 std::to_string和其他转换函数的使用

C++11同样引入了`std::to_string`函数，它能够将数值类型的变量转换为`std::string`类型。另外，`std::to_wstring`函数用于转换为宽字符串（`std::wstring`）。

下面是一个使用这些函数的示例：

#include <string>
#include <iostream>

int main() {
    int num = 123;
    std::string str = std::to_string(num);

    std::cout << "The number as string is: " << str << std::endl;

    long long llnum = 1234567890123456789LL;
    std::wstring wstr = std::to_wstring(llnum);

    std::wcout << L"The long long number as wstring is: " << wstr << std::endl;

    return 0;
}

在这段代码中，我们使用`std::to_string`将整数`num`转换成字符串`str`，然后输出。同样的，我们使用`std::to_wstring`将长整型数值`llnum`转换成宽字符串`wstr`，然后通过宽字符流`std::wcout`输出。

在这个章节中，我们深入探讨了C++标准库中字符串转换工具的使用方法和技巧，这为实现字符串和各种数据类型之间的高效转换提供了坚实的基础。通过本章节的介绍，你应当能够掌握`std::stringstream`的基本和高级使用方法，以及`std::stoi`, `std::stol`, `std::stoll`和`std::to_string`函数的正确使用方式，为字符串与数值类型之间的转换工作提供了便利。

# 3. C++中的字符串到数值的转换实践

## 3.1 避免字符串转换为数值时的常见错误

字符串到数值的转换在C++中是一个常见的操作，但是它也伴随着一些潜在的问题。本小节将探索在字符串转换为数值时遇到的错误以及如何解决这些问题。

### 3.1.1 输入异常与异常处理

在进行字符串到数值的转换时，可能会遇到各种形式的异常输入，例如包含非数字字符的字符串、空字符串或者超出数值类型范围的值。处理这些异常情况是至关重要的，否则可能会导致程序崩溃或运行结果不稳定。

示例代码段如下：

#include <iostream>
#include <string>
#include <stdexcept>

int main() {
    std::string numStr = "123a";
    try {
        int num = std::stoi(numStr);
        std::cout << "转换成功: " << num << std::endl;
    } catch (const std::invalid_argument& ia) {
        std::cout << "输入异常: " << ia.what() << std::endl;
    } catch (const std::out_of_range& oor) {
        std::cout << "数值超出范围: " << oor.what() << std::endl;
    }
    return 0;
}

在上述代码中，`std::stoi`函数用于将字符串转换为整数，它可能会抛出`std::invalid_argument`异常（输入字符串无法转换为数值时），或者`std::out_of_range`异常（字符串表示的数值超出了目标类型的范围）。通过捕获这些异常，程序能够优雅地处理错误输入，给出相应的提示信息。

### 3.1.2 解决前导空格和非法字符问题

字符串中的前导空格和非法字符是转换操作中的常见问题。`std::stoi`和相关函数可以跳过字符串开头的空格，但遇到非法字符时会抛出异常。为了避免这种异常，需要在转换之前对字符串进行清洗。

下面是一个处理前导空格和非法字符的示例：

#include <iostream>
#include <string>
#include <sstream>

int main() {
    std::string numStr = "   123a";
    std::string cleanStr;
    // 移除前导空格
    auto it = std::find_if(numStr.begin(), numStr.end(),
                           [](char c) { return !std::isspace(c); });
    cleanStr = std::string(it, numStr.end());
    // 移除末尾空格
    it = std::find_if(cleanStr.rbegin(), cleanStr.rend(),
                      [](char c) { return !std::isspace(c); }).base();
    cleanStr = std::string(numStr.begin(), it);
    // 转换操作
    try {
        int num = std::stoi(cleanStr);
        std::cout << "转换成功: " << num << std::endl;
    } catch (const std::invalid_argument& ia) {
        std::cout << "输入异常: " << ia.what() << std::endl;
    } catch (const std::out_of_range& oor) {
        std::cout << "数值超出范围: " << oor.what() << std::endl;
    }
    return 0;
}

上述代码首先使用`std::find_if`和`std::isspace`函数移除字符串`numStr`前后的空格，然后再尝试进行转换。通过这种方式，可以有效地避免因空格导致的转换失败。

## 3.2 利用数值类型进行高效的转换

C++提供了多种高效的数值类型转换方式，包括使用构造函数、以及数值运算等。正确地使用这些方法不仅能够提升程序性能，还能保证转换的准确性和稳定性。

### 3.2.1 利用数值类的构造函数进行转换

大多数C++数值类型都提供了能够接受字符串参数的构造函数。这可以用于直接从字符串创建数值类型对象。

示例代码如下：

#include <iostream>
#include <string>

int main() {
    std::string numStr = "123";
    int num = std::stoi(numStr);
    long long bigNum = std::stoll(numStr);
    float fnum = std::stof(numStr);
    double dnum = std::stod(numStr);
    std::cout << "整数: " << num << std::endl;
    std::cout << "长整数: " << bigNum << std::endl;
    std::cout << "浮点数: " << fnum << std::endl;
    std::cout << "双精度浮点数: " << dnum << std::endl;

    return 0;
}

在上述代码中，`std::stoi`、`std::stoll`、`std::stof`和`std::stod`都是使用字符串构造函数的方式将字符串转换为对应的数值类型。这些构造函数在内部进行了详细的边界检查和格式化处理，保证了转换的准确性。

### 3.2.2 使用数值运算处理溢出和边界问题

当从字符串转换为数值类型时，还可能遇到溢出问题。如果字符串表示的数值超出了目标数值类型的范围，将会发生溢出。在某些情况下，直接使用数值运算进行转换是处理溢出和边界问题的一个有效方法。

考虑以下例子：

#include <iostream>
#include <string>
#include <limits>

int main() {
    std::string numStr = "10000000000";
    unsigned long long bigNum = std::stoull(numStr);
    // 如果使用了有符号整型，这里会溢出
    if (bigNum > std::numeric_limits<int>::max()) {
        std::cout << "数值溢出，无法转换为int类型" << std::endl;
    } else {
        int num = static_cast<int>(bigNum);
        std::cout << "转换成功: " << num << std::endl;
    }
    return 0;
}

在上面的代码中，尝试将一个大数值字符串转换为`unsigned long long`类型，然后检查是否能够安全转换为`int`类型。如果数值太大，超出了`int`类型的范围，那么将会输出溢出信息。通过显式检查，可以避免意外的溢出行为。

这一节通过异常处理、字符串清洗以及数值运算的策略，提供了字符串到数值转换时常见问题的解决方法，以及如何避免转换中的潜在风险。接下来的章节将探讨数值到字符串的转换实践。

# 4. C++中的数值到字符串的转换实践

## 4.1 标准转换方法的深入解析

### 4.1.1 使用std::to_string进行转换

`std::to_string` 函数是C++11引入的，用于将数值类型转换为字符串。它是处理数值到字符串转换的直接且简洁的方法。`std::to_string` 支持多种数值类型，如 `int`, `long`, `long long`, `unsigned`, `unsigned long`, `unsigned long long`, `float`, `double`, `long double`。使用示例如下：

int main() {
    int num_int = 10;
    long num_long = 20L;
    double num_double = 30.5;
    std::string str_int = std::to_string(num_int);
    std::string str_long = std::to_string(num_long);
    std::string str_double = std::to_string(num_double);

    // 输出转换结果
    std::cout << "Integer to string: " << str_int << std::endl;
    std::cout << "Long to string: " << str_long << std::endl;
    std::cout << "Double to string: " << str_double << std::endl;

    return 0;
}

此函数的工作原理是将数值类型参数转换为C风格字符串，然后构造一个 `std::string` 对象。需要注意的是，`std::to_string` 对于非有限浮点数（NaN）和无穷大（Infinity）能够处理，但不会转换为标准字符串，通常返回 "nan" 或 "inf"。

### 4.1.2 使用 sprintf 和其他C风格函数的注意事项

`sprintf` 是C语言中的字符串格式化函数，虽然在C++中仍然可以使用，但不推荐使用。与 `std::to_string` 相比，`sprintf` 需要手动指定缓冲区大小，这增加了出错的风险。如果缓冲区大小不当，可能会导致缓冲区溢出，引发安全问题。

int main() {
    int num = 10;
    char buffer[100];
    // 使用sprintf进行转换
    sprintf(buffer, "%d", num);

    // 输出转换结果
    std::cout << "sprintf converted to: " << buffer << std::endl;

    return 0;
}

使用 `sprintf` 时，必须确保缓冲区足够大以容纳整个格式化的字符串，这在现代C++开发中通常不是最佳实践。此外，`sprintf` 不能直接用于转换C++特有的类型（如 `long long`），需要使用 `snprintf` 或者结合 `std::ostringstream`。

## 4.2 高级转换技巧和性能优化

### 4.2.1 流操作符与数值类的转换技巧

流操作符（`<<` 和 `>>`）可以用于将数值类型输入输出到流对象中，如 `std::ostringstream`。这种方法允许我们在转换过程中插入格式化操作，并且可以方便地与其他流操作（如条件检查、错误处理）结合。

#include <sstream>
#include <string>
#include <iostream>

int main() {
    int num = 10;
    std::ostringstream oss;
    oss << num; // 将数值写入流
    std::string str = oss.str(); // 从流中获取字符串

    // 输出转换结果
    std::cout << "Integer to string using stream: " << str << std::endl;

    return 0;
}

使用 `std::ostringstream` 的好处是，它避免了 `sprintf` 中的缓冲区溢出问题，并且能够处理C++类型。如果需要对输出进行格式化，可以使用格式化标志或者插入自定义格式化函数。

### 4.2.2 优化转换性能的策略和方法

当涉及到大量数值到字符串的转换时，性能优化变得尤为重要。使用 `std::to_string` 可能不是最快的转换方法。在这种情况下，可以考虑使用第三方库，如 Google的 `absl::StrFormat` 或者 `fmtlib`，这些库通常提供更快的性能和更少的开销。

#include <fmt/core.h>

int main() {
    int num = 10;
    std::string str = fmt::format("{}", num); // 使用fmtlib进行格式化

    // 输出转换结果
    std::cout << "Integer to string using fmtlib: " << str << std::endl;

    return 0;
}

优化方法还可以包括减少动态内存分配（比如预先分配足够大的缓冲区）和使用线程局部存储（TLS）来减少锁开销。同时，在并发环境下，避免不必要的同步开销也是性能优化的关键。

为了确保转换操作的性能，可以编写性能基准测试，并使用分析工具来找出瓶颈所在。在多线程应用中，选择合适的同步机制和并行处理技术，也对提高整体性能至关重要。

graph TD
    A[开始转换性能优化] --> B[确定性能瓶颈]
    B --> C[选择优化策略]
    C --> D[实施优化措施]
    D --> E[编写性能基准测试]
    E --> F[分析测试结果]
    F --> G{是否满足性能要求?}
    G -->|是| H[完成优化]
    G -->|否| B

| 性能优化策略 | 描述 |
| ------------------ | ------------------------------------------------------------ |
| 选择高效的库 | 使用像 `fmtlib` 这样的库，比标准库提供更好的性能 |
| 减少内存分配 | 预先分配足够大的缓冲区，避免动态分配 |
| 使用线程局部存储 | 减少多线程环境下的同步开销 |
| 并行处理与并发控制 | 使用线程池或任务并行库来实现高效的数据处理 |
| 性能基准测试与分析 | 使用基准测试工具来评估性能改进，并根据分析结果优化应用性能 |

# 5. 自定义类型与C++字符串转换

在C++中，除了处理内置数据类型和标准库中的数据类型转换之外，我们经常需要处理自定义类型的字符串转换问题。这可能涉及到将自定义对象转换为字符串表示形式，或者将字符串解析为自定义类型的对象。这类转换比标准类型转换更为复杂，因为它需要我们了解对象的内部结构和转换逻辑。在本章中，我们将探讨如何通过重载操作符和使用第三方库来实现这些高级转换。

## 5.1 重载std::stringstream的operator<<和operator>>

### 5.1.1 类型转换的设计思想和实现步骤

自定义类型的字符串转换要求我们对类的内部结构有深刻理解。为了将自定义对象转换为字符串，我们需要定义输出运算符 `operator<<`。对于将字符串转换为自定义类型的对象，则需要定义输入运算符 `operator>>`。在设计这些运算符时，我们应该确保转换逻辑清晰，并且符合类的语义。

实现步骤可以分为以下几步：

1. **定义输出运算符 `operator<<`：** 这个操作符需要接受一个 `std::ostream` 引用和一个常量自定义对象引用作为参数。输出运算符将对象的数据转换为字符串并写入到输出流中。

2. **定义输入运算符 `operator>>`：** 与输出运算符相反，输入运算符接受一个 `std::istream` 引用和一个非常量自定义对象引用作为参数。该操作符从输入流中读取数据，解析并存储到自定义对象中。

3. **考虑异常安全性：** 在转换过程中可能会遇到异常情况，例如输入格式错误。我们需要确保代码能够妥善处理异常，避免资源泄露或数据损坏。

4. **测试和验证：** 实现转换后，编写测试用例来验证转换逻辑的正确性和异常处理的有效性。

### 5.1.2 实现自定义类型的输入输出运算符

假设我们有一个简单的 `Date` 类，我们希望定义它的输入输出运算符以便能够将 `Date` 对象转换为字符串并从字符串解析得到 `Date` 对象。下面是一个可能的实现：

#include <iostream>
#include <sstream>

class Date {
public:
    int year, month, day;

    Date(int y, int m, int d) : year(y), month(m), day(d) {}

    friend std::ostream& operator<<(std::ostream& os, const Date& date) {
        os << date.year << '-' << date.month << '-' << date.day;
        return os;
    }

    friend std::istream& operator>>(std::istream& is, Date& date) {
        char delimiter1, delimiter2;
        is >> date.year >> delimiter1 >> date.month >> delimiter2 >> date.day;
        if (!is || delimiter1 != '-' || delimiter2 != '-') {
            is.clear(std::ios::failbit); // 设置流失败状态标志
        }
        return is;
    }
};

int main() {
    Date date(2023, 4, 1);
    std::cout << date << std::endl;  // 输出: 2023-4-1
    Date date2;
    std::cin >> date2;  // 输入: 2023-4-1
    std::cout << date2 << std::endl;  // 输出: 2023-4-1
    return 0;
}

在这个例子中，我们定义了 `Date` 类的输入输出运算符。在 `operator<<` 中，我们直接构造并输出了日期的字符串表示。在 `operator>>` 中，我们从输入流中读取数据，并检查了格式是否正确。

## 5.2 标准库外的转换方法

### 5.2.1 Boost库等第三方库的转换功能

有时标准库提供的工具可能不足以满足我们的需求，或者我们可能需要寻找更高级的转换工具。第三方库，如 Boost，提供了一系列强大的字符串转换功能。特别是 Boost.Serialization 和 Boost.Convert，它们提供了广泛的数据类型转换能力。

例如，使用 Boost.Serialization，我们可以将几乎任何对象序列化为字符串，或者从字符串反序列化。这样我们可以轻松地将自定义类型的对象转换为字符串表示形式，并且可以保持数据类型的所有信息。

### 5.2.2 性能和可维护性对比分析

第三方库如 Boost 提供的转换功能通常非常强大，但它们也可能带来额外的依赖和学习成本。在选择使用这些库时，我们必须权衡它们的性能优势和潜在的维护成本。

例如，Boost库的转换函数通常通过模板实现，因此它们可以用于任何支持这些操作的数据类型，并且能够利用编译器优化。但是，对 Boost 库的使用可能会增加项目的构建时间和复杂性，同时也会使项目对外部依赖的耦合度增加。

在决定是否使用第三方库进行字符串转换时，以下几点可以帮助我们做出决策：

- **性能需求：** 如果标准库功能无法满足性能要求，第三方库可能提供更优的性能。
- **项目维护性：** 如果项目需要长期维护且可能需要在多个项目中复用转换代码，则第三方库可能更有利于维护。
- **学习曲线：** 新引入的库需要开发团队学习，这可能在短期内降低生产力。
- **兼容性：** 需要考虑第三方库与项目其他依赖的兼容性问题。

在对比分析后，如果决定使用第三方库，应遵循良好的实践和设计原则进行集成，并确保库的使用能够带来实际的价值和改进。

# 6. C++字符串转换的最佳实践和测试

在C++开发过程中，字符串与各种数据类型之间的转换是不可或缺的操作。为了确保转换过程的健壮性和性能，遵循最佳实践和编写全面的测试用例是至关重要的。本章将重点讨论如何在遵循C++核心准则的基础上进行安全、高效的转换，并深入探讨如何实现全面的字符串转换测试。

## 6.1 遵循C++核心准则的转换实践

### 6.1.1 避免类型安全问题的最佳实践

在C++中，遵循核心准则进行字符串转换能够帮助我们避免类型安全问题，从而减少运行时的错误和安全漏洞。以下是几个关键的最佳实践：

- **使用强类型转换操作符**。优先使用`static_cast`、`const_cast`和`dynamic_cast`等操作符来进行安全的类型转换，而不是`reinterpret_cast`或C风格的类型转换。

- **定义清晰的转换构造函数和类型转换函数**。通过重载这些函数，可以让编译器明确知道如何进行转换，同时减少隐式转换带来的不确定性。

- **避免不必要的类型转换**。对于可以通过其他方式避免转换的情况，尽量不使用类型转换。例如，使用接口或抽象类来代替具体的实现类。

- **利用编译器警告和静态分析工具**。通过开启编译器的警告级别和使用静态分析工具，可以提前发现潜在的类型安全问题。

### 6.1.2 编写健壮的转换代码的指导原则

编写健壮的字符串转换代码应考虑以下原则：

- **明确转换的目的**。编写转换代码前，清楚转换的输入输出需求和预期行为，确保代码的可读性和可维护性。

- **对输入数据进行校验**。在转换之前，对输入的字符串进行校验，确保其符合预期格式。对于无法转换的输入，应提供适当的错误处理机制。

- **处理边界情况**。编写代码时考虑边界情况，如空字符串、极大或极小的数值转换等。

- **使用异常处理机制**。合理使用异常来处理转换中出现的错误，但要避免过度使用异常，以免影响性能。

## 6.2 实现全面的字符串转换测试用例

### 6.2.1 单元测试框架的选择和应用

为了验证字符串转换函数的正确性，编写单元测试是必不可少的环节。选择合适的单元测试框架对提高测试效率和覆盖率至关重要。以下是几个推荐的单元测试框架：

- **Google Test**：广泛使用的C++单元测试框架，提供了丰富的断言和测试用例管理功能。
- **Boost.Test**：Boost库中的测试组件，支持多种测试模式和自动测试发现功能。
- **Catch2**：轻量级、单头文件的测试框架，易于集成和使用。

在应用这些框架时，应遵循以下原则：

- **编写独立的测试用例**。每个测试用例应当独立，避免相互依赖，以保证测试的可靠性。
- **覆盖所有边界情况**。确保所有边界条件都被测试用例所覆盖，如空字符串、溢出值等。
- **使用参数化测试**。参数化测试可以减少代码冗余，提高测试的可维护性。

### 6.2.2 测试覆盖与持续集成的实践

为了确保代码质量，除了单元测试外，还应实施测试覆盖和持续集成：

- **测试覆盖**。使用代码覆盖工具（如gcov、gcovr或商业工具如Coverity）来分析测试用例的覆盖情况，确保关键代码路径都被测试到。
- **持续集成**。通过持续集成系统（如Jenkins、Travis CI或GitHub Actions）自动运行测试，确保每次代码提交都通过测试并监控代码质量。

在编写测试时，应关注以下几个方面：

- **逻辑路径的测试**。确保每条逻辑路径都至少被一个测试用例所覆盖。
- **性能测试**。对转换性能敏感的应用应进行性能测试，确保转换操作在可接受的时间内完成。
- **异常处理的测试**。确保所有异常情况都被正确处理，并且不会导致程序崩溃。

通过遵循这些实践，我们可以确保C++字符串转换的安全性、可靠性和性能，同时为未来的维护和扩展打下坚实的基础。