c++ - que - programa para convertir unidades de medida en c#

¿La función de conversión para la comprobación de errores se considera buena?

Question

Me gustaría tener una forma sencilla de verificar si un objeto es válido. Pensé en una función de conversión simple, algo como esto:

operator bool() const { return is_valid; }

Comprobar que sea válido sería muy simple ahora

// is my object invalid?
if (!my_object) std::cerr << "my_object isn''t valid" << std::endl;

¿Se considera esto una buena práctica?

Answer 1

En C ++ 03, necesitas usar el lenguaje bool seguro para evitar las cosas malas:

int x = my_object; // this works

En C ++ 11 puedes usar una conversión explícita:

explicit operator bool() const
{
    // verify if valid
    return is_valid;
}

De esta manera, debes ser explícito sobre la conversión a bool, para que ya no puedas hacer locuras por accidente (en C ++ siempre puedes hacer locuras a propósito):

int x = my_object; // does not compile because there''s no explicit conversion
bool y = bool(my_object); // an explicit conversion does the trick

Esto todavía funciona con normalidad en lugares como if y while que requieren una expresión booleana, porque la condición de esas declaraciones se convierte contextualmente a bool:

// this uses the explicit conversion "implicitly"
if (my_object)
{
    ...
}

Esto se documenta en §4 [conv] :

Una expresión e puede convertirse implícitamente a un tipo T si y solo si la declaración T t=e; está bien formado, para alguna variable temporal inventada t (§8.5). Ciertas construcciones de lenguaje requieren que una expresión se convierta en un valor booleano. Se dice que una expresión e aparece en dicho contexto se convierte contextualmente a bool y está bien formada si y solo si la declaración es bool t(e); está bien formado, para alguna variable temporal inventada t (§8.5). El efecto de cualquiera de las conversiones implícitas es el mismo que realizar la declaración y la inicialización y luego usar la variable temporal como resultado de la conversión.

(Lo que hace la diferencia es el uso de bool t(e); lugar de bool t = e; )

Los lugares donde se realiza esta conversión contextual a bool son:

• las condiciones de if , while , y for declaraciones;
• ¡Los operadores de la negación lógica ! , conjunción lógica && , y disyunción lógica || ;
• el operador condicional ?: ;
• la condición de static_assert ;
• la expresión constante opcional del especificador de excepción noexcept ;

Answer 2

La pregunta original era

¿Se considera esto una buena práctica?

El problema con la conversión segura de bools era muy relevante en la práctica, pero afortunadamente ahora ha sido abordado por las normas.

Pero el juicio si este enfoque es apropiado, es una cuestión de diseño.

Al introducir dicha "verificación de validez", efectivamente está declarando que sus objetos pueden estar en un estado no válido. Es decir, hablando en términos de informática, agregó un nuevo valor separado al dominio de valor representado por sus objetos. Un llamado valor inferior

El ejemplo más prominente para un dominio de valor con esa propiedad es el puntero. Un puntero puede referirse a varias ubicaciones de memoria, pero también puede ser NULL (no válido).

Por lo tanto, debemos preguntarnos: ¿ese valor de fondo realmente refleja la naturaleza de las cosas que queremos modelar con nuestras clases y , realmente necesitamos cubrir este aspecto de la naturaleza dentro de nuestro modelo?

La experiencia muestra que los valores más bajos tienden a ser propensos a errores, fáciles de olvidar y generalmente más un pasivo que un activo. Si puede organizar su código de manera que sus objetos no puedan ser inválidos, su código se vuelve más simple, más fácil de leer, entender y mantener.

Answer 3

No , un simple operador de conversión de bools no lo es, ya que ahora puede hacer comparaciones erróneas entre tipos no relacionados . En general, sí, una función de conversión es un bien. Solo usa el correcto (idioma de seguridad ). No puedo explicarlo mejor que los enlaces dados.