Editar: La respuesta corta a mi pregunta es que tuve una visión errónea de lo que SFINAE puede hacer y no verifica el cuerpo de la función en absoluto:sfinae crea una instancia del cuerpo de una función?

Tengo un problema similar a este:¿Es posible escribir una plantilla para verificar la existencia de una función?

La diferencia es que no solo quiero comprobar si la función existe, sino que también quiero saber si realmente pasará el SFINAE. Aquí hay un ejemplo de lo que estoy tratando de lograr:

struct A
{
    void FuncA() { std::cout << "A::FuncA" << std::endl; }
};

struct B
{
    void FuncA() { std::cout << "B::FuncA" << std::endl; }
    void FuncB() { std::cout << "B::FuncB" << std::endl; }
};

template<typename T>
struct Inter
{
    void FuncA() { t.FuncA(); }
    void FuncB() { t.FuncB(); }

    T t;
};

// Always takes some sort of Inter<T>.
template<typename InterType>
struct Final
{
    void CallFuncs()
    {
        // if( t.FuncA() exists and can be called )
            t.FuncA();

        // if( t.FuncB() exists and can be called )
            t.FuncB();
    }

    InterType t;
};

void DoEverything()
{
    Final<Inter<A>> finalA;
    Final<Inter<B>> finalB;

    finalA.CallFuncs();
    finalB.CallFuncs();
}

Tenga en cuenta que en CallFuncs (), tanto FuncA () como FuncB () siempre existirán, pero es posible que no se compilen dependiendo del tipo T utilizado en Inter. Cuando intenté usar la respuesta en la pregunta anterior, parecía que siempre me daba la verdad, lo que supongo es porque solo se está comprobando que la función existe, no que realmente se puede compilar (aunque no puedo descartar eso). No arruiné algo ...)

Para poder llamar condicionalmente a las funciones, imagino que puedo usar enable_if como tal:

template<typename InterType>
typename std::enable_if< ! /* how to determine if FuncA can be called? */>::type TryCallFuncA( InterType& i )
{
}
template<typename InterType>
typename std::enable_if</* how to determine if FuncA can be called? */>::type TryCallFuncA( InterType& i )
{
    i.FuncA();
}

template<typename InterType>
typename std::enable_if< ! /* how to determine if FuncB can be called? */>::type TryCallFuncB( InterType& i )
{
}
template<typename InterType>
typename std::enable_if</* how to determine if FuncB can be called? */>::type TryCallFuncB( InterType& i )
{
    i.FuncB();
}

template<typename InterType>
struct Final
{
    void CallFuncs()
    {
        TryCallFuncA(t);
        TryCallFuncB(t);
    }

    InterType t;
};

pero no estoy seguro de si hay alguna manera de obtener un valor booleano para pasar a enable_if. ¿Hay alguna forma en que pueda lograr esto o debo recurrir a algún tipo de rasgos de tipo mantenidos manualmente que indiquen si las funciones existen?

Por lo que vale la pena en cuanto al conjunto de funciones disponibles de C ++ 11, estoy usando MSVC 2010.

editar: Para agregar una nota importante, en mi situación real, la implementación de la clase Inter es efectivamente opaca en el punto en el que necesito determinar si Inter :: FuncA / FuncB se compilará o no, por lo que no puedo mejorar los tipos secundarios y comprobar la existencia de la función en ellos.