tuplas - ¿Cuál es la mejor manera de devolver una tupla desde la función en C++ 11?

tipos de tuplas

Question

Quiero devolver algunos valores de una función y quiero empaquetarlos en una tupla. Así que tengo dos posibilidades para la declaración de función:

std::tuple<bool, string, int> f()
{
  ...
  return std::make_tuple(false, "home", 0);
}

y

std::tuple<bool, string, int> f()
{
  ...
  return std::forward_as_tuple(false, "home", 0);
}

Estas funciones son equivalentes? ¿Entre estas funciones cuál prefieres?

Answer 1

Yo prefiero,

std::tuple<bool, std::string, int> f()
{
  ...
  return { false, "home", 0 };
}

EDITAR 1

El código anterior en realidad se está compilando para mí bajo clang / libc ++ trunk. Como @AndyProwl comentó en la sección de comentarios, esto no debería hacerlo ya que el constructor std :: tuple es explícito y la devolución a través de la sintaxis de la lista de inicialización se encuentra en el contexto de copia-inicialización, por lo tanto, copy-list-initialization, que falla cuando se compara un constructor explícito.

No sé la razón por la que clang / libc ++ está pasando, supongo que es un error en libc ++. De todos modos, es triste que uno no pueda hacer eso para las tuplas ...

Creo que me di cuenta de lo triste (para mí, por fin) que es, en general. Me estaba acostumbrando a esa sintaxis, pero uno se ve obligado a saber de antemano si el tipo que regresa contiene un constructor explícito en cualquier momento para que funcione.

Editar 2

Esta es de hecho una extensión libc ++. Para obtener más información, consulte la respuesta de Howard Hinnant aquí: https://stackoverflow.com/a/14963014 .

También está actualmente abierto en la lista de errores de libc ++: http://llvm.org/bugs/show_bug.cgi?id=15299 .

Esta es la propuesta relevante: Daniel Krügler, Mejorando par y tupla .

En resumen esto es lo que pasa con libc ++:

#include <tuple>
#include <string>

struct S
{
    explicit S(int) {}
};

int main()
{
    std::tuple<int, std::string> t1 = { 1, "hello" }; // ok
    std::tuple<std::string> t2      = "hello";        // ok
    std::tuple<int, S> t3           = { 1, 1 };       // fail: an *element* is to be constructed explicitly
}

Answer 2

std::forward_as_tuple() crea una tupla de referencias . Ya que estás devolviendo una tuple<bool, string, int> todos modos, los dos terminan siendo equivalentes en este caso , pero creo que el primer enfoque es más claro: usar forward_as_tuple() cuando no estás enviando nada es confuso.

Además, como lo mencionó Sebastian Redl en los comentarios, make_tuple() permitiría al compilador realizar una elision de copia - por el párrafo 12.8 / 31 del Estándar C ++ 11, mientras que forward_tuple() no (ya que lo que devuelve no tiene el mismo tipo que el tipo de retorno de la función).