enable_if et opérateur de conversion?

Question

Toute chance d'utiliser enable_if avec un opérateur de conversion de type? Il semble difficile, puisque les deux type de retour et la liste des paramètres sont implicites.

Answer 1

documentation :
Il ne semble pas être un moyen de spécifier un catalyseur pour un opérateur de conversion. La conversion des constructeurs, peut cependant avoir habilitants comme arguments par défaut supplémentaires.

Answer 2

De la petite recherche je l'ai fait (et en ignorant le c ++ 0x commentaire de Johannes), ma réponse est que cela dépend de ce que vous voulez que le enable_if pour. Si vous souhaitez que l'opération de conversion en T d'exister ou non à partir du type T alors il semble que la réponse est non, il n'y a aucun moyen en C ++ 03 (comme Ugo dit). Mais si vous avez besoin enable_if pour changer le comportement de l'opérateur en fonction du type de T alors oui, il existe une solution qui consiste à appeler une fonction activée aide (appelée to<T> comme Matthieu suggéré).

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

Pour mémoire, je frustré par cela pendant plusieurs jours, jusqu'à ce que je compris que je voulais enable_if pas SFINAE mais pour la compilation des changements de comportement. Vous pouvez également constater que c'est la vraie raison de votre besoin de enable_if aussi. Juste une suggestion.

(S'il vous plaît noter que ceci est une réponse à l'ère de C ++ 98)

Answer 3

Alors que je peux comprendre l'intérêt theoritecal dans la question, je me abstiens personnellement d'utiliser les opérateurs de conversion, autant que possible.

Le seul que j'ai jamais utilisé avec les Consistence est la conversion à un pseudo-booléenne (en utilisant l'idiome Safe Bool), pour les smart-pointeurs ou proxies, et comme il est indiqué que j'utiliser une astuce pour empêcher effectivement la pleine booléenne sémantique .. .

Si je veux toujours pour faciliter les conversions, je préfère quelque chose le long de la ligne de:

template <class T>
T to() const;

qui ne souffre pas des limitations (en terme de signature) de l'opérateur de conversion et nécessite l'invocation explicite, juste parce qu'il est un peu plus clair.

Answer 4

En fait, je l'ai trouvé un moyen; nous utilisons une classe privée, utilisé pour marquer une conversion qui ne devrait pas exister, et nous utilisons boost::mpl::if_ pour choisir de produire une conversion à NoConversion, ou le type désiré.

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