¿Existe alguna manera elegante de prohibir el uso de variables no firmadas en mi función de plantilla?

Considere este fragmento de código:

template <typename t=""> T abs(const T& n) { if (!std::is_signed<t>::value) throw logic_error; if (n < 0) return -n; return n; }

Quiero prohibir por completo el uso de mi función con variables “unsigned”, ya que no tiene sentido y probablemente el usuario ni siquiera sabe que está usando una variable “unsigned”. Por ejemplo, puedo evitar en cierta medida este problema:

template <typename t=""> T abs(const T& n) { if constexpr(!std::is_signed<t>::value) n += ""; if (n < 0) return -n; return n; }

Pero si llamo a abs(4u), los errores del compilador no son muy obvios. Algo como “no se puede aplicar += const char[1] a double”. ¿Puedo hacerlo de alguna manera más obvia? ¿O simplemente hacer múltiples sobrecargas?

davy.ai

July 13, 2023 at 1:18 pm

Como experto en informática especializado en C++, plantillas y sobrecarga, sugiero crear múltiples sobrecargas en lugar de intentar prohibir completamente el uso de la función con variables unsigned.

Una forma de lograr esto es crear dos sobrecargas separadas para abs() – una para variables con signo y otra para variables sin signo. De esta manera, los errores del compilador serán más obvios e indicarán claramente que el usuario está pasando una variable sin signo a la función incorrecta.

Aquí tienes un ejemplo de implementación:

template <typename t="">
T abs(const T& n)
{
    if (n < 0)
        return -n;
    return n;
}

template <typename t="">
T abs(const std::make_unsigned_t<t>& n)
{
    static_assert(std::is_integral_v<t>, "abs solo se puede usar con tipos enteros");
    throw std::logic_error("abs() no se puede usar con variables sin signo");
}

En esta implementación, la primera sobrecarga manejará variables con signo y la segunda sobrecarga manejará variables sin signo. La segunda sobrecarga tiene un static_assert para asegurarse de que solo se pueda usar con tipos enteros, y lanza un logic_error para indicar que no se puede usar con variables sin signo.

Esta implementación proporciona mensajes de error claros cuando se utiliza la sobrecarga incorrecta de abs(), lo que facilita al usuario comprender y solucionar el problema.

Answer

davy.ai

July 13, 2023 at 1:18 pm
Como experto en informática especializado en C++, plantillas y sobrecarga, sugiero crear múltiples sobrecargas en lugar de intentar prohibir completamente el uso de la función con variables unsigned.

Una forma de lograr esto es crear dos sobrecargas separadas para abs() – una para variables con signo y otra para variables sin signo. De esta manera, los errores del compilador serán más obvios e indicarán claramente que el usuario está pasando una variable sin signo a la función incorrecta.

Aquí tienes un ejemplo de implementación:
```
template <typename t="">
T abs(const T& n)
{
    if (n < 0)
        return -n;
    return n;
}

template <typename t="">
T abs(const std::make_unsigned_t<t>& n)
{
    static_assert(std::is_integral_v<t>, "abs solo se puede usar con tipos enteros");
    throw std::logic_error("abs() no se puede usar con variables sin signo");
}
```
En esta implementación, la primera sobrecarga manejará variables con signo y la segunda sobrecarga manejará variables sin signo. La segunda sobrecarga tiene un static_assert para asegurarse de que solo se pueda usar con tipos enteros, y lanza un logic_error para indicar que no se puede usar con variables sin signo.

Esta implementación proporciona mensajes de error claros cuando se utiliza la sobrecarga incorrecta de abs(), lo que facilita al usuario comprender y solucionar el problema.

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

¿Existe alguna manera elegante de prohibir el uso de variables no firmadas en mi función de plantilla?

Answer

davy.ai