多返回值（C++)

1. 自定义结构体（或 class）

思路：为这两个返回值命名一个上下文相关的结构体，返回时直接返回该结构体实例。
示例：

// 定义一个结果结构体
struct DivResult {
    int quotient;
    int remainder;
};

// 函数返回 DivResult
DivResult div_mod(int a, int b) {
    return DivResult{a / b, a % b};
}

int main() {
    auto result = div_mod(17, 5);
    std::cout << "商 = " << result.quotient
              << ", 余数 = " << result.remainder << "\n";
}

• 优点

  • 语义清晰，成员有意义的名字。

  • 易于扩展：若将来需要附加更多信息，只要在结构体里加成员即可。

• 缺点

  • 需要额外定义类型（但这种“显式”往往是优点）。

2. std::pair / std::tuple

2.1 std::pair

#include <utility>

std::pair<int,int> div_mod(int a, int b) {
    return {a / b, a % b};
}

int main() {
    auto [q, r] = div_mod(17, 5);  // C++17 结构化绑定
    std::cout << "商 = " << q << ", 余数 = " << r << "\n";
}

• 优点

  • 无需自定义类型，标准库即用。

  • 支持结构化绑定（C++17 起），免去 .first/.second。

• 缺点

  • .first/.second 语义不够直观，特别是团队协作时可读性较差。

2.2 std::tuple

当返回值超过两个、或者类型不统一时可用 std::tuple<T1, T2, …>，同样支持结构化绑定。

#include <tuple>

std::tuple<int,double,bool> func() {
    return {42, 3.14, true};
}

int main() {
    auto [i, d, b] = func();
}

3. 输出参数（Output Parameters）

思路：通过引用（或指针）参数将结果“输出”给调用者，函数本身可以返回 bool 或错误码。

bool div_mod(int a, int b, int& quotient, int& remainder) {
    if (b == 0) return false;
    quotient  = a / b;
    remainder = a % b;
    return true;
}

int main() {
    int q, r;
    if (div_mod(17, 5, q, r)) {
        std::cout << "商 = " << q << ", 余数 = " << r << "\n";
    }
}

• 优点

  • 不产生临时对象，略微节省拷贝/移动开销。

  • 传统 C 风格，兼容老代码。

• 缺点

  • 可读性差：调用者需要先声明变量。

  • 容易忽略检查返回值，且不如“单一返回值”直观。

4. std::optional（或 std::variant）+ 结构体／pair

当函数可能“失败”或“无结果”时，可结合 std::optional：

#include <optional>
#include <utility>

std::optional<std::pair<int,int>> div_mod(int a, int b) {
    if (b == 0) return std::nullopt;
    return std::make_pair(a / b, a % b);
}

int main() {
    if (auto res = div_mod(17, 5)) {
        auto [q, r] = *res;
        std::cout << "商 = " << q << ", 余数 = " << r << "\n";
    }
}

• 优点

  • 明确表示“有或无”结果。

• 缺点

  • 语法稍显冗长。

5. 更高级的封装：对象方法返回自身状态

如果返回的两个值本质上是同一个 “实体” 的属性，可以把它们变成一个类的成员，调用者先创建对象然后调用方法：

class Divider {
public:
    Divider(int a, int b): a_(a), b_(b) {}
    void compute() {
        quotient_  = a_ / b_;
        remainder_ = a_ % b_;
    }
    int quotient() const { return quotient_; }
    int remainder() const { return remainder_; }
private:
    int a_, b_, quotient_, remainder_;
};

int main() {
    Divider d(17,5);
    d.compute();
    std::cout << d.quotient() << ", " << d.remainder() << "\n";
}

• 优点

  • 可将“行为”与“数据”封装在一起，面向对象设计。

• 缺点

  • 对于简单场景可能显得过度设计。

总结

方法	语义清晰度	扩展性	性能	典型用法
自定义 struct/class	★★★★★	★★★★★	★★★★☆	强烈推荐，用于几乎所有场景
std::pair/tuple	★★☆☆☆	★★★☆☆	★★★☆☆	轻量，快速；若只有两个值且用结构化绑定，可接受
输出参数（引用/指针）	★☆☆☆☆	★★☆☆☆	★★★★★	C API、性能极致优化场景
std::optional<...>	★★★★☆	★★★☆☆	★★☆☆☆	可能失败的返回；结合结构体或 pair
面向对象封装	★★★★★	★★★☆☆	★★★★☆	复杂业务逻辑，状态驱动场景

最佳实践：如果只是为了返回两三个密切相关的值，首选“自定义结构体+返回值” 或 “std::pair+结构化绑定”（若对 .first/.second 无所谓）。当业务逻辑更复杂、可能失败或需要附加方法时，再考虑面向对象封装或 std::optional。