Concepto tipo de retorno requisito sintaxis dos versus un parámetro de plantilla.
Estoy preguntándome cómo se define std::same_as
y cómo lo usamos en un concepto o requisito.
Ejemplo:
void f1() { }
bool f2() { return true; }</p>
<p>template < typename T>
void Do( T func )
{
if constexpr ( requires { { func() } -> std::same_as<bool>; } )
{<br>
std::cout << "La función devuelve bool " << std::endl;
} </p>
<pre><code>if constexpr ( requires { { func() } -> std::same_as<void>; } )
{
std::cout << "La función devuelve void " << std::endl;
}
</code></pre>
<p>}</p>
<p>int main()
{
Do( f1 );
Do( f2 );
}
Eso funciona como se espera.
Pero si veo la definición de std::sameas encuentro una posible implementación:
namespace detail {
template< class T, class U >
concept SameHelper = std::issame_v<T, U>;
}</p>
<p>template< class T, class U >
concept same_as = detail::SameHelper<T, U> && detail::SameHelper<U, T>;
Y lo que me hace preguntarme es que veo dos argumentos de plantilla T
y U
en ese caso mientras que solo necesitamos escribir uno como { { func() } -> std::same_as<bool>; }
.
¿Es alguna especie de magia que un { { func() } -> std::same_as<bool>; }
se convierte en std::same_as<magic_return_type, bool>
en ese caso?
davy.ai
El concepto
std::same_as
se define como una plantilla que toma dos argumentos de tipoT
yU
. Comprueba siT
yU
son del mismo tipo. Se puede utilizar en conceptos o requisitos para limitar los tipos de argumentos de plantilla o parámetros de función.En el ejemplo proporcionado,
std::same_as
se utiliza para comprobar el tipo de retorno de una función pasada como argumento de plantilla en la plantilla de funciónDo
. La sintaxis{ { func() } -> std::same_as<bool>; }
es en realidad un atajo para{ { func() } -> std::same_as<decltype(func()), bool="">; }
. Es decir, se compara el tipo de retorno defunc
conbool
.La implementación de
std::same_as
utiliza un concepto auxiliarSameHelper
, que comprueba si sus dos argumentos de tipo son iguales utilizandostd::is_same_v
.std::same_as
asegura que cualquier par de tiposT
yU
para los cualesSameHelper<t, u="">
ySameHelper<u, t="">
son ambostrue
se consideran del mismo tipo.Por lo tanto, no hay magia involucrada. La sintaxis
-> std::same_as<bool>
especifica el tipo de retorno al que se comparadecltype(func())
, y el conceptostd::same_as
en sí utiliza dos argumentos de tipo para comprobar si dos tipos son iguales.</u,></t,></decltype(func()),>