2011-01-05 22 views

Respuesta

98

Las funciones miembro de la forma

operator TypeName() 

son operadores de conversión. Permiten que los objetos del tipo de clase se usen como si fueran del tipo TypeName y cuando lo son, se convierten a TypeName usando la función de conversión. En este caso particular, operator bool() permite utilizar un objeto del tipo de clase como si fuera bool. Por ejemplo, si tiene un objeto del tipo de clase llamado obj, puede utilizarlo como

if (obj) 

Esto llamará al operator bool(), devolver el resultado, y utilizar el resultado como la condición de la if.

Cabe señalar que operator bool() es una muy mala idea y nunca deberías usarla. Para una explicación detallada de por qué es malo y para la solución del problema, vea "The Safe Bool Idiom."

(C++ 0x, la próxima revisión del Estándar C++, agrega soporte para operadores de conversión explícitos. Estos le permitirán escribir una caja fuerte explicit operator bool() que funciona correctamente sin tener que saltar a través de los aros de la aplicación de la seguridad Bool Idiom.)

+2

+1 por referencia a Segura Bool Idiom – greyfade

+1

"se usa como si fuera un bool" falsamente implica que podría, por ejemplo, asignarle un valor booleano. Más bien, en el código del póster, genera una variable temporal de tipo bool que se relaciona con el valor momentáneo de col, pero a partir de entonces es independiente del objeto que lo creó. Además, la mención de Safe Bool Idiom es genial, pero solo para registrar que existen opiniones contrarias: en mi humilde opinión, el consejo de "nunca realmente lo uso" es exagerado: ofrece comprobaciones de compilador más estrictas contra el uso incorrecto a costa de una API más ofuscada eso puede conducir a un uso indebido accidental. –

+1

@Tony: Bueno, se puede usar como si fuera un bool; dado que el resultado de la conversión es un valor r ('bool'), no, no se puede asignar a él. Si fuera un valor l modificable (por ejemplo, 'bool &'), podría asignarlo. En cuanto a la corrección, defiendo que un 'operador bool()' siempre es incorrecto porque permite el uso de un objeto de clase en un gran número de situaciones donde nunca se quiere que se use. Safe Bool es una alternativa muy superior. –

1

Es una conversión implícita a bool. Es decir. siempre que se permitan las conversiones implícitas, su clase se puede convertir a bool llamando a ese método.

3

Es función de conversión definida por el usuario implicit para convertir su clase en true o false.

//usage 
bool value = yourclassinstance; //yourclassinstance is converted into bool! 
0

Como los otros han dicho, es para la conversión de tipos, en este caso a un bool. Por ejemplo:

class A { 
    bool isItSafe; 

public: 
    operator bool() const 
    { 
     return isItSafe; 
    } 

    ... 
}; 

ahora puedo usar un objeto de esta clase como si se trata de un valor lógico:

A a; 
... 
if (a) { 
    .... 
} 
8
operator bool() const 
{ 
    return col != 0; 
} 

define la forma en la clase es convertible en un valor booleano, el const después de la () se usa para indicar que este método no cambia (cambia los miembros de esta clase).

que se suele utilizar dichos operadores de la siguiente manera:

airplaysdk sdkInstance; 
if (sdkInstance) { 
    std::cout << "Instance is active" << std::endl; 
} else { 
    std::cout << "Instance is in-active error!" << std::endl; 
} 
-1

Otro uso común es para contenedores std hacer comparación de igualdad en los valores clave dentro de los objetos personalizados

class Foo 
{ 
    public: int val; 
}; 

class Comparer { public: 
bool operator() (Foo& a, Foo&b) const { 
return a.val == b.val; 
}; 

class Blah 
{ 
std::set< Foo, Comparer > _mySet; 
}; 
+0

Este es el ejemplo que utiliza 'operator()' not 'operator bool'. Ellos son totalmente diferentes. 'operator()' es el operador de llamada, de modo que un 'Comparer' se puede llamar como una función. Ese 'operador()' simplemente devuelve 'bool', pero eso no lo hace igual que' operator bool', que simplemente permite un molde implícito a 'bool'. – anthropomorphic

4

Me gustaría dar más códigos para dejarlo en claro.

struct A 
{ 
    operator bool() const { return true; } 
}; 

struct B 
{ 
    explicit operator bool() const { return true; } 
}; 

int main() 
{ 
    A a1; 
    if (a1) cout << "true" << endl; // OK: A::operator bool() 
    bool na1 = a1; // OK: copy-initialization selects A::operator bool() 
    bool na2 = static_cast<bool>(a1); // OK: static_cast performs direct-initialization 

    B b1;  
    if (b1) cout << "true" << endl; // OK: B::operator bool() 
    // bool nb1 = b1; // error: copy-initialization does not consider B::operator bool() 
    bool nb2 = static_cast<bool>(b1); // OK: static_cast performs direct-initialization 
}