在C++编程中，我们常常遇到需要从一个函数返回多个值的场景。然而，C++语法层面只允许函数返回一个值，这就需要开发者通过一些“手工活”来巧妙实现。
常见的做法包括使用引用或指针作为输出参数，或者定义专用的结构体。甚至，在更早期的实践中，有人会通过编写宏来模拟多返回值功能。
当年没有 std::tuple 的日子
在C++98时代，标准库中并没有 std::tuple 这个容器。但业务需求早已存在：例如解析一个字符串，需要拆出主机名和端口号，计算某个结果的同时还要返回一个错误码。开发者们为了实现“返回两个值”这个简单的想法，不得不先学会“如何把值带出去”的各种技巧。
坑是怎么来的：out参数
最常见的手法就是使用输出（out）参数。函数表面上返回一个 bool 表示成功与否，真正的数据则通过引用（或指针）参数“塞”给调用者。
如果你刚从C语言转来，可以将“引用”暂时理解为“变量的别名”。它看起来像在传值，但实际上能修改外部的那个变量。指针就更熟悉了，本质也是为了让函数能修改外部的数据。
bool parse_endpoint(const std::string& s, std::string& host, int& port);
这种写法很“C风格”。但阅读起来像是在办手续：你需要先准备好 host 和 port 这两个变量，再把它们传递进去。更麻烦的是，你必须确保每个调用点都记得检查那个 bool 返回值。
线上啪一下：失败路径把旧值带进了下一次
假设你写了一个小服务，从配置文件里读取地址列表，每行格式是 host:port。某天凌晨，运维改配置时不小心在某行多打了一个空格。
然后线上就出问题了。
std::string host;
int port = 0;
for (auto& line : lines) {
parse_endpoint(line, host, port); // 糟糕！忘记了检查返回值
connect(host, port);
}
这段代码最坏的地方不在于“解析失败”，而在于解析失败后，host 和 port 变量很可能还保持着上一次循环的成功值。下一次调用 connect(host， port) 时，你以为它连接的是当前行，实际上它连的是上一行。日志看起来一切正常，但排查问题能把人逼疯，因为失败路径和数据路径完全混在了一起。
另一条路：临时 struct（更干净，但也更累）
于是，有人提出直接返回一个结构体。别让调用方“自备容器”。
struct Endpoint {
std::string host;
int port;
};
Endpoint parse_endpoint2(const std::string& s);
这确实更像“返回一个值”，逻辑清晰，也更容易进行单元测试。但你很快会面临另一个现实问题：这个类型可能只在这个函数中使用一次，你却需要为它想一个名字。它应该放在哪个头文件？会不会污染命名空间？将来加一个字段是不是要改动很多地方？在小项目里尚可接受，但对于编写泛型库的作者来说，这就很头疼了。
从坑里爬出来：std::tuple（一个“匿名 struct”）
后来，Boost库率先实现了 boost::tuple，再后来C++标准库的Technical Report 1（TR1）中也收录了一版。最终在C++11，std::tuple 正式成为标准库的一部分。
Boost库可以理解为“社区高手们制作的C++扩展包”，当年很多现代特性都是先在Boost中验证可行性，再逐步融入标准。TR1则可以看作是“标准库的一次正式预告片”。
你可能会好奇：tuple 听起来并不复杂，为什么拖到C++11才彻底定型？核心原因在于C++11之前，模板无法原生支持“可变数量的类型参数”。你只能编写 Tuple2<T1， T2>， Tuple3<T1， T2， T3>，想支持到10个元素，就得写10套不同的类模板，或者依靠预处理器宏来生成这些代码。在Boost的tuple时代，这种脏活累活经常交给预处理器。
C++11引入了变参模板（variadic templates），于是我们看到 tuple<Ts...> 这样的写法。这里的 ... 意味着“这里接受一串类型”。自此，tuple 才真正成为一个可灵活扩展的基础设施。
你可以把它理解为一个“匿名的结构体”：它有多个字段，但字段没有名字，只按照位置（从0开始索引）来访问。这听起来不够优雅，但它解决的是“组织代码流”的问题：让多返回值变成一个真正的、可以传递的“值”，不再依赖外部变量来承接。很多时候，多返回值不是语法糖，而是在拯救你的数据流清晰度。
最常见的用法：打包返回 + get
以前面的解析函数为例，现在我们用 tuple 将“成功标识”和“数据”一起打包返回。
#include <tuple>
#include <string>
std::tuple<bool， std::string, int> parse_endpoint3(const std::string& s);
auto r = parse_endpoint3(line);
bool ok = std::get<0>(r);
auto host = std::get<1>(r);
int port = std::get<2>(r);
std::get<0>(r) 的意思是获取tuple r 中的第0个元素。这是一个编译期的索引操作。
所谓“编译期”，意味着在程序运行之前，编译器就能检查你写的索引是否合法。你可能会问，为什么这里是 get<0> 而不是 get(0)？原因很朴素：tuple每个位置元素的类型可能都不同，第0个是 bool，第1个是 std::string。如果你传入一个运行时的变量 int i，编译器就无法推断 get(i) 应该返回什么类型。而写成 std::get<3>(r)（如果tuple只有3个元素），编译器会直接报错，避免了留下一个“运行时炸弹”。
当然，get<0>/get<1> 这种写法，读起来依然像是在操作数组，不够直观。
不想写 get<0>：用 tie 解包（C++11很实用）
C++11中一个常用的搭配是 std::tie。你可以把它理解为“将一组变量绑定成一个接收器”。更具体地说，它会生成一个“由这些变量的引用所构成的tuple”。因此，你可以把它放在赋值语句的左边，让右边的tuple把值依次赋给这些变量。
也正因为 tie 生成的是引用，它只适合在一行内完成“接收”操作，不要将它保存起来四处传递，更不要将它从函数中返回。记住一句：tie 不存储值，它只是变量的“提手”。
bool ok = false;
std::string host;
int port = 0;
std::tie(ok, host, port) = parse_endpoint3(line);
if (!ok) return;
connect(host, port);
这样一来，数据流就清爽多了：成功就使用，失败就返回。数据不会偷偷带着旧值往下流淌。
还有一个实用小技巧：如果你不关心tuple中的某个位置，可以使用 std::ignore 来忽略它。
std::tie(std::ignore， host, port) = parse_endpoint3(line);
再来一个小项目味的例子：多字段比较
假设你写了一个小工具，需要将日志按两个字段排序：先按 user_id，再按 timestamp。你当然可以手写一堆 if-else 逻辑，但在许多C++工程中，会看到这样的写法：
#include <tuple>
struct Log {
int user_id;
int ts;
};
bool operator<(const Log& a, const Log& b) {
return std::tie(a.user_id, a.ts) < std::tie(b.user_id, b.ts);
}
这里利用了tuple的“字典序比较”特性：先比较第0个元素，如果相等再比较第1个元素，以此类推。其逻辑与你手写的 if 完全一致，但代码更加简洁。
横向对比：out参数、struct、pair、tuple
到这里，你可能会问：“我到底该用哪个？” 一个直观的经验是：你不是在选择语法，而是在选择“数据如何流动”。
- out参数：写起来省事，但最容易让程序状态走入歧途。忘记检查一次返回值，就可能带着陈旧数据运行很久。
- struct：可读性最好，字段有明确的名字。但你需要专门定义一个类型，并考虑它的存放位置。
std::pair：可以看作是“只有两个元素的tuple”。它出现得更早，在标准库中使用非常广泛。当你只需要返回两个值时，std::pair 通常更轻量。
#include <utility>
#include <string>
std::pair<std::string， int> parse_endpoint_pair(const std::string& s);
auto p = parse_endpoint_pair(line);
connect(p.first, p.second);
first/second 虽然也不算完美，但比 get<0>/get<1> 更像“人话”。标准库中有大量接口使用 pair 来返回两个值，例如 std::minmax：
#include <algorithm>
#include <utility>
auto mm = std::minmax(3, 7);
int lo = mm.first;
int hi = mm.second;
再比如 map::insert，它会返回一个 pair，包含插入位置的迭代器以及一个表示是否插入成功的 bool：
#include <map>
#include <string>
std::map<std::string, int> m;
auto r = m.insert({"a"， 1});
bool inserted = r.second;
std::tuple：当需要返回三个或以上的值时，它的优势开始显现。你无需为“一次性”的返回值专门创造一个命名类型。
#include <tuple>
#include <string>
std::tuple<std::string, int， bool> parse_endpoint4(const std::string& s);
std::string host;
int port = 0;
bool ok = false;
std::tie(host， port, ok) = parse_endpoint4(line);
如果不想手写冗长的 std::tuple<...> 类型，可以使用 std::make_tuple 让编译器自动推导类型：
return std::make_tuple(host, port, ok);
这种 tie 解包的写法，左边像是在“解构”，右边像是在“返回一个值”，中间省去了out参数那种“先准备容器再递进去”的仪式感。
一个更完善的写法：把错误信息也带回来
新手编写解析函数时，最容易写成“失败就返回 false”，然后把具体的失败原因丢掉了。利用 tuple，你可以把错误信息也一并返回。
#include <tuple>
#include <string>
std::tuple<bool， std::string, std::string, int> parse_endpoint5(const std::string& s);
bool ok = false;
std::string err;
std::string host;
int port = 0;
std::tie(ok, err, host， port) = parse_endpoint5(line);
这样，你就不会写出那种“线上服务出问题但日志里什么线索都没有”的代码。当然，如果你发现 tuple 的字段越来越多，这就是一个强烈的信号：是时候回到使用 struct 了。
tuple 为什么总出现在泛型库里
如果你主要编写业务代码，很多时候，一个小 struct 仍然是可读性最佳的选择。tuple 真正擅长的场景是另一类：当你编写模板库或泛型代码时，你面对的不是具体的“两个int”，而是“一串未知的类型”。你需要一个容器，能把这串类型当成一个完整的值来传递、组合和操作。此时，tuple 就变成了不可或缺的基础设施。
小结
struct 更像是“给人阅读的”，字段有名字，一目了然。tuple 更像是“给类型系统使用的”，它并不旨在替代结构体，而更像是一条类型安全的管道，让“多个东西”可以像“一个东西”那样在代码中流畅地移动。理解这些不同方法的适用场景，能帮助你在C++项目中做出更清晰、更稳健的设计。想了解更多深入的C++工程实践，欢迎访问云栈社区与其他开发者交流探讨。
发表于 昨天 19:55
|
查看: 1|
回复: 0
