如何在 Java 中模拟 C++ 的输入/输出参数并返回多值结果-java教程-PHP中文网

如何在 Java 中模拟 C++ 的输入/输出参数并返回多值结果

Java 不支持指针或引用传参，也无法直接返回多个值；但可通过封装通用结果类（如 Result）统一处理错误码与业务数据，避免为每个函数创建独立返回类，兼顾类型安全与代码可维护性。

java 不支持指针或引用传参，也无法直接返回多个值；但可通过封装通用结果类（如 `result`）统一处理错误码与业务数据，兼顾类型安全与代码可维护性。

在将大型 C++ 项目迁移至 Java 时，一个典型挑战是处理类似 int evaluateFunc(const T1&, T2&, T3&) 这类具有输入（const）、输入/输出（&）、纯输出（&）参数的函数——它们依赖 C++ 的引用语义实现状态修改，并始终返回整型错误码（如 0 表示成功，非零表示具体错误）。而 Java 中所有参数均为按值传递（对象传递的是引用的副本），无法原地修改原始变量；同时方法仅允许单个返回值。

✅ 推荐方案：泛型结果容器 + 显式状态封装

与其为 100 个函数分别定义 EvaluateResultA、EvaluateResultB… 等 100 个专用类，不如设计一个可复用、类型安全、语义清晰的通用结果结构：

public final class Result<t> {
    private final int errorCode;      // 统一错误码（必需）
    private final T data;             // 可选业务数据（null 合法）
    private final boolean success;    // 便捷判断：errorCode == 0

    private Result(int errorCode, T data) {
        this.errorCode = errorCode;
        this.data = data;
        this.success = (errorCode == 0);
    }

    public static <t> Result<t> success(T data) {
        return new Result(0, data);
    }

    public static <t> Result<t> failure(int errorCode) {
        return new Result(errorCode, null);
    }

    public static <t> Result<t> failure(int errorCode, T data) {
        return new Result(errorCode, data);
    }

    // Getters
    public int getErrorCode() { return errorCode; }
    public T getData() { return data; }
    public boolean isSuccess() { return success; }
    public boolean isFailure() { return !success; }

    @Override
    public String toString() {
        return String.format("Result{code=%d, success=%s, data=%s}", 
            errorCode, success, data);
    }
}</t></t></t></t></t></t></t>

? 迁移示例：C++ → Java 对照

假设原 C++ 函数：

int evaluateFunc(const std::string& input, std::string& ioBuffer, int& outputCount) {
    if (input.empty()) return ERR_INVALID_INPUT;
    ioBuffer += "_processed";
    outputCount = input.length();
    return OK;
}

对应 Java 实现（无需修改调用方变量，而是返回新状态）：

Gradle 9.8.0

下载

public Result<processedresult> evaluateFunc(String input) {
    if (input == null || input.isEmpty()) {
        return Result.failure(ERR_INVALID_INPUT);
    }

    String ioBuffer = input + "_processed";           // 输入/输出逻辑 → 新建值
    int outputCount = input.length();                  // 纯输出 → 封装进对象

    ProcessedResult result = new ProcessedResult(ioBuffer, outputCount);
    return Result.success(result);  // 单一返回：含错误码 + 业务数据
}

// 轻量内部类（按需定义，非每个函数都需独立类）
public static class ProcessedResult {
    public final String ioBuffer;
    public final int outputCount;
    public ProcessedResult(String ioBuffer, int outputCount) {
        this.ioBuffer = ioBuffer;
        this.outputCount = outputCount;
    }
}</processedresult>

调用方式简洁明确：

Result<processedresult> res = evaluateFunc("hello");
if (res.isSuccess()) {
    String buffer = res.getData().ioBuffer;     // "hello_processed"
    int count = res.getData().outputCount;      // 5
    // 后续处理...
} else {
    switch (res.getErrorCode()) {
        case ERR_INVALID_INPUT: handleInvalidInput(); break;
        case ERR_IO_TIMEOUT:    handleTimeout();      break;
        // ... 其他 50+ 错误码分支
    }
}</processedresult>

⚠️ 关键注意事项

不可变性优先：Java 中应避免“试图修改入参”（如 void f(StringBuilder sb)），而应返回新对象。这符合函数式思想，也更易测试和并发安全。
null 安全：Result 的 data 字段允许为 null（例如失败时无有效数据），但建议在 success() 工厂方法中强制非空约束，或使用 Optional 包装（若业务要求严格非空）。
错误码体系复用：将 50+ 错误码定义为 public static final int ERR_XXX = 1001; 常量，统一管理，便于国际化或日志映射。
性能考量：对象创建开销极小（现代 JVM 优化良好），远低于为每个函数定制类带来的维护成本。