c++ - forest - train caret

c++ convierte la clase a booleano

Question

Con todos los tipos fundamentales de C ++, uno puede simplemente consultar:

if(varname)

y el tipo se convierte en un booleano para su evaluación. ¿Hay alguna forma de replicar esta funcionalidad en una clase definida por el usuario? Una de mis clases está identificada por un entero, aunque tiene otros miembros, y me gustaría poder verificar si el entero está establecido en NULL de esa manera.

Gracias.

Answer 1

C ++ comprueba si el resultado de las sentencias es si es igual a cero o no. Así que creo que puedes definir un operador de igualdad para tu clase y definir cómo tu clase será diferente de cero en qué condiciones.

Answer 2

Como han dicho otros, usar operator int () o operator bool () es una mala idea debido a las conversiones que permite. Usar un puntero es mejor idea La solución mejor conocida para este problema hasta ahora es devolver un puntero de miembro (función):

class MyClass {
void some_function () {}
typedef void (MyClass:: * safe_bool_type) ();
operator safe_bool_type () const
{ return cond ? &MyClass::some_function : 0; }
};

Answer 3

El enfoque de C ++ 11 es:

struct Testable
{
explicit operator bool() const
{ return false; }
};
int main ()
{
Testable a, b;
if (a) { /* do something */ } // this is correct
if (a == b) { /* do something */ } // compiler error
}

Observe la palabra clave explicit que evita que el compilador se convierta implícitamente.

Answer 4

Puede definir un operador de conversión definido por el usuario. Esta debe ser una función miembro, por ejemplo:

class MyClass {
operator int() const
{ return your_number; }
// other fields
};

También puede implementar el operador bool. Sin embargo, SOLO sugeriría que no lo haga porque su clase será utilizable en expresiones aritméticas que pueden llevar rápidamente a un desastre. IOStreams define, por ejemplo, la conversión a void* . Puede probar void* de la misma manera que puede probar un bool , pero no hay conversiones implícitas definidas por idioma de void* . Otra alternativa es definir operator! Con la semántica deseada.

En resumen: la definición de tipos de enteros del operador de conversión sto (incluidos los booleanos) es REALMENTE una mala idea.

Answer 5

Simplemente implemente el operator bool() para su clase.

p.ej

class Foo
{
public:
Foo(int x) : m_x(x) { }
operator bool() const { return (0 != m_x); }
private:
int m_x;
}
Foo a(1);
if (a) { // evaluates true
// ...
}
Foo b(-1);
if (b) { // evaluates true
// ...
}
Foo c(0);
if (c) { // evaluates false
// ...
}