std::forward

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>

Definido en el archivo de encabezado <utility>
	(1)
template< class T > T&& forward( typename std::remove_reference<T>::type& t ) noexcept;			(desde C++11) (hasta C++14)
template< class T > constexpr T&& forward( std::remove_reference_t<T>& t ) noexcept;			(desde C++14)
		(2)
template< class T > T&& forward( typename std::remove_reference<T>::type&& t ) noexcept;				(desde C++11) (hasta C++14)
template< class T > constexpr T&& forward( std::remove_reference_t<T>&& t ) noexcept;				(desde C++14)

1) Reenvía lvalues ya sea como lvalues o como rvalues, dependiendo de T.

See More

Cuando t es una referencia reenviante (una función argumento que se declara como una referencia a un parámetro de plantilla de función no calificado-cv), esta sobrecarga reenvía el argumento a otra función con la categoría de valor que tenía cuando se pasó a la función llamada.

Por ejemplo, si se usa en un envoltorio como el siguiente, la plantilla se comporta como se describe más abajo:

template<class T>
void wrapper(T&& arg) 
{
    // arg es siempre un lvalue
    foo(std::forward<T>(arg)); // Reenviar como un lvalue o como un rvalue,
	                           // dependiendo de T
}

• Si una llamada a wrapper() pasa un rvalue std::string, entonces T se deduce como std::string (no como std::string&, const std::string&, o std::string&&), y std::forward se asegura que se pasa una referencia rvalue a foo.
• Si una llamada a wrapper() pasa un lvalue std::string constante, entonces T se deduce como const std::string&, y std::forward se asegura que se pasa una referencia lvalue constante a foo.
• Si una llamada a wrapper() pasa un lvalue std::string no constante, entonces T se deduce como std::string&, y std::forward se asegura que se pasa una referencia lvalue no constante a foo.

2) Reenvía rvalues como rvalues y prohibe el reenvío de rvalues como lvalues.

Esta sobrecarga hace posible reenviar el resultado de una expresión (tal como una llamada a función), que puede ser un rvalue o lvalue, como la categoría de valor original de un argumento de referencia reenviante.

Por ejemplo, si un envoltorio no solamente no solo no reenvía su argumento, sino que también llama a una función miembro sobre el argumento, y reenvía su resultado:

// envoltorio transformante 
template<class T>
void wrapper(T&& arg)
{
    foo(forward<decltype(forward<T>(arg).get())>(forward<T>(arg).get()));
}

donde el tipo de arg puede ser

struct Arg
{
    int i = 1;
    int  get() && { return i; } // llamar a esta sobrecarga es rvalue
    int& get() &  { return i; } // llamar a esta sobrecarga es lvalue
};

Intentar reenviar un rvalue como un lvalue, tal como instanciar la forma (2) con un tipo referencia lvalue T, es un error en tiempo de compilación.

Notas

Véase deducción de argumentos de plantilla para las reglas especiales detrás de las referencias reenviantes (T&& usadas como un parámetro de función) y referencias reenviantes para más detalles.

Parámetros

t

-

El objeto a ser reenviado.

Valor de retorno

static_cast<T&&>(t)

Ejemplo

Este ejemplo demuestra el reenvío perfecto del parámetro (o de los parámetros) al argumento del constructor de la clase T. También se demuestra el reenvío perfecto de los paquetes de parámetros.

Ejecuta este código

#include <iostream>
#include <memory>
#include <utility>

struct A {
    A(int&& n) { std::cout << "sobrecarga rvalue, n=" << n << "\n"; }
    A(int& n)  { std::cout << "sobrecarga lvalue, n=" << n << "\n"; }
};

class B {
public:
    template<class T1, class T2, class T3>
    B(T1&& t1, T2&& t2, T3&& t3) :
        a1_{std::forward<T1>(t1)},
        a2_{std::forward<T2>(t2)},
        a3_{std::forward<T3>(t3)}
    {
    }

private:
    A a1_, a2_, a3_;
};

template<class T, class U>
std::unique_ptr<T> make_unique1(U&& u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)));
}

template<class T, class... U>
std::unique_ptr<T> make_unique2(U&&... u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)...));
}

int main()
{   
    auto p1 = make_unique1<A>(2); // rvalue
    int i = 1;
    auto p2 = make_unique1<A>(i); // lvalue

    std::cout << "B\n";
    auto t = make_unique2<B>(2, i, 3);
}

Salida:

sobrecarga rvalue, n=2
sobrecarga lvalue, n=1
B
sobrecarga rvalue, n=2
sobrecarga lvalue, n=1
sobrecarga rvalue, n=3

Complejidad

Constante

Véase también

move (C++11)	Obtiene una referencia r-valor (plantilla de función)
move_if_noexcept (C++11)	Obtiene una referencia r-valor si el constructor de movimiento no lanza una excepción (plantilla de función)