¿Por qué las variables de miembros estáticos no funcionan bien con el operador ternario?

Question

Este es el trato. Tengo una clase estática que contiene varias funciones estáticas utilizadas para obtener entrada. La clase contiene una variable miembro privada estática para indicar si el usuario ingresó alguna información. Cada método de entrada comprueba si el usuario ingresó alguna información y establece la variable de estado en consecuencia. Creo que este sería un buen momento para usar el operador ternario. Lamentablemente, no puedo, porque al compilador no le gusta eso.

He replicado el problema, luego simplifiqué mi código tanto como fue posible para hacerlo más fácil de entender. Este no es mi código original.

Aquí está mi archivo de cabecera:

#include <iostream> 

using namespace std; 

class Test { 
public: 
    void go(); 
private: 
    static const int GOOD = 0; 
    static const int BAD = 1; 
}; 

Aquí está mi aplicación con el operador ternario:

#include "test.h" 

void Test::go() { 
    int num = 3; 
    int localStatus; 
    localStatus = (num > 2) ? GOOD : BAD; 
} 

Aquí es función principal:

#include <iostream> 
#include "test.h" 

using namespace std; 

int main() { 
    Test test = Test(); 
    test.go(); 
    return 0; 
} 

Cuando intento compilar esto, recibe este mensaje de error:

test.o: In function `Test::go()': 
test.cpp:(.text+0x17): undefined reference to `Test::GOOD' 
test.cpp:(.text+0x1f): undefined reference to `Test::BAD' 
collect2: ld returned 1 exit status 

Sin embargo, si reemplazo esto:

localStatus = (num > 2) ? GOOD : BAD; 

con esto:

if (num > 2) { 
    localStatus = GOOD; 
} else { 
    localStatus = BAD; 
} 

El código se compila y se ejecuta como se esperaba. ¿Qué oscura regla de C++ o caso de esquina de GCC es responsable de esta locura? (Estoy usando GCC 4.4.1 en Ubuntu 9.10.)

Answer 1

Esto es de acuerdo con el estándar C++. El operador ternario constituye un único valor l que se referirá a GOOD o BAD en tiempo de ejecución.La conversión lvalue a rvalue no se aplica inmediatamente a lvalue GOOD o BAD, y para ello necesita una definición de GOOD y BAD.

Consulte el informe de problemas del lenguaje central http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#712.

Como solución alternativa, se puede aplicar conversiones explícitas a int (que lee sus valores, haciendo con ello un valor-I a la conversión rvalue) o utilizar un operador que lee el valor, como +:

localStatus = (num > 2) ? +GOOD : +BAD; 

Answer 2

class Test { 
    static const int GOOD = 0; 
    static const int BAD = 1; 
}; 

Estos son sólo declaraciones ; no son definiciones. Es necesario proporcionar definiciones de las variables miembro estáticas, fuera de la definición de la clase, en una de sus archivos .cpp:

const int Test::GOOD; 
const int Test::BAD; 

Alternativamente, para constantes enteras, a menudo es más conveniente usar un enum:

class Test { 
    enum { 
     GOOD = 0, 
     BAD = 1 
    }; 
}; 

Answer 3

Su código se ve bien para mí. Y ideone está de acuerdo: ver this link. Pero eso es con gcc-4.3.4. Sin embargo, mi gcc-4.4.0 no lo acepta. Entonces, sea cual sea el motivo, no es obvio.

Editado para agregar: La siguiente variante compila bajo gcc-4.4.0:

int localStatus = 42 ? GOOD : BAD; 

Recordatorio: el siguiente código no se compila:

int localStatus = (num == 42) ? GOOD : BAD; 

Así que alguien ha metido la pata algun lado.