Strange Habitable_if Computamiento usando clases anidadas (MSVC Compiler Bug o Feature?)

Question

Después de un poco de tiempo, depurando mi código, seguí rastreado la razón de mis problemas a algunos resultados de especialización de plantillas inesperadas usando habetable_if:

El siguiente código falla la afirmación en Dotest () en Visual Studio 2010 (y 2008), mientras que no en G ++ 3.4.5. Sin embargo, cuando quito la plantilla de someclass o mudanza my_condition fuera del alcance de someclass funciona en MSVC, también.

¿Hay algo incorrecto con este código que explique este comportamiento (al menos parcialmente) o es este un error en el compilador MSVC?

(Uso de este código de ejemplo Es lo mismo para BOOST y la versión C ++ 0X STL)

#include <cassert>
#include <boost\utility\enable_if.hpp>

template <class X>
class SomeClass {
public:
    template <class T>
    struct my_condition {
        static const bool value = true;
    };

    template <class T, class Enable = void> 
    struct enable_if_tester { 
        bool operator()() { return false; }
    };

    template <class T>
    struct enable_if_tester<T, typename boost::enable_if< my_condition<T> >::type> { 
        bool operator()() { return true; }
    };

    template <class T>
    void DoTest() {
        enable_if_tester<T> test;
        assert( test() );
    }
};

int main() {
    SomeClass<float>().DoTest<int>();
    return 0;
}

---

Al intentar solucionarlo moviendo la condición de la alcance, también noté que esto no es suficiente cuando se usa STD :: Enable_if, pero al menos funciona con Boost :: Enable_if:

#include <cassert>
//#include <boost\utility\enable_if.hpp>
#include <type_traits>

template <class T, class X>
struct my_condition {
    static const bool value = true;
};

template <class X>
class SomeClass {
public:
    template <class T, class Enable = void> 
    struct enable_if_tester { 
        bool operator()() { return false; }
    };

    template <class T>
    //struct enable_if_tester<T, typename boost::enable_if< my_condition<T, X> >::type> { 
    struct enable_if_tester<T, typename std::enable_if< my_condition<T, X>::value >::type> { 
        bool operator()() { return true; }
    };

    template <class T>
    void DoTest() {
        enable_if_tester<T> test;
        assert( test() );
    }
};

int main() {
    SomeClass<float>().DoTest<int>();
    return 0;
}

Espero que alguien tenga una explicación para esto.

Answer 1

Todo está bien con su código, es solo que VC es Buggy.Se sabe que tiene problemas con la especialización parcial de la plantilla de las clases de miembros de la plantilla.