当前位置：首页 > ops >正文

多返回值（C++)

ops 2025/9/7 3:08:09

多返回值

1. 自定义结构体（或 class）
2. std::pair / std::tuple
- 2.1 std::pair
- 2.2 std::tuple
3. 输出参数（Output Parameters）
4. std::optional（或 std::variant）+ 结构体／pair
5. 更高级的封装：对象方法返回自身状态
总结

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`
面向对象封装	★★★★★	★★★☆☆	★★★★☆	复杂业务逻辑，状态驱动场景