enable_if bei überladenen Operatoren mit unterschiedlichem Rückgabetyp

Question

Ich versuche, im Grunde 3 Dinge auf einmal hier zu tun: Überladen der Zuweisung Operator mit einer Vorlage, beschränken die Typen (mit boost::enable_if), und mit einem bestimmten Rückgabetyp.

Hier ein Beispiel:

template <class T>
std::string operator =(T t) {  return "some string"; }

Jetzt, nach dem Aufschwung enable_if (Abschnitt 3, Aufzählungspunkt 1), müsste ich enable_if als Rückgabetyp verwenden, da ich einen Operator überlade, der nur ein Argument annehmen kann. Ich möchte jedoch, dass der Rückgabetyp eine Zeichenkette ist und daher nicht unbedingt denselben Typ wie das Vorlagenargument hat.

Ich möchte enable_if verwenden, einfach weil ich möchte, dass die Vorlage einfach übersprungen wird, wenn es kein gültiger Typ ist (und keinen Fehler auslöst).

Hat jemand eine Idee, wie man das bewerkstelligen kann?

Answer 1

#include <iostream>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/contains.hpp>

class FooBar
{
public:
    FooBar () {}
    ~FooBar () {}

    template <typename T>
    typename boost::enable_if <
        typename boost::mpl::contains <
            boost::mpl::vector<std::string, int>, T>::type,
            std::string>::type
    operator = (T v)
    {
        return "some string";
    }
};

int
main ()
{
    FooBar bar;
    bar = 1;
    bar = std::string ("foo");
    // bar = "bar"; // This will give a compilation error because we have enabled
                    // our operator only for std::string and int types.
}