std::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本质上是你的结构解决方案，但是已经为你定义好了，并且可以适应任何两种数据类型。

而不是返回多个值，只返回其中一个，并在所需的函数中引用其他的eg:

int divide(int a,int b,int quo,int &rem)

如果你通过引用函数返回一个值,编译器不能存储在寄存器当调用其他函数,因为从理论上讲,第一个函数可以保存变量的地址传递给它的全局变量,和任何subsecuently称为功能可能改变它,所以编译器会有(1)将值从寄存器保存到内存之前调用其他函数和(2)重读的时候需要从内存后再任何这样的调用。

如果通过引用返回，程序的优化将受到影响

在这里，我正在编写一个程序，在c++中返回多个值(超过两个值)。此程序在c++14 (g++ 4.9.2)中可执行。程序就像计算器。

#  include <tuple>
# include <iostream>

using namespace std; 

tuple < int,int,int,int,int >   cal(int n1, int n2)
{
    return  make_tuple(n1/n2,n1%n2,n1+n2,n1-n2,n1*n2);
}

int main()
{
    int qut,rer,add,sub,mul,a,b;
    cin>>a>>b;
    tie(qut,rer,add,sub,mul)=cal(a,b);
    cout << "quotient= "<<qut<<endl;
    cout << "remainder= "<<rer<<endl;
    cout << "addition= "<<add<<endl;
    cout << "subtraction= "<<sub<<endl;
    cout << "multiplication= "<<mul<<endl;
    return 0;
}

因此，您可以清楚地理解，通过这种方式，您可以从一个函数返回多个值。使用std::pair只能返回2个值，而std::tuple可以返回两个以上的值。

在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;
}

有很多方法可以返回多个参数。我会讲得很详尽。

使用参考参数:

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开始接收结果。