enable_if y operador de conversión?

Question

Hay alguna posibilidad de usar enable_if con un operador de conversión de tipo? Parece complicado, ya que tanto el tipo de retorno y los parámetros de la lista están implícitos.

Answer 1

documentación :
No parece ser una forma de especificar un facilitador para un operador de conversión. La conversión de los constructores, sin embargo, puede tener como facilitadores de los argumentos por defecto adicionales.

Answer 2

A partir de la poca investigación que hice (e ignorando el comentario ++ 0x de Johannes c), mi respuesta es que depende de lo que quiere el enable_if para. Si desea que la operación de conversión a T que existe o no del tipo T entonces parece que la respuesta es no, no hay forma en C ++ 03 (como se dijo Ugo). Pero si usted necesita el enable_if para cambiar el Comportamiento del operador dependiendo del tipo de T entonces sí, hay una solución que es llamar a una habilitado ayudante de función (llamada to<T> como se sugiere Matthieu).

#include<iostream>
#include<boost/utility/enable_if.hpp>
#include<boost/type_traits/is_class.hpp>

struct B{
    B(const B& other){}
    B(){}
};

struct A{
    template<class T>
    T to(typename boost::enable_if_c<not boost::is_class<T>::value, void*>::type = 0){
        std::clog << "converted to non class" << std::endl;
        return T(0);
    }
    template<class T>
    T to(typename boost::enable_if_c<boost::is_class<T>::value, void*>::type = 0){
        std::clog << "conveted to class" << std::endl;
        return T();
    }
    template<class T>
    operator T(){
        return to<T>();
    }
};

int main(){
    A a;
    double d = (double)a; // output: "converted to non class"
    B b = (B)(a); // output: "converted to class"
    return 0;
}

Para el registro, estaba frustrado con esto durante varios días, hasta que me di cuenta que quería enable_if no para SFINAE pero para el cambio de comportamiento en tiempo de compilación. También puede encontrar que esta es la verdadera razón de su necesidad de enable_if también. Sólo una sugerencia.

(Tenga en cuenta que esta es una respuesta para el C ++ 98 era)

Answer 3

Aunque puedo entender el interés theoritecal en la pregunta, yo personalmente se abstenga de utilizar operadores de conversión tanto como sea posible.

El único que ha consumido alguna vez con la consistencia es la conversión de un pseudo-booleano (usando el lenguaje Bool seguro), por inteligentes triples o apoderados, y como se señaló utilizo un truco para evitar que la realidad completa semántica booleano .. .

Si alguna vez quiero para facilitar las conversiones, me gusta mucho más algo a lo largo de la línea:

template <class T>
T to() const;

que no sufre de las limitaciones (en términos de firma) del operador de conversión y requiere la invocación explícita, sólo porque es un poco más claro.

Answer 4

En realidad, he encontrado una manera; utilizamos una clase privada, no utilizada para marcar una conversión que no debería existir, y usamos boost::mpl::if_ para seleccionar si desea producir una conversión a NoConversion, o al tipo deseado.

class A {
    class NoConversion { };
    template<class B> operator typename boost::mpl::if_<Cond, B, NoConversion>::type() const;
}