C++
Devolviendo varios valores de una función
Buscar..
Introducción
Hay muchas situaciones en las que es útil devolver varios valores de una función: por ejemplo, si desea ingresar un artículo y devolver el precio y el número en stock, esta funcionalidad podría ser útil. Hay muchas formas de hacer esto en C ++, y la mayoría involucra a la STL. Sin embargo, si desea evitar el STL por alguna razón, todavía hay varias formas de hacer esto, incluyendo structs/classes y arrays .
Uso de parámetros de salida
Los parámetros se pueden usar para devolver uno o más valores; Esos parámetros deben ser punteros o referencias no const .
Referencias:
void calculate(int a, int b, int& c, int& d, int& e, int& f) {
c = a + b;
d = a - b;
e = a * b;
f = a / b;
}
Punteros:
void calculate(int a, int b, int* c, int* d, int* e, int* f) {
*c = a + b;
*d = a - b;
*e = a * b;
*f = a / b;
}
Algunas bibliotecas o marcos de trabajo usan un #define 'vacío' para #define que los parámetros sean parámetros de salida en la firma de la función. Esto no tiene un impacto funcional y se compilará, pero hace que la firma de la función sea un poco más clara;
#define OUT
void calculate(int a, int b, OUT int& c) {
c = a + b;
}
Usando std :: tuple
El tipo std::tuple puede agrupar cualquier número de valores, posiblemente incluyendo valores de diferentes tipos, en un solo objeto de retorno:
std::tuple<int, int, int, int> foo(int a, int b) { // or auto (C++14)
return std::make_tuple(a + b, a - b, a * b, a / b);
}
En C ++ 17, se puede usar una lista de inicializadores de arriostramiento:
std::tuple<int, int, int, int> foo(int a, int b) {
return {a + b, a - b, a * b, a / b};
}
La recuperación de valores de la tuple devuelta puede ser complicada, y requiere el uso de la función std::get template:
auto mrvs = foo(5, 12);
auto add = std::get<0>(mrvs);
auto sub = std::get<1>(mrvs);
auto mul = std::get<2>(mrvs);
auto div = std::get<3>(mrvs);
Si los tipos se pueden declarar antes de que se devuelva la función, entonces se puede emplear std::tie para descomprimir una tuple en variables existentes:
int add, sub, mul, div;
std::tie(add, sub, mul, div) = foo(5, 12);
Si uno de los valores devueltos no es necesario, se puede usar std::ignore :
std::tie(add, sub, std::ignore, div) = foo(5, 12);
Los enlaces estructurados se pueden utilizar para evitar std::tie :
auto [add, sub, mul, div] = foo(5,12);
Si desea devolver una tupla de referencias de lvalor en lugar de una tupla de valores, use std::tie en lugar de std::make_tuple .
std::tuple<int&, int&> minmax( int& a, int& b ) {
if (b<a)
return std::tie(b,a);
else
return std::tie(a,b);
}
lo que permite
void increase_least(int& a, int& b) {
std::get<0>(minmax(a,b))++;
}
En algunos casos raros std::forward_as_tuple lugar de std::tie ; tenga cuidado si lo hace, ya que los temporales pueden no durar lo suficiente como para ser consumidos.
Usando std :: array
El contenedor std::array puede agrupar un número fijo de valores de retorno. Este número debe conocerse en tiempo de compilación y todos los valores de retorno deben ser del mismo tipo:
std::array<int, 4> bar(int a, int b) {
return { a + b, a - b, a * b, a / b };
}
Esto reemplaza los arrays de estilo c de la int bar[4] form int bar[4] . La ventaja es que ahora se pueden usar varias funciones std de c++ . También proporciona funciones útiles como miembros at que es una función de acceso miembro de seguro con la comprobación de encuadernado, y size que le permite devolver el tamaño de la matriz sin cálculo.
Usando std :: pair
La estructura struct template std::pair puede agrupar exactamente dos valores de retorno, de cualquiera de los dos tipos:
#include <utility>
std::pair<int, int> foo(int a, int b) {
return std::make_pair(a+b, a-b);
}
Con C ++ 11 o posterior, se puede usar una lista de inicializadores en lugar de std::make_pair :
#include <utility>
std::pair<int, int> foo(int a, int b) {
return {a+b, a-b};
}
Los valores individuales del std::pair devuelto se pueden recuperar utilizando los objetos miembros first y second del par:
std::pair<int, int> mrvs = foo(5, 12);
std::cout << mrvs.first + mrvs.second << std::endl;
Salida:
10
Usando struct
Se puede usar una struct para agrupar múltiples valores de retorno:
struct foo_return_type {
int add;
int sub;
int mul;
int div;
};
foo_return_type foo(int a, int b) {
return {a + b, a - b, a * b, a / b};
}
auto calc = foo(5, 12);
En lugar de la asignación a campos individuales, se puede usar un constructor para simplificar la construcción de valores devueltos:
struct foo_return_type {
int add;
int sub;
int mul;
int div;
foo_return_type(int add, int sub, int mul, int div)
: add(add), sub(sub), mul(mul), div(div) {}
};
foo_return_type foo(int a, int b) {
return foo_return_type(a + b, a - b, a * b, a / b);
}
foo_return_type calc = foo(5, 12);
Los resultados individuales devueltos por la función foo() se pueden recuperar accediendo a las variables miembro de la struct calc :
std::cout << calc.add << ' ' << calc.sub << ' ' << calc.mul << ' ' << calc.div << '\n';
Salida:
17 -7 60 0
Nota: cuando se utiliza una struct , los valores devueltos se agrupan en un solo objeto y se puede acceder a ellos utilizando nombres significativos. Esto también ayuda a reducir el número de variables extrañas creadas en el alcance de los valores devueltos.
Para desempaquetar una struct devuelta desde una función, se pueden usar enlaces estructurados . Esto coloca los parámetros de salida en una posición uniforme con los parámetros de entrada:
int a=5, b=12;
auto[add, sub, mul, div] = foo(a, b);
std::cout << add << ' ' << sub << ' ' << mul << ' ' << div << '\n';
La salida de este código es idéntica a la anterior. La struct todavía se utiliza para devolver los valores de la función. Esto le permite hacer frente a los campos de forma individual.
Encuadernaciones Estructuradas
C ++ 17 introduce enlaces estructurados, lo que hace que sea aún más fácil tratar con múltiples tipos de devolución, ya que no es necesario confiar en std::tie() ni realizar ningún desempaquetado manual de tuplas:
std::map<std::string, int> m;
// insert an element into the map and check if insertion succeeded
auto [iterator, success] = m.insert({"Hello", 42});
if (success) {
// your code goes here
}
// iterate over all elements without having to use the cryptic 'first' and 'second' names
for (auto const& [key, value] : m) {
std::cout << "The value for " << key << " is " << value << '\n';
}
Los enlaces estructurados se pueden usar de forma predeterminada con std::pair , std::tuple y cualquier tipo cuyos miembros de datos no estáticos sean todos miembros públicos directos o miembros de una clase base no ambigua:
struct A { int x; };
struct B : A { int y; };
B foo();
// with structured bindings
const auto [x, y] = foo();
// equivalent code without structured bindings
const auto result = foo();
auto& x = result.x;
auto& y = result.y;
Si hace que su tipo sea "similar a una tupla", también funcionará automáticamente con su tipo. Un tuple-like es un tipo con tuple_size , tuple_element y get tuple_element :
namespace my_ns {
struct my_type {
int x;
double d;
std::string s;
};
struct my_type_view {
my_type* ptr;
};
}
namespace std {
template<>
struct tuple_size<my_ns::my_type_view> : std::integral_constant<std::size_t, 3>
{};
template<> struct tuple_element<my_ns::my_type_view, 0>{ using type = int; };
template<> struct tuple_element<my_ns::my_type_view, 1>{ using type = double; };
template<> struct tuple_element<my_ns::my_type_view, 2>{ using type = std::string; };
}
namespace my_ns {
template<std::size_t I>
decltype(auto) get(my_type_view const& v) {
if constexpr (I == 0)
return v.ptr->x;
else if constexpr (I == 1)
return v.ptr->d;
else if constexpr (I == 2)
return v.ptr->s;
static_assert(I < 3, "Only 3 elements");
}
}
ahora esto funciona:
my_ns::my_type t{1, 3.14, "hello world"};
my_ns::my_type_view foo() {
return {&t};
}
int main() {
auto[x, d, s] = foo();
std::cout << x << ',' << d << ',' << s << '\n';
}
Usando un consumidor de objetos de función
Podemos proporcionar un consumidor al que se llamará con los múltiples valores relevantes:
template <class F>
void foo(int a, int b, F consumer) {
consumer(a + b, a - b, a * b, a / b);
}
// use is simple... ignoring some results is possible as well
foo(5, 12, [](int sum, int , int , int ){
std::cout << "sum is " << sum << '\n';
});
Esto se conoce como "estilo de paso de continuación" .
Puede adaptar una función devolviendo una tupla a una función de estilo de paso de continuación a través de:
template<class Tuple>
struct continuation {
Tuple t;
template<class F>
decltype(auto) operator->*(F&& f)&&{
return std::apply( std::forward<F>(f), std::move(t) );
}
};
std::tuple<int,int,int,int> foo(int a, int b);
continuation(foo(5,12))->*[](int sum, auto&&...) {
std::cout << "sum is " << sum << '\n';
};
con versiones más complejas que se pueden escribir en C ++ 14 o C ++ 11.
Usando std :: vector
Un std::vector puede ser útil para devolver un número dinámico de variables del mismo tipo. El siguiente ejemplo usa int como tipo de datos, pero un std::vector puede contener cualquier tipo que se pueda copiar de forma trivial:
#include <vector>
#include <iostream>
// the following function returns all integers between and including 'a' and 'b' in a vector
// (the function can return up to std::vector::max_size elements with the vector, given that
// the system's main memory can hold that many items)
std::vector<int> fillVectorFrom(int a, int b) {
std::vector<int> temp;
for (int i = a; i <= b; i++) {
temp.push_back(i);
}
return temp;
}
int main() {
// assigns the filled vector created inside the function to the new vector 'v'
std::vector<int> v = fillVectorFrom(1, 10);
// prints "1 2 3 4 5 6 7 8 9 10 "
for (int i = 0; i < v.size(); i++) {
std::cout << v[i] << " ";
}
std::cout << std::endl;
return 0;
}
Usando el iterador de salida
Se pueden devolver varios valores del mismo tipo pasando un iterador de salida a la función. Esto es particularmente común para funciones genéricas (como los algoritmos de la biblioteca estándar).
Ejemplo:
template<typename Incrementable, typename OutputIterator>
void generate_sequence(Incrementable from, Incrementable to, OutputIterator output) {
for (Incrementable k = from; k != to; ++k)
*output++ = k;
}
Ejemplo de uso:
std::vector<int> digits;
generate_sequence(0, 10, std::back_inserter(digits));
// digits now contains {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}