Atualmente tenho ummap<int, std::wstring>, mas para flexibilidade, eu quero ser capaz de atribuir uma expressão lambda, retornandostd::wstring como valor no mapa.

Então eu criei essa classe de modelo:

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

e usá-lo como:

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"

Agora, eu não quero usar o construtor para envolver o lambda, então eu decidi adicionar um segundo operador de atribuição, desta vez para ostd::function:

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

Este é o ponto em que o compilador começa a reclamar. A linhamymap[124] = L"blablabla"; de repente resulta nesse erro:

erro C2593: 'operator = é ambíguo'

O IntelliSense fornece mais algumas informações:

mais de um operador "=" corresponde a esses operandos: function "ValueOrFunction :: operator = (const std :: function e outros) [com T = std :: wstring]" função "ValueOrFunction :: operator = (const T & other) [com T = std :: wstring] "tipos de operando são: ConfigurationValue = const wchar_t [10] c: \ projetos \ beta \ CppTest \ CppTest \ CppTest.cpp 37 13 CppTest

Então, minha pergunta é: por que o compilador não consegue distinguir entrestd::function<T()> eT? E como posso consertar isso?