enable_if und Konvertierungsoperator?

Question

Jede Chance zu nutzen enable_if mit einem Typ Konvertierungsoperator? Scheint kompliziert, da beide Rückgabetyp und Parameterliste implizit sind.

Answer 1

dixit der Dokumentation :
Es scheint nicht ein Weg, um einen Enabler für einen Konvertierungsoperator angeben. Konvertieren Konstrukteure können jedoch Enabler als zusätzliche Standard-Argumente haben.

Answer 2

Von der wenig Forschung ich habe (und ignoriert den c ++ 0x Kommentar von Johannes), meine Antwort ist, dass es hängt davon ab, was Sie die enable_if für wollen. Wenn Sie die Umwandlungsoperation zu T existieren oder nicht vom Typ T wollen, dann scheint es, dass die Antwort nein ist, da in C keine Möglichkeit gibt, ++ 03 (wie Ugo sagte). Aber wenn Sie die enable_if müssen die Verhalten ändern des Bedieners von der Art der T abhängig dann ja, gibt es eine Abhilfe, die ein aktiviertes zu nennen ist Helferfunktion (genannt to<T> als Matthieu vorgeschlagen).

#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;
}

Für die Aufzeichnung wurde ich mit dieser für mehrere Tage frustriert, bis ich erkennen, dass ich enable_if nicht für SFINAE aber für Kompilierung-Verhalten ändern wollte. Sie finden auch, dass dies der wahre Grund für Ihren Bedarf an enable_if auch. Nur ein Vorschlag.

(Bitte beachten Sie, dass dies eine Antwort für die C ++ 98-Ära)

Answer 3

Während ich das theoritecal Interesse an der Frage verstehen, ich persönlich verzichten auf Umwandlung Betreiber so viel wie möglich.

Die einzigen, die ich je mit Konsistenz verwenden ist die Umwandlung in einen pseudo-boolean (das sicheren Bool Idiom verwenden) für Smart-Pointer oder Proxies, und wie bereits erwähnt verwende ich einen Trick, um tatsächlich die vollständige boolean semantische verhindern .. .

Wenn ich jemals Conversions erleichtern will, muss ich viel lieber etwas entlang der Linie:

template <class T>
T to() const;

, die von den Beschränkungen nicht (in der Bezeichnung der Unterschrift) leiden des Umwandlungsoperators und erfordern expliziten Aufruf, nur weil es etwas klarer ist.

Answer 4

Eigentlich habe ich einen Weg gefunden; wir verwenden, um eine private, nicht verwendete Klasse eine Umwandlung zu markieren, die nicht existieren sollten, und wir verwenden boost::mpl::if_ um auszuwählen, ob eine Umstellung auf NoConversion, oder auf die gewünschte Art zu erzeugen.

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