¿Por qué gcc no avisa cuando se pasa un valor enum o int como un argumento de función que es bool?

Question

He siguiente código:

typedef enum 
{ 
    FOO, 
    BAR, 
    BAZ 
} foo_t; 

static void afunc(bool is_it_on) 
{ 
    /* do the job */ 
} 

int main(void) 
{ 
    afunc(BAZ); 
    return 0; 
} 

Compilar este código no genera ningún mensaje de advertencia, incluso con -Wall -Wextra opciones que se ofrecen al compilador. Incluso he intentado con la opción -Wconversion, que no tuvo efecto porque bool y enum parecían ser del mismo tamaño para g ++. (el tamaño del tipo enum no está definido en la especificación hasta donde yo sé)

He peinado a través del manual de gcc y no he encontrado nada al respecto.

Preguntas:

• ¿Hay una manera de forzar al compilador que genere una advertencia en casos como este?
• ¿O es que este casting implícito es legal por especificación C++?

compilador que estoy usando: gcc 4.1.2

---

Editted

Conclusión:

La única solución viable a este parece definir un nuevo tipo para representar 0 o 1, y úselo en lugar de bool.

el código sería como seguir, y g ++ se queja de conversión de tipo:

typedef enum 
{ 
    FOO1, 
    FOO2 
} foo_t; 

typedef enum 
{ 
    MY_FALSE, 
    MY_TRUE 
} my_bool_t; 

void foo(my_bool_t a) 
{ 
} 

int main(void) 
{ 
    /* 
     * gcc generates an error. 
     * error: cannot convert ‘foo_t’ to ‘my_bool_t’ 
     * for argument ‘1’ to ‘void foo(my_bool_t)’ 
     */ 
    foo(FOO1); 
    return 0; 
} 

Answer 1

Sí, esas conversiones implícitas son perfectamente legal.

C++ 11 proyectos de n3290, §4.12 conversiones booleanas:

A prvalue de la aritmética, la enumeración sin ámbito, puntero, o puntero a tipo de miembro se puede convertir en un prvalue de tipo bool. Un valor cero, un valor de puntero nulo o un valor de puntero de miembro nulo se convierte en falso; cualquier otro valor se convierte en verdadero. Un prvalue de tipo std :: nullptr_t se puede convertir a un prvalue de type bool; el valor resultante es falso.

Las advertencias sobre estas conversiones (para los tipos aritméticos) probablemente darían lugar a un gran número de advertencias en todo el lugar, no creo que sea manejable.

En C++ 11, puede utilizar con ámbito enumeraciones para evitar que la conversión implícita:

Esta falla al compilar por falta de una conversión de Foo a bool:

enum class Foo { ONE }; 

void tryit(bool b) { } 

int main() 
{ 
    tryit(Foo::ONE); 
}