从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);
这些方法中是否有一种通常是首选的，还是有其他的建议?
编辑:在实际代码中，可能会有两个以上的结果。它们也可能是不同类型的。
当前回答
OO解决方案是创建一个比率类。它不需要任何额外的代码(会节省一些代码)，会明显更干净/清晰，并且会给你一些额外的重构，让你也可以清理这个类之外的代码。
实际上，我认为有人建议返回一个结构，这是足够接近，但隐藏的意图，这需要一个充分考虑的类与构造函数和一些方法，事实上，你最初提到的“方法”(作为返回对)应该最有可能是这个类的成员，返回自己的实例。
我知道你的例子只是一个“例子”，但事实是，除非你的函数做的比任何函数都要多，如果你想让它返回多个值，你几乎肯定会错过一个对象。
不要害怕创建这些小的类来做小的工作——这就是OO的神奇之处——你最终会分解它，直到每个方法都非常小而简单，每个类都非常小而可理解。
另一件事应该是一个错误的指示器:在OO中，你基本上没有数据——OO不是传递数据，一个类需要在内部管理和操作它自己的数据，任何数据传递(包括访问器)都是一个迹象，表明你可能需要重新考虑一些事情。
其他回答
如果你通过引用函数返回一个值,编译器不能存储在寄存器当调用其他函数,因为从理论上讲,第一个函数可以保存变量的地址传递给它的全局变量,和任何subsecuently称为功能可能改变它,所以编译器会有(1)将值从寄存器保存到内存之前调用其他函数和(2)重读的时候需要从内存后再任何这样的调用。
如果通过引用返回，程序的优化将受到影响
有很多方法可以返回多个参数。我会讲得很详尽。
使用参考参数:
void foo( int& result, int& other_result );
使用指针参数:
void foo( int* result, int* other_result );
这样做的好处是，您必须在呼叫站点做一个&，可能会提醒人们这是一个out-parameter。
写出一个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不再能够读取任何作为奖励传递进来的值。
其他定义点的方法可以把数据用构造出来。例如，将东西放置在某个地方的回调。
我们可以返回一个结构:
struct foo_r { int result; int other_result; };
foo_r foo();
whick在每个版本的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值){})时，值回调可以被调用500次。
对于纯粹的精神错乱，你甚至可以在延续上使用延续。
void foo( std::function<void(int, std::function<void(int)>)> result );
其用途如下:
foo( [&](int result, auto&& other){ other([&](int other){
/* code */
}) });
这就允许结果和他者之间存在多一关系。
同样使用统一的值，我们可以这样做:
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开始接收结果。
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 -O3只需要优化std::string: https://godbolt.org/z/Mqbez73Kf
在这里:https://godbolt.org/z/WWKvE3osv，您可以看到GCC将所有返回值打包在一个内存块中(rdi+N)， pod样式，证明没有性能损失。
如果只有几个返回值，我只会通过引用来做，但对于更复杂的类型，你也可以这样做:
static struct SomeReturnType {int a,b,c; string str;} SomeFunction()
{
return {1,2,3,string("hello world")}; // make sure you return values in the right order!
}
如果返回类型只是一个临时返回类型，则使用“static”将返回类型的范围限制在这个编译单元。
SomeReturnType st = SomeFunction();
cout << "a " << st.a << endl;
cout << "b " << st.b << endl;
cout << "c " << st.c << endl;
cout << "str " << st.str << endl;
这绝对不是最漂亮的方法，但它是有效的。
而不是返回多个值，只返回其中一个，并在所需的函数中引用其他的eg:
int divide(int a,int b,int quo,int &rem)
