C++ 契约编程（Contracts）：利用 C++23 预览特性实现函数前置条件的运行时验证

各位同学，各位C++爱好者，大家好！

今天，我们将深入探讨C++语言中一个激动人心且极具潜力的特性——契约编程（Contracts）。尤其令人振奋的是，C++23标准虽然尚未最终定稿，但它为我们带来了契约编程的预览特性，使我们能够在C++中以一种更加结构化、声明式的方式来增强代码的健壮性和可维护性。本次讲座的重点将放在如何利用这些预览特性，特别是函数前置条件（preconditions）的运行时验证上。

1. 引言：为什么我们需要契约编程？

在现代软件开发中，程序的健壮性、可靠性和可维护性是衡量代码质量的关键指标。我们常常面临这样的挑战：如何确保函数在使用时接收到有效的输入？如何保证函数执行完毕后，其输出和系统状态符合预期？

传统上，C++程序员处理这些问题主要依赖以下几种方式：

1. 断言（Assertions）：如 assert() 宏，用于在开发和调试阶段检查程序内部的不变式。如果断言失败，程序通常会终止。它们的缺点是在发布版本中通常会被禁用，从而失去了运行时验证的能力。
2. 异常（Exceptions）：用于处理运行时发生的、可恢复的错误。例如，当文件打不开，或者内存分配失败时，抛出异常可以允许调用者尝试恢复或优雅地失败。然而，异常通常用于处理那些“意料之外但可能发生”的情况，而不是“绝对不应该发生”的编程错误。
3. 手动检查与错误码/返回值：在函数内部进行大量 if 语句检查，并返回错误码或特殊值。这会导致代码冗余，可读性差，且容易遗漏检查。
4. 注释和文档：依赖开发者手动编写文档来描述函数的使用契约。这种方式完全依赖于开发者的自觉性，且无法进行自动化验证。

这些方法各有优缺点，但都未能提供一种统一的、语言层面的机制来清晰地声明和自动验证函数与其调用者之间的“契约”。当一个函数被调用时，它与调用者之间存在着一系列的约定：调用者必须满足某些条件（前置条件），函数执行后会保证某些条件成立（后置条件）。如果这些约定被打破，意味着程序逻辑存在缺陷，而这种缺陷应该在尽可能早的阶段被发现。

契约编程，或称“契约式设计”（Design by Contract, DbC），正是为了解决这些问题而生。它由计算机科学家 Bertrand Meyer 在其 Eiffel 语言中首次提出，旨在通过明确声明函数的前置条件（preconditions）、后置条件（postconditions）和类不变量（invariants），从而提高软件的可靠性、可理解性和可测试性。

C++23预览的契约特性，将DbC的理念引入了C++语言本身，提供了一种标准化的方式来声明这些契约，并允许编译器在不同模式下对它们进行运行时验证。这无疑是C++语言发展史上的一个重要里程碑。

2. 契约式设计 (Design by Contract, DbC) 的核心概念

在深入C++23的具体语法之前，我们有必要先理解契约式设计的三大核心概念：

1. 前置条件 (Preconditions)：

   • 由函数调用者负责满足的条件。
   • 它定义了函数可以被合法调用的所有前提。
   • 如果前置条件不满足，函数不应被调用，这意味着调用者代码存在bug。
   • 在C++中，这通常通过 [[expects: expression]] 属性来声明。

2. 后置条件 (Postconditions)：

   • 由函数自身负责满足的条件。
   • 它定义了函数成功执行后，其返回值和/或系统状态必须满足的属性。
   • 如果后置条件不满足，意味着函数内部实现存在bug。
   • 在C++中，这通常通过 [[ensures: expression]] 属性来声明。

3. 不变量 (Invariants)：

   • 作用于类或模块。
   • 它定义了在对象的整个生命周期中，无论何时，只要对象处于“稳定”状态（即在公共方法调用前后），都必须保持为真的条件。
   • 不变量通常通过在所有公共成员函数的前置条件和后置条件中隐式检查来维护。C++23目前没有直接的 [[invariant]] 属性，但可以通过在所有成员函数中重复 expects 和 ensures 来模拟。

契约式设计的核心思想是“相互义务与承诺”：

• 调用者承诺满足函数的前置条件。
• 被调用函数承诺在满足前置条件的情况下，一定会满足其后置条件。

如果任一方违反了契约，则表明程序中存在一个逻辑错误，这应该被立即发现并修正。

3. C++23 契约编程预览特性：语法与语义

C++23引入的契约编程特性主要以属性（attributes）的形式呈现，它们是编译器可以理解和处理的元数据。

3.1 [[expects: expression]]：声明前置条件

[[expects: expression]] 属性用于声明函数的前置条件。expression 必须是一个布尔表达式，它在函数体执行之前被评估。

语法示例：

#include <iostream>
#include <vector>
#include <stdexcept> // 用于演示传统错误处理

// 传统方式：手动检查
int divide_manual(int numerator, int denominator) {
    if (denominator == 0) {
        throw std::invalid_argument("Denominator cannot be zero.");
    }
    return numerator / denominator;
}

// 使用 C++23 契约：前置条件
// 注意：这需要支持 C++23 契约的编译器（如 Clang 15+ 并启用相应实验特性）
// 编译时可能需要类似 -fcontract-level=default 的标志
int divide_contract(int numerator, int denominator)
    [[expects: denominator != 0]] // 声明前置条件
{
    std::cout << "Executing divide_contract(" << numerator << ", " << denominator << ")" << std::endl;
    return numerator / denominator;
}

// 另一个例子：访问 vector 元素
void print_vector_element(const std::vector<int>& vec, size_t index)
    [[expects: index < vec.size()]] // 索引必须在有效范围内
{
    std::cout << "Element at index " << index << ": " << vec[index] << std::endl;
}

// 复杂一点的前置条件：要求指针非空且其指向的值大于0
void process_positive_value(int* ptr)
    [[expects: ptr != nullptr && *ptr > 0]]
{
    std::cout << "Processing positive value: " << *ptr << std::endl;
    // ... 执行一些依赖于ptr非空且*ptr为正数的逻辑
}

int main() {
    std::cout << "--- Manual Check Example ---" << std::endl;
    try {
        std::cout << "10 / 2 = " << divide_manual(10, 2) << std::endl;
        std::cout << "10 / 0 (manual) will throw..." << std::endl;
        std::cout << divide_manual(10, 0) << std::endl;
    } catch (const std::invalid_argument& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    std::cout << "n--- Contract Expects Example ---" << std::endl;
    std::cout << "10 / 2 = " << divide_contract(10, 2) << std::endl;
    // 下面这行代码如果前置条件失败，将触发契约违规处理
    // 在默认模式下，通常会导致程序终止
    // std::cout << "10 / 0 (contract) will violate contract..." << std::endl;
    // std::cout << divide_contract(10, 0) << std::endl; // 运行时会触发契约违规

    std::vector<int> my_vec = {10, 20, 30};
    print_vector_element(my_vec, 1);
    // print_vector_element(my_vec, 3); // 运行时会触发契约违规

    int a = 5;
    process_positive_value(&a);
    int b = -1;
    // process_positive_value(&b); // 运行时会触发契约违规
    // process_positive_value(nullptr); // 运行时会触发契约违规

    std::cout << "Program finished successfully (if no contract violations occurred and terminated)." << std::endl;

    return 0;
}

在上述 divide_contract 函数中，[[expects: denominator != 0]] 明确告诉编译器和任何阅读代码的人：此函数要求 denominator 绝不能为零。如果调用者违反了这一条件，那么它是一个编程错误，而不是一个需要被捕获的“运行时异常”。

3.2 [[ensures: expression]]：声明后置条件

[[ensures: expression]] 属性用于声明函数的后置条件。expression 必须是一个布尔表达式，它在函数体执行完毕并返回值之后被评估（如果函数有返回值）。

语法示例：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm> // for std::is_sorted

// 使用 C++23 契约：后置条件
// 确保返回的字符串不为空
std::string get_non_empty_string(int value)
    [[ensures: !return_value.empty()]] // return_value 是 C++ 契约中的特殊标识符
{
    std::string result = std::to_string(value);
    // 假设在某些复杂逻辑下，result 可能意外为空
    // if (value == 0) result = ""; // 如果这里真的返回空字符串，后置条件就会失败
    return result;
}

// 确保 vector 被排序
void sort_vector(std::vector<int>& vec)
    [[ensures: std::is_sorted(vec.begin(), vec.end())]]
{
    std::sort(vec.begin(), vec.end());
    // 假设这里排序算法有bug，没有正确排序，后置条件就会失败
    // std::reverse(vec.begin(), vec.end()); // 如果这里反转了，后置条件会失败
}

// 确保返回值在某个范围内
int generate_id()
    [[ensures: return_value >= 1000 && return_value <= 9999]]
{
    static int current_id = 1000;
    // 假设这里有bug，生成了超出范围的ID
    // if (current_id == 9999) current_id = 10000; // 此时后置条件失败
    return current_id++;
}

int main() {
    std::cout << "--- Contract Ensures Example ---" << std::endl;

    std::string s1 = get_non_empty_string(123);
    std::cout << "Generated string: '" << s1 << "'" << std::endl;

    // std::string s_empty = get_non_empty_string(0); // 如果get_non_empty_string返回空，会触发契约违规

    std::vector<int> numbers = {5, 2, 8, 1, 9};
    std::cout << "Original vector: ";
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    sort_vector(numbers);
    std::cout << "Sorted vector: ";
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    // 如果 sort_vector 内部有bug导致未排序，这里将触发契约违规

    std::cout << "Generated ID: " << generate_id() << std::endl;
    std::cout << "Generated ID: " << generate_id() << std::endl;
    // 循环调用直到触发后置条件失败，如果 generate_id 有bug
    // for (int i = 0; i < 9000; ++i) {
    //     generate_id();
    // }
    // std::cout << "Generated ID (out of range): " << generate_id() << std::endl;

    std::cout << "Program finished successfully (if no contract violations occurred and terminated)." << std::endl;

    return 0;
}

在 [[ensures: !return_value.empty()]] 中，return_value 是一个特殊的标识符，它代表函数的返回值。这个标识符只能在 [[ensures]] 属性中使用。如果函数没有返回值（即 void 函数），则不能使用 return_value。

3.3 [[assert: expression]]：内部断言 (非C++23契约属性，但相关)

虽然 C++23 契约特性主要关注 expects 和 ensures 作为函数接口契约，但值得一提的是，标准委员会也曾讨论过 [[assert: expression]]，它更类似于一个增强版的 static_assert 或 assert，用于表达程序内部的逻辑不变式。然而，在 C++23 的当前提案中，[[assert]] 属性并未被包含为官方的契约属性。通常，内部逻辑的断言仍然使用 assert 宏或自定义断言机制。

核心区别：

• [[expects]] 和 [[ensures]] 关注函数接口的契约，是公开的、对调用者和实现者都生效的。它们是函数签名的一部分。
• assert() 宏关注函数实现的内部逻辑，通常在发布版本中被移除。
• [[assert]] (如果被引入) 会是介于两者之间，可能在某些模式下保留在发布版本中，用于检查内部逻辑。

本次讲座我们主要聚焦于 C++23 提供的 [[expects]] 和 [[ensures]]。

4. 契约违规处理与合同级别 (Contract Levels)

契约编程的核心在于，当契约被违反时，程序应该如何响应。C++23的契约特性引入了“契约级别”（Contract Levels）的概念，允许开发者在编译时选择不同程度的契约检查，以平衡安全性和性能。

4.1 契约违规处理 (Contract Violation Handler)

当一个契约（无论是前置条件还是后置条件）被违反时，程序将调用一个“契约违规处理函数”（Contract Violation Handler）。默认的处理行为是终止程序（通过 std::terminate()）。然而，C++标准库提供了 std::set_contract_violation_handler 函数，允许开发者自定义这个处理函数。

自定义处理函数示例：

#include <iostream>
#include <vector>
#include <string>
#include <functional> // for std::function
#include <cstdlib>    // for std::abort

// C++23 contract violation handler type
// The exact signature might vary in experimental implementations,
// but conceptually it receives information about the violation.
// For now, let's assume a simplified signature for demonstration.
// The actual C++23 proposal defines it as:
// using contract_violation_handler = void(*)(const std::contract_violation&);
// For simplicity and broader compiler compatibility in experimental settings,
// we might use a lambda or a function pointer that just logs and aborts.

// A custom contract violation handler
void my_contract_violation_handler(const std::contract_violation& violation) {
    std::cerr << "!!! CONTRACT VIOLATION DETECTED !!!" << std::endl;
    std::cerr << "File: " << violation.file_name() << std::endl;
    std::cerr << "Line: " << violation.line_number() << std::endl;
    std::cerr << "Function: " << violation.function_name() << std::endl;
    std::cerr << "Expression: " << violation.expression() << std::endl;
    std::cerr << "Assertion level: " << static_cast<int>(violation.assertion_level()) << std::endl;
    std::cerr << "Type: " << (violation.type() == std::contract_violation::type::precondition ? "Precondition" : "Postcondition") << std::endl;
    std::cerr << "Terminating program..." << std::endl;
    std::abort(); // 终止程序，通常是期望行为
}

// C++23 契约函数
int divide(int numerator, int denominator)
    [[expects: denominator != 0]]
{
    std::cout << "  Inside divide(" << numerator << ", " << denominator << ")" << std::endl;
    return numerator / denominator;
}

std::string get_string_rep(int value)
    [[ensures: !return_value.empty()]]
{
    // Simulate a bug where for value 0, it returns an empty string
    if (value == 0) {
        return ""; // This will violate the postcondition
    }
    return std::to_string(value);
}

int main() {
    // 设置自定义契约违规处理函数
    // Note: This function is part of <contract> header in C++23.
    // For experimental compilers, you might need to mock std::contract_violation
    // or use specific compiler flags.
    // For demonstration, let's assume `std::set_contract_violation_handler` is available.
    std::set_contract_violation_handler(&my_contract_violation_handler);

    std::cout << "--- Testing Precondition ---" << std::endl;
    std::cout << "Calling divide(10, 5)..." << std::endl;
    std::cout << "Result: " << divide(10, 5) << std::endl;

    std::cout << "Calling divide(10, 0)... (This should trigger contract violation)" << std::endl;
    // This call will trigger the precondition violation and call my_contract_violation_handler
    // divide(10, 0);

    std::cout << "n--- Testing Postcondition ---" << std::endl;
    std::cout << "Calling get_string_rep(123)..." << std::endl;
    std::cout << "Result: " << get_string_rep(123) << std::endl;

    std::cout << "Calling get_string_rep(0)... (This should trigger contract violation)" << std::endl;
    // This call will trigger the postcondition violation and call my_contract_violation_handler
    // get_string_rep(0);

    std::cout << "Program will terminate if contract is violated." << std::endl;
    return 0;
}

请注意，std::contract_violation 及其成员函数 file_name()、line_number() 等是 C++23 提案中的内容，具体实现可能需要特定的编译器支持和头文件（如 <contract>）。在许多实验性实现中，你可能需要自己定义一个简化的处理函数或使用编译器提供的特定接口。核心思想是，你可以拦截这个错误并记录详细信息，但最终行为通常是终止程序，因为契约违规被认为是不可恢复的编程错误。

4.2 契约级别 (Contract Levels)

契约级别是编译时配置，它决定了哪些契约在运行时被检查。这对于在不同发布阶段（开发、测试、生产）平衡性能和安全性至关重要。C++23 提案定义了以下几个契约级别：

| 契约级别 | 编译选项示例 (概念性) | 前置条件 (expects) 行为 | 后置条件 (ensures) 行为 | 适用场景 | 备注 注意： 对于 std::contract_violation 结构体，std::set_contract_violation_handler 函数，以及 C++23 契约的完整支持，您需要使用支持 C++23 实验性契约的编译器版本（例如 Clang 15+ 或 GCC 13+ 的特定分支），并且通常需要通过编译标志（例如 -fcontract-level=default 或 -std=c++2b -fcontracts）来启用这些特性。

#include <iostream>
#include <vector>
#include <string>
#include <functional>
#include <cstdlib>
// #include <contract> // In C++23, std::set_contract_violation_handler is in <contract>

// Mock std::contract_violation for compilers that don't fully support C++23 contracts yet
// In a real C++23 environment, you would include <contract>
namespace std {
    enum class contract_assertion_level : unsigned char {
        default_level, audit_level, axiom_level
    };

    enum class contract_violation_type : unsigned char {
        precondition, postcondition
    };

    struct contract_violation {
        const char* file_name() const { return "mock_file.cpp"; }
        unsigned int line_number() const { return 0; }
        const char* function_name() const { return "mock_func"; }
        const char* expression() const { return "mock_expr"; }
        contract_assertion_level assertion_level() const { return contract_assertion_level::default_level; }
        contract_violation_type type() const { return contract_violation_type::precondition; }
    };

    // A simple mock for set_contract_violation_handler
    // In actual C++23, this would take a function pointer to void(*)(const std::contract_violation&)
    std::function<void(const contract_violation&)> current_handler;
    void set_contract_violation_handler(std::function<void(const contract_violation&)> handler) {
        current_handler = std::move(handler);
    }
} // namespace std

// A custom contract violation handler
void my_contract_violation_handler(const std::contract_violation& violation) {
    std::cerr << "!!! CUSTOM CONTRACT VIOLATION DETECTED !!!" << std::endl;
    std::cerr << "File: " << violation.file_name() << std::endl;
    std::cerr << "Line: " << violation.line_number() << std::endl;
    std::cerr << "Function: " << violation.function_name() << std::endl;
    std::cerr << "Expression: " << violation.expression() << std::endl;
    std::cerr << "Assertion level: " << static_cast<int>(violation.assertion_level()) << std::endl;
    std::cerr << "Type: " << (violation.type() == std::contract_violation_type::precondition ? "Precondition" : "Postcondition") << std::endl;
    std::cerr << "Terminating program via abort()..." << std::endl;
    std::abort(); // Terminate the program
}

// C++23 契约函数
// Note: Actual compilation requires specific compiler flags for C++23 contracts.
// If your compiler doesn't support them, these attributes will be ignored.
int divide(int numerator, int denominator)
    [[expects: denominator != 0]]
{
    std::cout << "  Inside divide(" << numerator << ", " << denominator << ")" << std::endl;
    return numerator / denominator;
}

std::string get_string_rep(int value)
    [[ensures: !return_value.empty()]]
{
    std::cout << "  Inside get_string_rep(" << value << ")" << std::endl;
    if (value == 0) {
        // This will violate the postcondition IF contracts are enabled and checked.
        // In a real C++23 contract system, this would trigger the handler.
        // For this mock, it just returns.
        std::cerr << "  (Simulating postcondition failure if contracts were active)" << std::endl;
        return "";
    }
    return std::to_string(value);
}

int main() {
    // Set the custom contract violation handler.
    // In a real C++23 setup, this would register with the runtime.
    std::set_contract_violation_handler(my_contract_violation_handler);

    std::cout << "--- Testing Precondition ---" << std::endl;
    std::cout << "Calling divide(10, 5)..." << std::endl;
    std::cout << "Result: " << divide(10, 5) << std::endl;

    std::cout << "Calling divide(10, 0)... (This *should* trigger contract violation if enabled)" << std::endl;
    // If contracts are enabled and `denominator != 0` fails,
    // my_contract_violation_handler would be called.
    // For this mock, the attribute is just syntax, not runtime logic.
    // If you compile with `-fcontract-level=default` on a supporting compiler, this will terminate.
    // If not, it's just undefined behavior (division by zero).
    // divide(10, 0); // Uncomment to test

    std::cout << "n--- Testing Postcondition ---" << std::endl;
    std::cout << "Calling get_string_rep(123)..." << std::endl;
    std::cout << "Result: " << get_string_rep(123) << std::endl;

    std::cout << "Calling get_string_rep(0)... (This *should* trigger contract violation if enabled)" << std::endl;
    // If contracts are enabled and `!return_value.empty()` fails,
    // my_contract_violation_handler would be called.
    // get_string_rep(0); // Uncomment to test

    std::cout << "nProgram finished (if no real contract violations occurred and terminated)." << std::endl;
    std::cout << "Note: The mock handler only demonstrates the *concept*. Real C++23 contract checks require specific compiler support." << std::endl;

    return 0;
}

请注意：上述代码中的 namespace std { ... } 是为了在没有完整C++23契约支持的编译器上模拟 std::contract_violation 和 std::set_contract_violation_handler 的存在，以便代码能够通过编译并展示概念。在真正的C++23环境中，您将直接包含 <contract> 头文件并使用标准提供的类型和函数。

契约级别详情：

契约级别	编译器标志 (Clang/GCC 示例)	前置条件 ([[expects]])	后置条件 ([[ensures]])	适用场景
off	-fcontract-level=off	不检查，契约代码被移除	不检查，契约代码被移除	最终生产版本，追求极致性能，信任代码无bug。
default	-fcontract-level=default	检查，失败时调用处理函数并终止	检查，失败时调用处理函数并终止	开发和测试阶段，以及对关键模块有一定运行时安全要求的生产版本。这是推荐的默认级别，提供很好的平衡。
audit	-fcontract-level=audit	检查，失败时调用处理函数并终止	检查，失败时调用处理函数并终止	更严格的测试和审计阶段。通常比 default 级别检查更多的隐式契约（如果将来标准定义了更多）。
axiom	-fcontract-level=axiom	假定为真，不检查，但编译器可用于优化或静态分析	假定为真，不检查，但编译器可用于优化或静态分析	仅在编译器能够完全证明契约永远为真的情况下使用。主要用于辅助静态分析工具或高级编译器优化。在运行时，它不执行检查。在当前C++23提案中，其主要目的是提供给静态分析器信息，而不是运行时检查。

在实践中，通常会根据构建类型来设置契约级别：

• Debug/Test Builds: 使用 default 或 audit 级别，以捕获尽可能多的编程错误。
• Release Builds: 视情况选择 default（对于需要运行时安全的关键系统）或 off（对于性能敏感且经过充分测试的系统）。

5. 契约编程的优势与应用场景

5.1 优势

1. 提高代码可靠性与健壮性：强制在运行时验证程序逻辑，及时发现和定位bug。
2. 改善代码可读性与可维护性：契约直接声明了函数的意图和使用要求，作为“活的文档”，比注释更可靠。
3. 促进模块化设计：明确定义了模块之间的接口约定，减少了不必要的耦合。
4. 简化调试：一旦契约被违反，程序会在错误发生的精确位置终止，而不是在错误传播到其他部分导致更难以诊断的崩溃。
5. 增强测试能力：契约可以作为测试用例的生成依据，帮助编写更全面的单元测试和集成测试。
6. 静态分析潜力：编译器和静态分析工具可以利用契约信息进行更深入的代码分析和优化。
7. 区分错误类型：明确区分了“编程错误”（违反契约，应终止）和“运行时异常”（可恢复的错误）。

5.2 实际应用场景

1. 输入验证：

   • 确保函数参数非空指针、非负数、在有效范围内等。
   • [[expects: index < vec.size()]]
   • [[expects: value > 0]]

2. 资源管理：

   • 确保在尝试释放资源前，资源确实被分配了。
   • 确保文件句柄在使用前是打开的。

3. 数据结构操作：

   • 在向容器添加元素后，确保容器大小增加。
   • 在从容器移除元素后，确保容器大小减少。
   • 确保排序操作后，容器内容确实有序。
   • [[ensures: vec.size() == old_size + 1]] (需要访问旧值，C++23 契约提案考虑了 old 表达式，但具体语法还在演进中，目前可能需要手动保存)
   • [[ensures: std::is_sorted(begin, end)]]

4. 数学运算：

   • 防止除零、对负数取平方根等非法操作。
   • [[expects: denominator != 0]]

5. API设计：

   • 为库函数和公共API明确指定使用要求，降低误用风险。
   • 这对于构建健壮的第三方库尤为重要。

6. 安全关键系统：

   • 在航空、医疗、汽车等对可靠性要求极高的领域，契约编程能提供额外的安全保障。

6. 契约编程与现有错误处理机制的对比与选择

特性	assert()	throw (异常)	[[expects]]/[[ensures]] (契约)
目的	调试期间发现内部编程错误	处理可恢复的运行时错误	声明并验证函数与调用者/实现者之间的契约（编程错误）
运行时行为	Debug模式下终止，Release模式下通常移除	抛出异常，可被捕获并处理	默认终止（可自定义处理函数），可配置检查级别
性能开销	Debug模式下有，Release模式下无	相对较高（栈展开，对象构造）	取决于契约表达式复杂度及契约级别（可为零）
恢复能力	无	有	无（默认视为编程错误，不可恢复）
位置	函数内部，用于内部逻辑检查	函数内部或调用者处，用于错误传播	函数签名，作为接口的一部分
适用场景	内部逻辑的临时检查，快速失败	文件I/O失败、内存不足、网络连接中断等	API参数验证、函数结果验证、数据结构状态检查等
语义	“这不应该发生，如果发生，程序就错了”	“这可能发生，请处理它”	“调用者必须保证A，函数保证B；否则，这是个bug”

何时选择哪种机制？

• 使用 assert()：当你想在开发和调试阶段快速发现那些“绝不应该发生”的内部逻辑错误，但在发布版本中不希望有任何性能开销时。assert 适合于检查那些只对开发者有意义，对最终用户而言是内部实现细节的条件。
• 使用 throw (异常)：当错误是外部环境导致的、不可预测但可恢复的，或者调用者有能力并且可能希望从错误中恢复时。异常是处理“意料之外但可能发生”情况的标准机制。
• 使用 [[expects]]/[[ensures]] (契约)：当你想明确声明函数与其调用者或实现者之间的“约定”，并且任何违反这些约定的行为都应被视为“编程错误”时。契约是关于正确使用代码的规范，违反契约意味着程序逻辑存在缺陷，通常应该终止程序以防止进一步的损害。

契约编程尤其适用于那些“前置条件不满足，就没有意义继续执行”的情况。例如，一个 sort 函数，如果传入的迭代器范围无效，那么继续执行是没有意义的，而且很可能导致崩溃。这正是前置条件大放异彩的地方。

7. 契约编程与继承 (Liskov Substitution Principle, LSP)

在面向对象编程中，特别是涉及到继承时，契约编程与Liskov替换原则（LSP）有着深刻的联系。LSP要求子类型必须能够替换其基类型而不改变程序的正确性。在契约的语境下，这意味着：

• 子类的expects（前置条件）可以被削弱或保持不变，但不能被加强。

  • 如果基类要求 x > 0，子类可以要求 x >= 0 (削弱)，或者 x > 0 (不变)，但不能要求 x > 1 (加强)。
  • 理由：如果子类加强了前置条件，那么任何满足基类前置条件的调用者可能就不满足子类的前置条件了，从而破坏了替换性。

• 子类的ensures（后置条件）可以被加强或保持不变，但不能被削弱。

  • 如果基类保证 result >= 0，子类可以保证 result > 0 (加强)，或者 result >= 0 (不变)，但不能只保证 result != 0 (削弱)。
  • 理由：如果子类削弱了后置条件，那么任何依赖基类后置条件的调用者可能在调用子类时发现其承诺未被满足，从而破坏了替换性。

这个原则在设计继承体系时非常重要，确保了即使通过基类指针或引用调用子类方法，契约的有效性也能得到维护。

#include <iostream>
#include <vector>
#include <algorithm>

// 假设我们有一个基类
class Base
{
public:
    virtual void process_data(std::vector<int>& data, int value)
        [[expects: value >= 0]] // 基类要求 value 非负
        [[ensures: !data.empty()]] // 基类保证 data 非空
    {
        std::cout << "Base::process_data - value: " << value << std::endl;
        if (data.empty()) {
            data.push_back(value);
        } else {
            data[0] = value;
        }
    }
};

// 子类 SubA：削弱前置条件，加强后置条件
class SubA : public Base
{
public:
    void process_data(std::vector<int>& data, int value) override
        [[expects: true]] // 削弱前置条件：SubA 对 value 不再有任何要求 (极端情况，通常会有更具体的削弱)
        [[ensures: !data.empty() && data.back() == value]] // 加强后置条件：不仅非空，而且最后一个元素是 value
    {
        std::cout << "SubA::process_data - value: " << value << std::endl;
        data.push_back(value);
    }
};

// 子类 SubB：保持前置条件不变，保持后置条件不变
class SubB : public Base
{
public:
    void process_data(std::vector<int>& data, int value) override
        [[expects: value >= 0]] // 保持前置条件不变
        [[ensures: !data.empty()]] // 保持后置条件不变
    {
        std::cout << "SubB::process_data - value: " << value << std::endl;
        // 假设 SubB 的实现是插入到开头
        data.insert(data.begin(), value);
    }
};

// 子类 SubC：违反LSP的例子 (加强了前置条件)
// 理论上，编译器会对此发出警告或错误，或运行时契约检查会失败
class SubC : public Base
{
public:
    void process_data(std::vector<int>& data, int value) override
        [[expects: value > 10]] // 加强了前置条件 (违反LSP!)
        [[ensures: !data.empty()]]
    {
        std::cout << "SubC::process_data - value: " << value << std::endl;
        data.push_back(value * 2);
    }
};

// 子类 SubD：违反LSP的例子 (削弱了后置条件)
class SubD : public Base
{
public:
    void process_data(std::vector<int>& data, int value) override
        [[expects: value >= 0]]
        [[ensures: data.size() >= 0]] // 削弱了后置条件 (违反LSP!) (基类保证非空，子类只保证size>=0)
    {
        std::cout << "SubD::process_data - value: " << value << std::endl;
        // 假设这里有bug，或者特殊逻辑导致data可能为空
        if (value % 2 == 0) {
            data.clear(); // 这将违反基类的后置条件!
        } else {
            data.push_back(value);
        }
    }
};

int main() {
    std::cout << "--- Liskov Substitution Principle and Contracts ---" << std::endl;

    std::vector<int> initial_data = {1};
    int test_value = 5; // 满足 Base 的前置条件 (>= 0)

    Base* b_ptr = nullptr;

    // Test SubA (LSP compliant)
    std::cout << "nTesting SubA (LSP compliant):" << std::endl;
    b_ptr = new SubA();
    std::vector<int> data_a = initial_data;
    b_ptr->process_data(data_a, test_value); // 调用 SubA 的 process_data
    // 如果 SubA 的后置条件 (data.back() == value) 失败，会触发违规
    delete b_ptr;

    // Test SubB (LSP compliant)
    std::cout << "nTesting SubB (LSP compliant):" << std::endl;
    b_ptr = new SubB();
    std::vector<int> data_b = initial_data;
    b_ptr->process_data(data_b, test_value); // 调用 SubB 的 process_data
    delete b_ptr;

    // Test SubC (LSP violation: strengthened precondition)
    std::cout << "nTesting SubC (LSP violation: strengthened precondition):" << std::endl;
    b_ptr = new SubC();
    std::vector<int> data_c = initial_data;
    // 调用者期望传入 test_value=5 是合法的 (因为 Base::process_data 允许)
    // 但 SubC::process_data 内部要求 value > 10，这将导致前置条件违规
    // b_ptr->process_data(data_c, test_value); // Uncomment to observe violation
    delete b_ptr;

    // Test SubD (LSP violation: weakened postcondition)
    std::cout << "nTesting SubD (LSP violation: weakened postcondition):" << std::endl;
    b_ptr = new SubD();
    std::vector<int> data_d = initial_data;
    // b_ptr->process_data(data_d, test_value); // Uncomment to observe violation
    // 如果 test_value 是偶数 (例如 6)，SubD 会清空 data，导致后置条件 !data.empty() 失败
    delete b_ptr;

    std::cout << "Program finished." << std::endl;

    return 0;
}

在上述示例中，SubA 和 SubB 是符合 LSP 的，它们要么保持契约不变，要么以一种兼容的方式修改了契约。而 SubC 加强了前置条件，SubD 削弱了后置条件，这都违反了 LSP。在支持契约的C++23编译器中，这些LSP违规行为将在运行时被检测到，从而帮助开发者编写更正确的继承体系。

8. 展望与总结

C++23 契约编程特性，即使仍处于预览阶段，也为 C++ 生态系统带来了巨大的潜力。它提供了一种语言层面的标准化机制，用于声明和运行时验证函数的前置条件和后置条件，从而显著提高代码的健壮性、可读性和可靠性。通过与现有错误处理机制的合理结合，开发者能够更精确地表达程序意图，区分编程错误与运行时异常，并在开发和测试阶段尽早发现潜在问题。

虽然目前 C++23 契约的实现和普及尚需时日，但其理念和带来的好处是毋庸置疑的。我们鼓励大家关注 C++ 标准委员会的进展，并在条件允许时尝试使用这些实验性特性，为未来的软件开发实践做好准备。