Ich habe derzeit einemap<int, std::wstring>Aus Gründen der Flexibilität möchte ich in der Lage sein, einen Lambda-Ausdruck zuzuweisen, der zurückkehrtstd::wstring als Wert in der Karte.

Also habe ich diese Template-Klasse erstellt:

template <typename T>
class ValueOrFunction
{
private:
    std::function<T()> m_func;
public:
    ValueOrFunction() : m_func(std::function<T()>()) {}
    ValueOrFunction(std::function<T()> func) : m_func(func) {}
    T operator()() { return m_func(); }
    ValueOrFunction& operator= (const T& other)
    {
        m_func = [other]() -> T { return other; };
        return *this;
    }
};

und benutze es wie:

typedef ValueOrFunction<std::wstring> ConfigurationValue;
std::map<int, ConfigurationValue> mymap;

mymap[123] = ConfigurationValue([]() -> std::wstring { return L"test"; });
mymap[124] = L"blablabla";
std::wcout << mymap[123]().c_str() << std::endl; // outputs "test"
std::wcout << mymap[124]().c_str() << std::endl; // outputs "blablabla"

Jetzt möchte ich den Konstruktor nicht mehr zum Umschließen des Lambda verwenden, also habe ich beschlossen, einen zweiten Zuweisungsoperator hinzuzufügen, diesmal für dasstd::function:

ValueOrFunction& operator= (const std::function<T()>& other)
{
    m_func = other;
    return *this;
}

Dies ist der Punkt, an dem sich der Compiler beschwert. Die Liniemymap[124] = L"blablabla"; führt plötzlich zu diesem Fehler:

Fehler C2593: 'operator = is ambiguous'

IntelliSense bietet einige weitere Informationen:

Mehr als ein Operator "=" entspricht diesen Operanden: Funktion "ValueOrFunction :: operator = (const std :: function & other) [mit T = std :: wstring]" Funktion "ValueOrFunction :: operator = (const T & other) [mit T = std :: wstring] "sind folgende Operandentypen: ConfigurationValue = const wchar_t [10] c: \ projects \ beta \ CppTest \ CppTest \ CppTest.cpp 37 13 CppTest

Meine Frage ist also, warum der Compiler nicht unterscheiden kannstd::function<T()> undT? Und wie kann ich das beheben?