std::reference_wrapper en una guía de deducción de argumentos de plantilla de clase?
Esto se acerca a una revisión de código/mejores prácticas, pero… ¿es razonable hacer esto?
// Una metafunción para mapear T -> T pero std::reference<><t>> -> T&:
template <typename t=""> struct RefWrapperToRef { using type = T; };
template <typename t=""> struct RefWrapperToRef<><><t>>> { using type = T&; };
// Una metafunción similar a std::remove_reference pero std::reference<><t>> -> T.
template <typename t=""> struct RemoveRefAndRefWrapper {
using type = std::remove_reference_t<typename></typename><t>::type>;
};
template <typename t="">
struct S {
static_assert(not std::is_rvalue_reference_v<t>, "Puede haber un lugar para ello, pero es peligroso.");
T x;
// Permitir la construcción a partir de una referencia universal mediante el reenvío.
template <typename u="">
explicit S(U&& x) : x(std::forward<u>(x)) {
static_assert(std::is_same_v<><typename></typename><u>::type>,
std::remove_cv_t<typename></typename><t>::type>>);
static_assert(not std::is_reference_v<t> or std::is_lvalue_reference_v<typename></typename><u>::type>);
}
};
template <typename t="">
S(T) -> S<typename></typename><t>::type>;
Es decir, si tienes int x y llamas a S(std::ref(x)), asumiremos que deseas un S<int&>. Esto parece elegante, simple y sin ambigüedades pero ligeramente mágico.
Enlace al código</int&>
davy.ai
El código proporcionado define metafunciones y una plantilla de clase
Sque permite la construcción a partir de una referencia universal mediante forwarding. La plantillaSutiliza las metafunciones para manejar referencias y envoltorios de referencia.La pregunta es si este enfoque es razonable.
En general, el uso de metafunciones y plantillas para manejar referencias y envoltorios de referencia puede ayudar a simplificar el código y hacerlo más flexible. En este caso específico, permite un manejo elegante de referencias y envoltorios de referencia en el constructor de
S.Sin embargo, al igual que con cualquier código de plantilla, puede ser complejo y difícil de entender, y puede requerir conocimientos avanzados de C++. Además, el uso de metafunciones y plantillas puede dificultar la depuración y diagnóstico de problemas con el código.
En general, aunque este enfoque es razonable si se utiliza con cuidado y comprensión, puede no ser apropiado o necesario para todos los casos de uso. Al igual que con cualquier implementación de código, conviene aplicar las mejores prácticas y realizar una revisión de código para asegurarse de que sea correcto, mantenible y adecuado para la tarea en cuestión.