从C++函数中返回多个值时是否有一种首选的方法？例如，想象一个将两个整数相除并返回商和余数的函数。我经常见到的一种方式是使用引用参数：
void divide(int dividend, int divisor, int& quotient, int& remainder);
一种变体是返回一个值，并通过引用参数传递另一个值：
int divide(int dividend, int divisor, int& remainder);
另一种方法是声明一个结构体来包含所有的结果，然后返回它：
struct divide_result {
int quotient;
int remainder;
};
divide_result divide(int dividend, int divisor);
这些方式中是否有一种通常更受青睐，或者还有其他建议？
编辑：在实际的代码中，可能会有超过两个结果。它们也可能是不同的类型。
在C++11中，你可以：
#include <tuple>
std::tuple<int, int> divide(int dividend, int divisor) {
return std::make_tuple(dividend / divisor, dividend % divisor);
}
#include <iostream>
int main() {
using namespace std;
int quotient, remainder;
tie(quotient, remainder) = divide(14, 3);
cout << quotient << ',' << remainder << endl;
}
在 C++17 中：
#include <tuple>
std::tuple<int, int> divide(int dividend, int divisor) {
return {dividend / divisor, dividend % divisor};
}
#include <iostream>
int main() {
using namespace std;
auto [quotient, remainder] = divide(14, 3);
cout << quotient << ',' << remainder << endl;
}
或者使用结构体：
auto divide(int dividend, int divisor) {
struct result {int quotient; int remainder;};
return result {dividend / divisor, dividend % divisor};
}
#include <iostream>
int main() {
using namespace std;
auto result = divide(14, 3);
cout << result.quotient << ',' << result.remainder << endl;
// or
auto [quotient, remainder] = divide(14, 3);
cout << quotient << ',' << remainder << endl;
}
为了返回两个值，我使用std::pair（通常通过typedef）。如果要返回多于两个结果，请考虑使用boost::tuple（在C++11及更高版本中有std::tuple）。
随着C++17引入结构化绑定，返回std::tuple可能会成为被广泛接受的标准。
std::tuple。 - Ferrucciostd::tie。https://dev59.com/L3E85IYBdhLWcg3w3Xlp#2573822 - fdermishin就我个人而言，我通常不喜欢使用返回参数，原因如下：
我也对成对/元组技术有一些保留意见。主要问题是返回值通常没有自然顺序。代码读者该怎么知道result.first是商还是余数？实现者可能会改变顺序，这将破坏现有代码。如果这些值是相同类型的，则没有编译器错误或警告，这尤其危险。实际上，这些论点也适用于返回参数。
这里是另一个代码示例，稍微复杂一些：
pair<double,double> calculateResultingVelocity(double windSpeed, double windAzimuth,
double planeAirspeed, double planeCourse);
pair<double,double> result = calculateResultingVelocity(25, 320, 280, 90);
cout << result.first << endl;
cout << result.second << endl;
这会打印地速和航向，还是航向和地速？不太明显。
与此相比：
struct Velocity {
double speed;
double azimuth;
};
Velocity calculateResultingVelocity(double windSpeed, double windAzimuth,
double planeAirspeed, double planeCourse);
Velocity result = calculateResultingVelocity(25, 320, 280, 90);
cout << result.speed << endl;
cout << result.azimuth << endl;
我认为这更清晰易懂。
所以，我认为一般情况下，结构体技术是我的首选。在某些情况下，成对/元组的想法可能是一个很好的解决方案。我希望尽可能避免返回参数。
struct声明为Velocity的建议很好。但是，一个担忧是它会污染命名空间。我想，使用C++11，struct可以有一个长类型名称，可以使用auto result = calculateResultingVelocity(...)。 - Huguesstruct { int a, b; } my_func();。这可以像这样使用:auto result = my_func();。但C++不允许这样做:"不能在返回类型中定义新类型"。所以我必须创建类似于struct my_func_result_t的结构体... - anton_rhauto返回局部类型，因此可以轻松地获得auto result = my_func();。 - ildjarn有很多方法可以返回多个参数。我将详细说明。
void foo( int& result, int& other_result );
void foo( int* result, int* other_result );
这种方法的优点是在调用时必须使用&，可能会提醒人们这是一个输出参数。
out<?>模板并使用它：template<class T>
struct out {
std::function<void(T)> target;
out(T* t):target([t](T&& in){ if (t) *t = std::move(in); }) {}
out(std::optional<T>* t):target([t](T&& in){ if (t) t->emplace(std::move(in)); }) {}
out(std::aligned_storage_t<sizeof(T), alignof(T)>* t):
target([t](T&& in){ ::new( (void*)t ) T(std::move(in)); } ) {}
template<class...Args> // TODO: SFINAE enable_if test
void emplace(Args&&...args) {
target( T(std::forward<Args>(args)...) );
}
template<class X> // TODO: SFINAE enable_if test
void operator=(X&&x){ emplace(std::forward<X>(x)); }
template<class...Args> // TODO: SFINAE enable_if test
void operator()(Args...&&args){ emplace(std::forward<Args>(args)...); }
};
void foo( out<int> result, out<int> other_result )
一切都很好。foo不能再读取任何作为奖励传递的值。
其他定义可以放置数据的方法可用于构造out。例如，回调以将事物放置在某个位置。
struct foo_r { int result; int other_result; };
foo_r foo();
这在每个版本的C++中都能正常工作，在c++17中还允许：
auto&&[result, other_result]=foo();
零成本。由于保证省略，甚至可以不移动参数。
std::tuple：std::tuple<int, int> foo();
这种方法的缺点是参数没有名称。这使得c++17成为可能：
auto&&[result, other_result]=foo();
同样地，在c++17之前，我们可以这样做：
int result, other_result;
std::tie(result, other_result) = foo();
这有点棘手。但是，保证省略在这里不起作用。
进入更陌生的领域（在out<>之后！），
void foo( std::function<void(int result, int other_result)> );
现在的调用者执行以下操作：
foo( [&](int result, int other_result) {
/* code */
} );
void get_all_values( std::function<void(int)> value )
当你使用 get_all_values([&](int value){} ) 时，value 回调可能会被调用500次。
为了纯粹的疯狂，甚至可以在 continuation 上使用 continuation。
void foo( std::function<void(int, std::function<void(int)>)> result );
使用方式如下：
foo( [&](int result, auto&& other){ other([&](int other){
/* code */
}) });
这将允许result和other之间的多对一关系。
再次使用统一值，我们可以这样做：
void foo( std::function< void(span<int>) > results )
void foo( std::function< void(span<int>) > results ) {
int local_buffer[1024];
std::size_t used = 0;
auto send_data=[&]{
if (!used) return;
results({ local_buffer, used });
used = 0;
};
auto add_datum=[&](int x){
local_buffer[used] = x;
++used;
if (used == 1024) send_data();
};
auto add_data=[&](gsl::span<int const> xs) {
for (auto x:xs) add_datum(x);
};
for (int i = 0; i < 7+(1<<20); ++i) {
add_datum(i);
}
send_data(); // any leftover
}
std::function 有点重。因此，我们需要一个function_view，它永远不会分配内存。std::function<void(std::function<void(int result, int other_result)>)> foo(int input);
在这种情况下，foo 不是接受回调函数并调用它，而是返回一个接受回调函数的函数。
foo(7)([&](int result, int other_result){ /* code */ });
这种方式通过使用单独的括号来打破输出参数与输入参数之间的联系。
通过使用variant和c++20协程，您可以将foo作为返回类型变体（或只是返回类型）的生成器。 语法尚未确定，因此我不会给出示例。
在信号和插槽的世界中，一个公开一组信号的函数：
template<class...Args>
struct broadcaster;
broadcaster<int, int> foo();
允许您创建一个异步工作并在完成时广播结果的foo。
沿着这条线，我们有各种管道技术，其中函数不执行任何操作，而是安排以某种方式连接数据，并且执行相对独立。
foo( int_source )( int_dest1, int_dest2 );
int_source提供整数之前不会执行任何操作。当它提供整数时，int_dest1和int_dest2开始接收结果。auto&&[result, other_result]=foo(); 的信息。谢谢！ - jjmontesauto&&[result, other_result]=foo(); 中，为什么要使用 auto&& 而不是 auto？ - starrietauto& 表示“可修改引用”，auto const& 表示“不可修改引用，可能是扩展临时变量”，auto 表示“复制一份”。我使用 auto&& 表示“我不在乎，你帮我解决，可以是具有生命周期延长的临时变量，也可以是引用，不是我的问题，我对任何东西都满意”。 - Yakk - Adam NevraumontT&& 表示右值引用，所以我认为使用 auto& 或 auto&& 而不是 auto(拷贝) 会产生悬空引用。使用 auto& 或 auto&& 捕获函数的返回值是否可以？另外，我不明白“我不在乎，你帮我解决”怎么能行。如果我理解错了什么，请告诉我，我正在努力学习这些概念。谢谢 :) - starrietstd::pair<int, int> divide(int dividend, int divisor)
{
// :
return std::make_pair(quotient, remainder);
}
std::pair<int, int> answer = divide(5,2);
// answer.first == quotient
// answer.second == remainder
std::pair本质上是您的结构体解决方案，但已为您定义并准备好适应任何两种数据类型。
这完全取决于实际函数和多个值的含义，以及它们的大小：
使用C++17，您还可以返回一个或多个不可移动/不可复制的值（在某些情况下）。通过新的保证返回值优化，返回不可移动类型的可能性得以实现，并且与聚合体和所谓的模板构造函数很好地组合。
template<typename T1,typename T2,typename T3>
struct many {
T1 a;
T2 b;
T3 c;
};
// guide:
template<class T1, class T2, class T3>
many(T1, T2, T3) -> many<T1, T2, T3>;
auto f(){ return many{string(),5.7, unmovable()}; };
int main(){
// in place construct x,y,z with a string, 5.7 and unmovable.
auto [x,y,z] = f();
}
这个东西的好处在于它保证不会造成任何拷贝或移动。你也可以将many结构体变量定义为可变参数。更多细节请见：
针对这个问题，面向对象的解决方案是创建一个比例类。这不需要额外的代码（甚至可以节省一些代码），会更加清晰简洁，并且可以让你进行其他的重构以简化这个类之外的代码。
其实我认为有人建议返回一个结构体，虽然很接近但隐藏了意图——这需要是一个完整设计的类，包括构造函数和一些方法。实际上，你最初提到的“方法”（返回这个组合）很可能应该成为这个类的成员方法，返回一个自身的实例。
我知道你的例子只是一个“例子”，但事实上，除非你的函数做的比任何函数都多，否则如果你想要返回多个值，你几乎肯定缺少一个对象。
不要害怕创建这些小类来完成一些小任务——这就是面向对象的魔力——你可以将它分解成每个方法都非常小而简单，每个类都很小而易懂。
另一个表明有问题的迹象是：在面向对象中，你基本上没有数据——面向对象不是关于传递数据的，类需要在内部管理和操作自己的数据，任何数据传递（包括访问器）都表明你可能需要重新思考一些东西。
使用C++17, 使用std::make_tuple, 结构化绑定，尽可能使用auto:
#include <tuple>
#include <string>
#include <cstring>
auto func() {
// ...
return std::make_tuple(1, 2.2, std::string("str"), "cstr");
}
int main() {
auto [i, f, s, cs] = func();
return i + f + s.length() + strlen(cs);
}
使用 -O1 时，代码可以完全进行优化：https://godbolt.org/z/133rT9Pcq
只有当需要优化 std::string 时，才需要 -O3：https://godbolt.org/z/Mqbez73Kf
在这里：https://godbolt.org/z/WWKvE3osv，你可以看到 GCC 将所有返回值打包在单个内存块（rdi+N）中，像 POD 风格一样，证明没有性能损失。
在C（以及因此也是C ++）标准中，使用<stdlib.h>（或<cstdlib>）中的div，ldiv（以及在C99中的lldiv ）函数返回结构体已经有先例。
'返回值和返回参数混合'通常是最不清晰的。
在C中，让函数通过返回状态并通过返回参数返回数据是明智的；在C++中，您可以使用异常来传递失败信息，这种方式不太明显可行。
如果有两个以上的返回值，则类似结构体的机制可能是最好的选择。
struct行移到函数体外部，并将auto函数返回替换为result）。 - oblitumdivide函数的定义放入一个单独的cpp文件中，我遇到了错误error: use of ‘auto divide(int, int)’ before deduction of ‘auto’。我该如何解决？ - Adriaan